[llvm-commits] CVS: llvm/lib/ExecutionEngine/Interpreter/Execution.cpp Interpreter.h

[Chris Lattner]

Changes in directory llvm/lib/ExecutionEngine/Interpreter:

Execution.cpp updated: 1.115 -> 1.116
Interpreter.h updated: 1.54 -> 1.55

---
Log message:

Do not depend on structure elements being of type UByteTy


---
Diffs of the changes:  (+31 -22)

Index: llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
diff -u llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.115 llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.116
--- llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.115	Thu Nov 13 00:06:01 2003
+++ llvm/lib/ExecutionEngine/Interpreter/Execution.cpp	Tue Nov 25 14:44:56 2003
@@ -15,16 +15,18 @@
 #include "llvm/Instructions.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Constants.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
 #include "Support/Statistic.h"
 #include <cmath>  // For fmod
-
-namespace llvm {
+using namespace llvm;
 
 namespace {
   Statistic<> NumDynamicInsts("lli", "Number of dynamic instructions executed");
 }
 
-Interpreter *TheEE = 0;
+namespace llvm {
+  Interpreter *TheEE = 0;
+}
 
 //===----------------------------------------------------------------------===//
 //                     Value Manipulation code
@@ -42,8 +44,8 @@
     case Instruction::Cast:
       return executeCastOperation(CE->getOperand(0), CE->getType(), SF);
     case Instruction::GetElementPtr:
-      return TheEE->executeGEPOperation(CE->getOperand(0), CE->op_begin()+1,
-					CE->op_end(), SF);
+      return TheEE->executeGEPOperation(CE->getOperand(0), gep_type_begin(CE),
+					gep_type_end(CE), SF);
     case Instruction::Add:
       return executeAddInst(getOperandValue(CE->getOperand(0), SF),
                             getOperandValue(CE->getOperand(1), SF),
@@ -601,33 +603,41 @@
 
 // getElementOffset - The workhorse for getelementptr.
 //
-GenericValue Interpreter::executeGEPOperation(Value *Ptr, User::op_iterator I,
-					      User::op_iterator E,
+GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
+					      gep_type_iterator E,
 					      ExecutionContext &SF) {
   assert(isa<PointerType>(Ptr->getType()) &&
          "Cannot getElementOffset of a nonpointer type!");
 
   PointerTy Total = 0;
-  const Type *Ty = Ptr->getType();
 
   for (; I != E; ++I) {
-    if (const StructType *STy = dyn_cast<StructType>(Ty)) {
+    if (const StructType *STy = dyn_cast<StructType>(*I)) {
       const StructLayout *SLO = TD.getStructLayout(STy);
       
       // Indices must be ubyte constants...
       const ConstantUInt *CPU = cast<ConstantUInt>(*I);
-      assert(CPU->getType() == Type::UByteTy);
       unsigned Index = CPU->getValue();
       
       Total += SLO->MemberOffsets[Index];
-      Ty = STy->getElementTypes()[Index];
-    } else if (const SequentialType *ST = cast<SequentialType>(Ty)) {
+    } else {
+      const SequentialType *ST = cast<SequentialType>(*I);
       // Get the index number for the array... which must be long type...
-      assert((*I)->getType() == Type::LongTy);
-      unsigned Idx = getOperandValue(*I, SF).LongVal;
-      Ty = ST->getElementType();
-      unsigned Size = TD.getTypeSize(Ty);
-      Total += Size*Idx;
+      GenericValue IdxGV = getOperandValue(I.getOperand(), SF);
+
+      uint64_t Idx;
+      switch (I.getOperand()->getType()->getPrimitiveID()) {
+      default: assert(0 && "Illegal getelementptr index for sequential type!");
+      case Type::SByteTyID:  Idx = IdxGV.SByteVal; break;
+      case Type::ShortTyID:  Idx = IdxGV.ShortVal; break;
+      case Type::IntTyID:    Idx = IdxGV.IntVal; break;
+      case Type::LongTyID:   Idx = IdxGV.LongVal; break;
+      case Type::UByteTyID:  Idx = IdxGV.UByteVal; break;
+      case Type::UShortTyID: Idx = IdxGV.UShortVal; break;
+      case Type::UIntTyID:   Idx = IdxGV.UIntVal; break;
+      case Type::ULongTyID:  Idx = IdxGV.ULongVal; break;
+      }
+      Total += TD.getTypeSize(ST->getElementType())*Idx;
     }
   }
 
@@ -639,7 +649,7 @@
 void Interpreter::visitGetElementPtrInst(GetElementPtrInst &I) {
   ExecutionContext &SF = ECStack.back();
   SetValue(&I, TheEE->executeGEPOperation(I.getPointerOperand(),
-                                   I.idx_begin(), I.idx_end(), SF), SF);
+                                   gep_type_begin(I), gep_type_end(I), SF), SF);
 }
 
 void Interpreter::visitLoadInst(LoadInst &I) {
@@ -912,5 +922,3 @@
     visit(I);   // Dispatch to one of the visit* methods...
   }
 }
-
-} // End llvm namespace


Index: llvm/lib/ExecutionEngine/Interpreter/Interpreter.h
diff -u llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.54 llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.55
--- llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.54	Thu Nov 13 00:06:01 2003
+++ llvm/lib/ExecutionEngine/Interpreter/Interpreter.h	Tue Nov 25 14:44:56 2003
@@ -25,6 +25,7 @@
 namespace llvm {
 
 struct FunctionInfo;        // Defined in ExecutionAnnotations.h
+class gep_type_iterator;
 
 // AllocaHolder - Object to track all of the blocks of memory allocated by
 // alloca.  When the function returns, this object is poped off the execution
@@ -152,8 +153,8 @@
 
   //FIXME: private:
 public:
-  GenericValue executeGEPOperation(Value *Ptr, User::op_iterator I,
-				   User::op_iterator E, ExecutionContext &SF);
+  GenericValue executeGEPOperation(Value *Ptr, gep_type_iterator I,
+				   gep_type_iterator E, ExecutionContext &SF);
 
 private:  // Helper functions
   // SwitchToNewBasicBlock - Start execution in a new basic block and run any