X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FiMemory.h;h=e42f5b993b85c924a66abf00169ae3ae2e76c81f;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=fd502315c4356a9422cbdd0ba33c6d2c39f60977;hpb=f150b9d984c7a8e3cf7c77bb676731e7abf8359f;p=oota-llvm.git

diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h
index fd502315c43..e42f5b993b8 100644
--- a/include/llvm/iMemory.h
+++ b/include/llvm/iMemory.h
@@ -21,7 +21,7 @@ class PointerType;
 class AllocationInst : public Instruction {
 protected:
   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, 
-		 const std::string &Name = "");
+		 const std::string &Name = "", Instruction *InsertBefore = 0);
 public:
 
   // isArrayAllocation - Return true if there is an allocation size parameter
@@ -63,12 +63,15 @@ public:
 //                                MallocInst Class
 //===----------------------------------------------------------------------===//
 
-struct MallocInst : public AllocationInst {
-  MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "")
-    : AllocationInst(Ty, ArraySize, Malloc, Name) {}
+class MallocInst : public AllocationInst {
+  MallocInst(const MallocInst &MI);
+public:
+  MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
+             Instruction *InsertBefore = 0)
+    : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {}
 
   virtual Instruction *clone() const { 
-    return new MallocInst((Type*)getType(), (Value*)Operands[0].get());
+    return new MallocInst(*this);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -86,12 +89,15 @@ struct MallocInst : public AllocationInst {
 //                                AllocaInst Class
 //===----------------------------------------------------------------------===//
 
-struct AllocaInst : public AllocationInst {
-  AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "")
-    : AllocationInst(Ty, ArraySize, Alloca, Name) {}
+class AllocaInst : public AllocationInst {
+  AllocaInst(const AllocaInst &);
+public:
+  AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
+             Instruction *InsertBefore = 0)
+    : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {}
 
   virtual Instruction *clone() const { 
-    return new AllocaInst((Type*)getType(), (Value*)Operands[0].get());
+    return new AllocaInst(*this);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -110,7 +116,7 @@ struct AllocaInst : public AllocationInst {
 //===----------------------------------------------------------------------===//
 
 struct FreeInst : public Instruction {
-  FreeInst(Value *Ptr);
+  FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
 
   virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
 
@@ -127,70 +133,6 @@ struct FreeInst : public Instruction {
 };
 
 
-//===----------------------------------------------------------------------===//
-//                              MemAccessInst Class
-//===----------------------------------------------------------------------===//
-//
-// MemAccessInst - Common base class of GetElementPtrInst...
-//
-class MemAccessInst : public Instruction {
-protected:
-  inline MemAccessInst(const Type *Ty, unsigned Opcode,
-		       const std::string &Nam = "")
-    : Instruction(Ty, Opcode, Nam) {}
-public:
-  // getIndexedType - Returns the type of the element that would be loaded with
-  // a load instruction with the specified parameters.
-  //
-  // A null type is returned if the indices are invalid for the specified 
-  // pointer type.
-  //
-  static const Type *getIndexedType(const Type *Ptr, 
-				    const std::vector<Value*> &Indices,
-				    bool AllowStructLeaf = false);
-
-  inline op_iterator       idx_begin()       {
-    return op_begin()+getFirstIndexOperandNumber();
-  }
-  inline const_op_iterator idx_begin() const {
-    return op_begin()+getFirstIndexOperandNumber();
-  }
-  inline op_iterator       idx_end()         { return op_end(); }
-  inline const_op_iterator idx_end()   const { return op_end(); }
-
-
-  std::vector<Value*> copyIndices() const {
-    return std::vector<Value*>(idx_begin(), idx_end());
-  }
-
-  Value *getPointerOperand() {
-    return getOperand(getFirstIndexOperandNumber()-1);
-  }
-  const Value *getPointerOperand() const {
-    return getOperand(getFirstIndexOperandNumber()-1);
-  }
-  
-  virtual unsigned getFirstIndexOperandNumber() const = 0;
-
-  inline unsigned getNumIndices() const {  // Note: always non-negative
-    return (getNumOperands() - getFirstIndexOperandNumber());
-  }
-  
-  inline bool hasIndices() const {
-    return getNumIndices() > 0;
-  }
-
-  // Methods for support type inquiry through isa, cast, and dyn_cast:
-  static inline bool classof(const MemAccessInst *) { return true; }
-  static inline bool classof(const Instruction *I) {
-    return I->getOpcode() == GetElementPtr;
-  }
-  static inline bool classof(const Value *V) {
-    return isa<Instruction>(V) && classof(cast<Instruction>(V));
-  }
-};
-
-
 //===----------------------------------------------------------------------===//
 //                                LoadInst Class
 //===----------------------------------------------------------------------===//
@@ -201,12 +143,14 @@ class LoadInst : public Instruction {
     Operands.push_back(Use(LI.Operands[0], this));
   }
 public:
-  LoadInst(Value *Ptr, const std::string &Name = "");
+  LoadInst(Value *Ptr, const std::string &Name = "",
+           Instruction *InsertBefore = 0);
 
   virtual Instruction *clone() const { return new LoadInst(*this); }
 
   Value *getPointerOperand() { return getOperand(0); }
   const Value *getPointerOperand() const { return getOperand(0); }
+  static unsigned getPointerOperandIndex() { return 0U; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const LoadInst *) { return true; }
@@ -230,13 +174,14 @@ class StoreInst : public Instruction {
     Operands.push_back(Use(SI.Operands[1], this));
   }
 public:
-  StoreInst(Value *Val, Value *Ptr);
+  StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore = 0);
   virtual Instruction *clone() const { return new StoreInst(*this); }
 
   virtual bool hasSideEffects() const { return true; }
 
   Value *getPointerOperand() { return getOperand(1); }
   const Value *getPointerOperand() const { return getOperand(1); }
+  static unsigned getPointerOperandIndex() { return 1U; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const StoreInst *) { return true; }
@@ -253,24 +198,60 @@ public:
 //                             GetElementPtrInst Class
 //===----------------------------------------------------------------------===//
 
-class GetElementPtrInst : public MemAccessInst {
+class GetElementPtrInst : public Instruction {
   GetElementPtrInst(const GetElementPtrInst &EPI)
-    : MemAccessInst((Type*)EPI.getType(), GetElementPtr) {
+    : Instruction((Type*)EPI.getType(), GetElementPtr) {
     Operands.reserve(EPI.Operands.size());
     for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
       Operands.push_back(Use(EPI.Operands[i], this));
   }
 public:
   GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
-		    const std::string &Name = "");
+		    const std::string &Name = "", Instruction *InsertBefore =0);
   virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
-  virtual unsigned getFirstIndexOperandNumber() const { return 1; }
   
   // getType - Overload to return most specific pointer type...
   inline const PointerType *getType() const {
     return (PointerType*)Instruction::getType();
   }
 
+  /// getIndexedType - Returns the type of the element that would be loaded with
+  /// a load instruction with the specified parameters.
+  ///
+  /// A null type is returned if the indices are invalid for the specified 
+  /// pointer type.
+  ///
+  static const Type *getIndexedType(const Type *Ptr, 
+				    const std::vector<Value*> &Indices,
+				    bool AllowStructLeaf = false);
+  
+  inline op_iterator       idx_begin()       {
+    return op_begin()+1;
+  }
+  inline const_op_iterator idx_begin() const {
+    return op_begin()+1;
+  }
+  inline op_iterator       idx_end()         { return op_end(); }
+  inline const_op_iterator idx_end()   const { return op_end(); }
+
+  Value *getPointerOperand() {
+    return getOperand(0);
+  }
+  const Value *getPointerOperand() const {
+    return getOperand(0);
+  }
+  static unsigned getPointerOperandIndex() {
+    return 0U;                      // get index for modifying correct operand
+  }
+
+  inline unsigned getNumIndices() const {  // Note: always non-negative
+    return getNumOperands() - 1;
+  }
+  
+  inline bool hasIndices() const {
+    return getNumOperands() > 1;
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const GetElementPtrInst *) { return true; }
   static inline bool classof(const Instruction *I) {