Specify GetResultInst index as an unsigned.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47390 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 24 insertions, 21 deletions

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 4f1222f..c061a4a 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -2348,27 +2348,28 @@ public:
 /// aggregate value, where aggregate value is returned by CallInst.
 ///
 class GetResultInst : public Instruction {
-  Use Ops[2];
+  Use Aggr;
+  unsigned Idx;
   GetResultInst(const GetResultInst &GRI) :
-    Instruction(GRI.getType(), Instruction::GetResult, Ops, 2) {
-    Ops[0].init(GRI.Ops[0], this);
-    Ops[1].init(GRI.Ops[1], this);
+    Instruction(GRI.getType(), Instruction::GetResult, &Aggr, 1) {
+    Aggr.init(GRI.Aggr, this);
+    Idx = GRI.Idx;
   }
 
 public:
-  explicit GetResultInst(Value *Aggr, Value *Index, 
+  explicit GetResultInst(Value *Aggr, unsigned index,
                          const std::string &Name = "",
                          Instruction *InsertBefore = 0);
 
   /// isValidOperands - Return true if an getresult instruction can be
   /// formed with the specified operands.
-  static bool isValidOperands(const Value *Aggr, const Value *Idx);
+  static bool isValidOperands(const Value *Aggr, unsigned index);
   
   virtual GetResultInst *clone() const;
   
   // getType - Get aggregate value element type
   inline const Type *getType() const {
-    return Ops[0]->getType();
+    return Aggr->getType();
   }
   
   inline Value *getAggregateValue() {
@@ -2379,11 +2380,11 @@ public:
     return getOperand(0);
   }
 
-  const Value *getIndex() {
-    return getOperand(1);
+  unsigned getIndex() {
+    return Idx;
   }
 
-  unsigned getNumOperands() const { return 2; }
+  unsigned getNumOperands() const { return 1; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GetResultInst *) { return true; }
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index 9e9da47..effe097 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -3132,7 +3132,7 @@ MemoryInst : MALLOC Types OptCAlign {
     $$ = new StoreInst($3, tmpVal, $1, $7);
     delete $5;
   }
-| GETRESULT Types LocalName ',' ConstVal  {
+| GETRESULT Types LocalName ',' EUINT64VAL  {
   ValID TmpVID = ValID::createLocalName(*$3);
   Value *TmpVal = getVal($2->get(), TmpVID);
   if (!GetResultInst::isValidOperands(TmpVal, $5))
diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 65bc183..d700902 100644
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -2705,23 +2705,25 @@ void SwitchInst::setSuccessorV(unsigned idx, BasicBlock *B) {
 //                           GetResultInst Implementation
 //===----------------------------------------------------------------------===//
 
-GetResultInst::GetResultInst(Value *Aggr, Value *Index,
+GetResultInst::GetResultInst(Value *Aggregate, unsigned Index,
                              const std::string &Name,
                              Instruction *InsertBef)
   : Instruction(Aggr->getType(),
-                GetResult, Ops, 2, InsertBef) {
-  assert(isValidOperands(Aggr, Index) && "Invalid GetResultInst operands!");
-  Ops[0].init(Aggr, this);
-  Ops[1].init(Index, this);
+                GetResult, &Aggr, 1, InsertBef) {
+  assert(isValidOperands(Aggregate, Index) && "Invalid GetResultInst operands!");
+  Aggr.init(Aggregate, this);
+  Idx = Index;
   setName(Name);
 }
 
-bool GetResultInst::isValidOperands(const Value *Aggr, const Value *Index) {
-  if (!Aggr || !Index)
-    return false;
-  if (!isa<StructType>(Aggr->getType()) || Index->getType() != Type::Int32Ty)
+bool GetResultInst::isValidOperands(const Value *Aggregate, unsigned Index) {
+  if (!Aggregate)
     return false;
-  return true;
+  if (const StructType *STy = dyn_cast<StructType>(Aggregate->getType())) 
+    if (Index < STy->getNumElements())
+      return true;
+
+  return false;
 }