X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FiMemory.h;h=e42f5b993b85c924a66abf00169ae3ae2e76c81f;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=5667da6c8ff1428c4e69a9f201cd80def8720563;hpb=118630d9248415d8139d7df4147649bdadacbae9;p=oota-llvm.git diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h index 5667da6c8ff..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,34 +19,43 @@ // 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() && - ((const ArrayType*)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() || - ((const ArrayType*)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 that is not 1. + // + bool isArrayAllocation() const; + + // 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 { return (const PointerType*)Instruction::getType(); } + // getAllocatedType - Return the type that is being allocated by the + // instruction. + // + 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)); + } }; @@ -55,15 +64,24 @@ 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() ? Operands[1] : 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) { + return (I->getOpcode() == Instruction::Malloc); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -72,15 +90,24 @@ 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() ? Operands[1] : 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) { + return (I->getOpcode() == Instruction::Alloca); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -88,58 +115,21 @@ 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; } -}; - -//===----------------------------------------------------------------------===// -// 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; + // Methods for support type inquiry through isa, cast, and dyn_cast: + static inline bool classof(const FreeInst *) { return true; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Free); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -147,19 +137,29 @@ public: // 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; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Load); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -167,21 +167,30 @@ 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; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::Store); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; @@ -189,23 +198,68 @@ 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; } + static inline bool classof(const Instruction *I) { + return (I->getOpcode() == Instruction::GetElementPtr); + } + static inline bool classof(const Value *V) { + return isa(V) && classof(cast(V)); + } }; #endif // LLVM_IMEMORY_H