X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FiMemory.h;h=09c94a2c77db62203120acfa34f89a2d66a5b43a;hb=9fff7e194a2d8aa3abe92efa506b1fbe83583f53;hp=b14023625ca3e3c162c4250067aa0bde6105770b;hpb=8beec9da6cf69d1099a76b4c027f41537446b597;p=oota-llvm.git diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h index b14023625ca..09c94a2c77d 100644 --- a/include/llvm/iMemory.h +++ b/include/llvm/iMemory.h @@ -9,7 +9,7 @@ #define LLVM_IMEMORY_H #include "llvm/Instruction.h" -#include "llvm/DerivedTypes.h" +class PointerType; //===----------------------------------------------------------------------===// // AllocationInst Class @@ -21,7 +21,7 @@ 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 @@ -42,9 +42,8 @@ public: // getAllocatedType - Return the type that is being allocated by the // instruction. - inline const Type *getAllocatedType() const { - return getType()->getElementType(); - } + // + const Type *getAllocatedType() const; virtual Instruction *clone() const = 0; @@ -65,16 +64,16 @@ public: //===----------------------------------------------------------------------===// class MallocInst : public AllocationInst { + MallocInst(const MallocInst &MI); public: - MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "") - : AllocationInst(Ty, ArraySize, Malloc, Name) {} + 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(getType(), (Value*)Operands[0].get()); + return new MallocInst(*this); } - virtual const char *getOpcodeName() const { return "malloc"; } - // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const MallocInst *) { return true; } static inline bool classof(const Instruction *I) { @@ -91,16 +90,16 @@ public: //===----------------------------------------------------------------------===// class AllocaInst : public AllocationInst { + AllocaInst(const AllocaInst &); public: - AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "") - : AllocationInst(Ty, ArraySize, Alloca, Name) {} + 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(getType(), (Value*)Operands[0].get()); + return new AllocaInst(*this); } - virtual const char *getOpcodeName() const { return "alloca"; } - // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const AllocaInst *) { return true; } static inline bool classof(const Instruction *I) { @@ -116,19 +115,12 @@ public: // FreeInst Class //===----------------------------------------------------------------------===// -class FreeInst : public Instruction { -public: - FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") { - assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!"); - Operands.reserve(1); - Operands.push_back(Use(Ptr, this)); - } +struct FreeInst : public Instruction { + FreeInst(Value *Ptr, Instruction *InsertBefore = 0); virtual Instruction *clone() const { return new FreeInst(Operands[0]); } - virtual const char *getOpcodeName() const { return "free"; } - - virtual bool hasSideEffects() const { return true; } + virtual bool mayWriteToMemory() const { return true; } // Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const FreeInst *) { return true; } @@ -141,86 +133,24 @@ public: }; -//===----------------------------------------------------------------------===// -// MemAccessInst Class -//===----------------------------------------------------------------------===// -// -// MemAccessInst - Common base class of LoadInst, StoreInst, and -// 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 &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 copyIndices() const { - return std::vector(idx_begin(), idx_end()); - } - - Value *getPointerOperand() { - return getOperand(getFirstIndexOperandNumber()-1); - } - const Value *getPointerOperand() const { - return getOperand(getFirstIndexOperandNumber()-1); - } - - virtual unsigned getFirstIndexOperandNumber() const = 0; - - inline bool hasIndices() const { - return getNumOperands() > getFirstIndexOperandNumber(); - } - - // 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() == Load || I->getOpcode() == Store || - I->getOpcode() == GetElementPtr; - } - static inline bool classof(const Value *V) { - return isa(V) && classof(cast(V)); - } -}; - - //===----------------------------------------------------------------------===// // LoadInst Class //===----------------------------------------------------------------------===// -class LoadInst : public MemAccessInst { - LoadInst(const LoadInst &LI) : MemAccessInst(LI.getType(), Load) { - Operands.reserve(LI.Operands.size()); - for (unsigned i = 0, E = LI.Operands.size(); i != E; ++i) - Operands.push_back(Use(LI.Operands[i], this)); +class LoadInst : public Instruction { + LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) { + Operands.reserve(1); + Operands.push_back(Use(LI.Operands[0], this)); } public: - LoadInst(Value *Ptr, const std::vector &Ix, const std::string & = ""); - 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); } - virtual const char *getOpcodeName() const { return "load"; } - virtual unsigned getFirstIndexOperandNumber() const { return 1; } + 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; } @@ -237,21 +167,21 @@ public: // StoreInst Class //===----------------------------------------------------------------------===// -class StoreInst : public MemAccessInst { - StoreInst(const StoreInst &SI) : MemAccessInst(SI.getType(), Store) { - Operands.reserve(SI.Operands.size()); - for (unsigned i = 0, E = SI.Operands.size(); i != E; ++i) - Operands.push_back(Use(SI.Operands[i], this)); +class StoreInst : public Instruction { + StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) { + Operands.reserve(2); + Operands.push_back(Use(SI.Operands[0], this)); + Operands.push_back(Use(SI.Operands[1], this)); } public: - StoreInst(Value *Val, Value *Ptr, const std::vector &Idx); - StoreInst(Value *Val, Value *Ptr); + StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore = 0); virtual Instruction *clone() const { return new StoreInst(*this); } - virtual const char *getOpcodeName() const { return "store"; } - - virtual bool hasSideEffects() const { return true; } - virtual unsigned getFirstIndexOperandNumber() const { return 2; } + virtual bool mayWriteToMemory() 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; } @@ -268,23 +198,58 @@ public: // GetElementPtrInst Class //===----------------------------------------------------------------------===// -class GetElementPtrInst : public MemAccessInst { +class GetElementPtrInst : public Instruction { GetElementPtrInst(const GetElementPtrInst &EPI) - : MemAccessInst(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 &Idx, - const std::string &Name = ""); + const std::string &Name = "", Instruction *InsertBefore =0); virtual Instruction *clone() const { return new GetElementPtrInst(*this); } - virtual const char *getOpcodeName() const { return "getelementptr"; } - virtual unsigned getFirstIndexOperandNumber() const { return 1; } // getType - Overload to return most specific pointer type... inline const PointerType *getType() const { - return cast(Instruction::getType()); + 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 &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: