Provide uniform access to the pointer operand and to the index

operands (if any) for different types of MemAccessInst's.


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

2 files changed, 84 insertions, 17 deletions

diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h
index 92d6a6c..f57a019 100644
--- a/include/llvm/iMemory.h
+++ b/include/llvm/iMemory.h
@@ -109,8 +109,16 @@ public:
 //
 class MemAccessInst : public Instruction {
 protected:
-  inline MemAccessInst(const Type *Ty, unsigned Opcode, const string &Nam = "") 
-    : Instruction(Ty, Opcode, Nam) {}
+  inline MemAccessInst(const Type *Ty, unsigned Opcode,
+		       const vector<ConstPoolVal*> &Idx,
+		       const string &Nam = "")
+    : Instruction(Ty, Opcode, Nam),
+      indexVec(Idx)
+  {}
+  
+protected:
+  vector<ConstPoolVal*> indexVec;
+  
 public:
   // getIndexedType - Returns the type of the element that would be loaded with
   // a load instruction with the specified parameters.
@@ -121,6 +129,16 @@ public:
   static const Type *getIndexedType(const Type *Ptr, 
 				    const vector<ConstPoolVal*> &Indices,
 				    bool AllowStructLeaf = false);
+  
+  static unsigned int getIndexedOfsetForTarget(const Type *Ptr, 
+					  const vector<ConstPoolVal*> &Indices,
+					  const TargetMachine& targetMachine);
+  
+  const vector<ConstPoolVal*>& getIndexVec() const { return indexVec; }
+  
+  virtual Value* getPtrOperand() = 0;
+  
+  virtual int	getFirstOffsetIdx() const = 0;
 };
 
 
@@ -129,7 +147,7 @@ public:
 //===----------------------------------------------------------------------===//
 
 class LoadInst : public MemAccessInst {
-  LoadInst(const LoadInst &LI) : MemAccessInst(LI.getType(), Load) {
+  LoadInst(const LoadInst &LI) : MemAccessInst(LI.getType(), Load, LI.getIndexVec()) {
     Operands.reserve(LI.Operands.size());
     for (unsigned i = 0, E = LI.Operands.size(); i != E; ++i)
       Operands.push_back(Use(LI.Operands[i], this));
@@ -137,8 +155,10 @@ class LoadInst : public MemAccessInst {
 public:
   LoadInst(Value *Ptr, const vector<ConstPoolVal*> &Idx,
 	   const string &Name = "");
-  virtual Instruction *clone() const { return new LoadInst(*this); }
-  virtual const char *getOpcodeName() const { return "load"; }  
+  virtual Instruction*	clone() const { return new LoadInst(*this); }
+  virtual const char*	getOpcodeName() const { return "load"; }  
+  virtual Value*	getPtrOperand() { return this->getOperand(0); }
+  virtual int getFirstOffsetIdx() const { return (this->getNumOperands() > 1)? 1 : -1;}
 };
 
 
@@ -147,7 +167,7 @@ public:
 //===----------------------------------------------------------------------===//
 
 class StoreInst : public MemAccessInst {
-  StoreInst(const StoreInst &SI) : MemAccessInst(SI.getType(), Store) {
+  StoreInst(const StoreInst &SI) : MemAccessInst(SI.getType(), Store, SI.getIndexVec()) {
     Operands.reserve(SI.Operands.size());
     for (unsigned i = 0, E = SI.Operands.size(); i != E; ++i)
       Operands.push_back(Use(SI.Operands[i], this));
@@ -157,8 +177,10 @@ public:
 	    const string &Name = "");
   virtual Instruction *clone() const { return new StoreInst(*this); }
   virtual const char *getOpcodeName() const { return "store"; }  
-
+  
   virtual bool hasSideEffects() const { return true; }
+  virtual Value*	getPtrOperand()	{ return this->getOperand(1); }
+  virtual int getFirstOffsetIdx() const { return (this->getNumOperands() > 2)? 2 : -1;}
 };
 
 
@@ -168,7 +190,7 @@ public:
 
 class GetElementPtrInst : public MemAccessInst {
   GetElementPtrInst(const GetElementPtrInst &EPI)
-    : MemAccessInst(EPI.getType(), GetElementPtr) {
+    : MemAccessInst(EPI.getType(), GetElementPtr, EPI.getIndexVec()) {
     Operands.reserve(EPI.Operands.size());
     for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
       Operands.push_back(Use(EPI.Operands[i], this));
@@ -178,7 +200,9 @@ public:
 		    const string &Name = "");
   virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
   virtual const char *getOpcodeName() const { return "getelementptr"; }  
-
+  virtual Value*	getPtrOperand()	{ return this->getOperand(0); }
+  virtual int getFirstOffsetIdx() const { return (this->getNumOperands() > 1)? 1 : -1;}
+  
   inline bool isArraySelector() const { return !isStructSelector(); }
   bool isStructSelector() const;
 };
diff --git a/lib/VMCore/iMemory.cpp b/lib/VMCore/iMemory.cpp
index 2f2c6c1..9c52da3 100644
--- a/lib/VMCore/iMemory.cpp
+++ b/lib/VMCore/iMemory.cpp
@@ -17,14 +17,15 @@
 // A null type is returned if the indices are invalid for the specified 
 // pointer type.
 //
-const Type *MemAccessInst::getIndexedType(const Type *Ptr, 
-					  const vector<ConstPoolVal*> &Idx,
-					  bool AllowStructLeaf = false) {
+/* static */
+const Type* MemAccessInst::getIndexedType(const Type *Ptr, 
+					const vector<ConstPoolVal*> &Idx,
+					bool AllowStructLeaf = false) {
   if (!Ptr->isPointerType()) return 0;   // Type isn't a pointer type!
  
   // Get the type pointed to...
   Ptr = ((const PointerType*)Ptr)->getValueType();
-
+  
   if (Ptr->isStructType()) {
     unsigned CurIDX = 0;
     while (Ptr->isStructType()) {
@@ -44,6 +45,46 @@ const Type *MemAccessInst::getIndexedType(const Type *Ptr,
   }
 }
 
+/* static */
+unsigned int
+MemAccessInst::getIndexedOfsetForTarget(const Type *Ptr, 
+					const vector<ConstPoolVal*> &Idx,
+					const TargetMachine& targetMachine)
+{
+  if (!Ptr->isPointerType())
+    return 0;				// Type isn't a pointer type!
+ 
+  unsigned int curOffset = 0;
+  
+  // Get the type pointed to...
+  Ptr = ((const PointerType*) Ptr)->getValueType();
+  
+  if (Ptr->isStructType()) {
+    unsigned CurIDX = 0;		// which element of Idx vector
+    while (Ptr->isStructType()) {
+      const StructType * SPtr = (StructType *) Ptr;
+      
+      if (Idx.size() == CurIDX) 
+	break;
+      
+      assert (Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx");
+      unsigned NextIdx = ((ConstPoolUInt*)Idx[CurIDX++])->getValue();
+      
+      // add the offset for the current element
+      curOffset += SPtr->getElementOffset(NextIdx, targetMachine);
+      
+      // and update Ptr to refer to current element
+      Ptr = SPtr->getElementTypes()[NextIdx];
+    }
+    return curOffset;
+  } else if (Ptr->isArrayType()) {
+    assert(0 && "Loading from arrays not implemented yet!");
+  } else {
+    assert (Idx.size() == 0 && "Indexing type that is not struct or array?");
+    return 0;				// Load directly through ptr
+  }
+}
+  
 
 //===----------------------------------------------------------------------===//
 //                           LoadInst Implementation
@@ -51,13 +92,15 @@ const Type *MemAccessInst::getIndexedType(const Type *Ptr,
 
 LoadInst::LoadInst(Value *Ptr, const vector<ConstPoolVal*> &Idx,
 		   const string &Name = "")
-  : MemAccessInst(getIndexedType(Ptr->getType(), Idx), Load, Name) {
+  : MemAccessInst(getIndexedType(Ptr->getType(), Idx), Load, Idx, Name)
+{
   assert(getIndexedType(Ptr->getType(), Idx) && "Load operands invalid!");
   Operands.reserve(1+Idx.size());
   Operands.push_back(Use(Ptr, this));
-
+  
   for (unsigned i = 0, E = Idx.size(); i != E; ++i)
     Operands.push_back(Use(Idx[i], this));
+  
 }
 
 
@@ -67,7 +110,7 @@ LoadInst::LoadInst(Value *Ptr, const vector<ConstPoolVal*> &Idx,
 
 StoreInst::StoreInst(Value *Val, Value *Ptr, const vector<ConstPoolVal*> &Idx,
 		     const string &Name = "")
-  : MemAccessInst(Type::VoidTy, Store, Name) {
+  : MemAccessInst(Type::VoidTy, Store, Idx, Name) {
   assert(getIndexedType(Ptr->getType(), Idx) && "Store operands invalid!");
   
   Operands.reserve(2+Idx.size());
@@ -88,7 +131,7 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr,
 				     const string &Name = "")
   : MemAccessInst(PointerType::getPointerType(getIndexedType(Ptr->getType(),
 							     Idx, true)),
-		  GetElementPtr, Name) {
+		  GetElementPtr, Idx, Name) {
   assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!");
   Operands.reserve(1+Idx.size());
   Operands.push_back(Use(Ptr, this));