X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FiMemory.h;h=e42f5b993b85c924a66abf00169ae3ae2e76c81f;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=3b4a18bed0a0345fa1a9e4f65adbe08cbf47eee9;hpb=607bfadd8c586981eb395e7e8d5a352d262eadc1;p=oota-llvm.git diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h index 3b4a18bed0a..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,89 +133,24 @@ struct FreeInst : public Instruction { }; -//===----------------------------------------------------------------------===// -// 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 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() == 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 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; } @@ -226,19 +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 bool hasSideEffects() const { return true; } - virtual unsigned getFirstIndexOperandNumber() const { return 2; } + + 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; } @@ -255,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 &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 &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) {