X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FiMemory.h;h=e42f5b993b85c924a66abf00169ae3ae2e76c81f;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=5ce03ef73656e2a37ee3d5d5a49bd38552617d23;hpb=b86751715ca1b9cc67bac69c51c71add63196fe0;p=oota-llvm.git diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h index 5ce03ef7365..e42f5b993b8 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 @@ -19,39 +19,21 @@ // AllocaInst. // class AllocationInst : public Instruction { -public: +protected: AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy, - const string &Name = "") - : Instruction(Ty, iTy, Name) { - assert(Ty->isPointerType() && "Can't allocate a non pointer type!"); - - if (ArraySize) { - // Make sure they didn't try to specify a size for !(unsized array) type - assert(getType()->getValueType()->isArrayType() && - cast(getType()->getValueType())->isUnsized() && - "Trying to allocate something other than unsized array, with size!"); - - Operands.reserve(1); - Operands.push_back(Use(ArraySize, this)); - } else { - // Make sure that the pointer is not to an unsized array! - assert(!getType()->getValueType()->isArrayType() || - cast(getType()->getValueType())->isSized() && - "Trying to allocate unsized array without size!"); - } - } + const std::string &Name = "", Instruction *InsertBefore = 0); +public: // isArrayAllocation - Return true if there is an allocation size parameter - // to the allocation instruction. + // to the allocation instruction that is not 1. // - inline bool isArrayAllocation() const { return Operands.size() == 1; } + bool isArrayAllocation() const; - inline const Value *getArraySize() const { - assert(isArrayAllocation()); return Operands[0]; - } - inline Value *getArraySize() { - assert(isArrayAllocation()); return Operands[0]; - } + // getArraySize - Get the number of element allocated, for a simple allocation + // of a single element, this will return a constant 1 value. + // + inline const Value *getArraySize() const { return Operands[0]; } + inline Value *getArraySize() { return Operands[0]; } // getType - Overload to return most specific pointer type... inline const PointerType *getType() const { @@ -60,11 +42,20 @@ public: // getAllocatedType - Return the type that is being allocated by the // instruction. - inline const Type *getAllocatedType() const { - return getType()->getValueType(); - } + // + const Type *getAllocatedType() const; virtual Instruction *clone() const = 0; + + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const AllocationInst *) { return true; } + static inline bool classof(const Instruction *I) { + return I->getOpcode() == Instruction::Alloca || + I->getOpcode() == Instruction::Malloc; + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -73,17 +64,16 @@ public: //===----------------------------------------------------------------------===// class MallocInst : public AllocationInst { + MallocInst(const MallocInst &MI); public: - MallocInst(const Type *Ty, Value *ArraySize = 0, const 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(), - Operands.size() ? (Value*)Operands[1].get() : 0); + 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) { @@ -100,17 +90,16 @@ public: //===----------------------------------------------------------------------===// class AllocaInst : public AllocationInst { + AllocaInst(const AllocaInst &); public: - AllocaInst(const Type *Ty, Value *ArraySize = 0, const 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(), - Operands.size() ? (Value*)Operands[1].get() : 0); + 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) { @@ -126,19 +115,11 @@ public: // FreeInst Class //===----------------------------------------------------------------------===// -class FreeInst : public Instruction { -public: - FreeInst(Value *Ptr, const string &Name = "") - : Instruction(Type::VoidTy, Free, Name) { - 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; } // Methods for support type inquiry through isa, cast, and dyn_cast: @@ -152,61 +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 vector &Idx, - const string &Nam = "") - : Instruction(Ty, Opcode, Nam), - indexVec(Idx) - {} - -protected: - vector indexVec; - -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 vector &Indices, - bool AllowStructLeaf = false); - - const vector& getIndexVec() const { return indexVec; } - - virtual Value* getPtrOperand() = 0; - - virtual int getFirstOffsetIdx() const = 0; -}; - - //===----------------------------------------------------------------------===// // LoadInst Class //===----------------------------------------------------------------------===// -class LoadInst : public MemAccessInst { - 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)); +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 vector &Idx, - const string &Name = ""); - 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;} + 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; } @@ -223,21 +167,21 @@ public: // StoreInst Class //===----------------------------------------------------------------------===// -class StoreInst : public MemAccessInst { - 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)); +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 vector &Idx, - const string &Name = ""); + 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 Value* getPtrOperand() { return this->getOperand(1); } - virtual int getFirstOffsetIdx() const { return (this->getNumOperands() > 2)? 2 : -1;} + + 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; } @@ -254,24 +198,59 @@ public: // GetElementPtrInst Class //===----------------------------------------------------------------------===// -class GetElementPtrInst : public MemAccessInst { +class GetElementPtrInst : public Instruction { GetElementPtrInst(const GetElementPtrInst &EPI) - : MemAccessInst(EPI.getType(), GetElementPtr, EPI.getIndexVec()) { + : 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 vector &Idx, - const string &Name = ""); + GetElementPtrInst(Value *Ptr, const std::vector &Idx, + const std::string &Name = "", Instruction *InsertBefore =0); 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; + // 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; }