diff options
Diffstat (limited to 'include/llvm/iMemory.h')
-rw-r--r-- | include/llvm/iMemory.h | 140 |
1 files changed, 140 insertions, 0 deletions
diff --git a/include/llvm/iMemory.h b/include/llvm/iMemory.h new file mode 100644 index 0000000000..077266de94 --- /dev/null +++ b/include/llvm/iMemory.h @@ -0,0 +1,140 @@ +//===-- llvm/iMemory.h - Memory Operator node definitions --------*- C++ -*--=// +// +// This file contains the declarations of all of the memory related operators. +// This includes: malloc, free, alloca, load, store, getfield, putfield +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_IMEMORY_H +#define LLVM_IMEMORY_H + +#include "llvm/Instruction.h" +#include "llvm/DerivedTypes.h" +#include "llvm/ConstPoolVals.h" + +class ConstPoolType; + +class AllocationInst : public Instruction { +protected: + UseTy<ConstPoolType> TyVal; + Use ArraySize; +public: + AllocationInst(ConstPoolType *tyVal, Value *arrSize, unsigned iTy, + const string &Name = "") + : Instruction(tyVal->getValue(), iTy, Name), + TyVal(tyVal, this), ArraySize(arrSize, this) { + + // Make sure they didn't try to specify a size for an invalid type... + assert(arrSize == 0 || + (getType()->getValueType()->isArrayType() && + ((const ArrayType*)getType()->getValueType())->isUnsized()) && + "Trying to allocate something other than unsized array, with size!"); + + // Make sure that if a size is specified, that it is a uint! + assert(arrSize == 0 || arrSize->getType() == Type::UIntTy && + "Malloc SIZE is not a 'uint'!"); + } + inline ~AllocationInst() {} + + // getType - Overload to return most specific pointer type... + inline const PointerType *getType() const { + return (const PointerType*)Instruction::getType(); + } + + virtual Instruction *clone() const = 0; + + inline virtual void dropAllReferences() { TyVal = 0; ArraySize = 0; } + virtual bool setOperand(unsigned i, Value *Val) { + if (i == 0) { + assert(!Val || Val->getValueType() == Value::ConstantVal); + TyVal = (ConstPoolType*)Val; + return true; + } else if (i == 1) { + // Make sure they didn't try to specify a size for an invalid type... + assert(Val == 0 || + (getType()->getValueType()->isArrayType() && + ((const ArrayType*)getType()->getValueType())->isUnsized()) && + "Trying to allocate something other than unsized array, with size!"); + + // Make sure that if a size is specified, that it is a uint! + assert(Val == 0 || Val->getType() == Type::UIntTy && + "Malloc SIZE is not a 'uint'!"); + + ArraySize = Val; + return true; + } + return false; + } + + virtual unsigned getNumOperands() const { return 2; } + + virtual const Value *getOperand(unsigned i) const { + return i == 0 ? TyVal : (i == 1 ? ArraySize : 0); + } +}; + +class MallocInst : public AllocationInst { +public: + MallocInst(ConstPoolType *tyVal, Value *ArraySize = 0, + const string &Name = "") + : AllocationInst(tyVal, ArraySize, Instruction::Malloc, Name) {} + inline ~MallocInst() {} + + virtual Instruction *clone() const { + return new MallocInst(TyVal, ArraySize); + } + + virtual string getOpcode() const { return "malloc"; } +}; + +class AllocaInst : public AllocationInst { +public: + AllocaInst(ConstPoolType *tyVal, Value *ArraySize = 0, + const string &Name = "") + : AllocationInst(tyVal, ArraySize, Instruction::Alloca, Name) {} + inline ~AllocaInst() {} + + virtual Instruction *clone() const { + return new AllocaInst(TyVal, ArraySize); + } + + virtual string getOpcode() const { return "alloca"; } +}; + + + +class FreeInst : public Instruction { +protected: + Use Pointer; +public: + FreeInst(Value *Ptr, const string &Name = "") + : Instruction(Type::VoidTy, Instruction::Free, Name), + Pointer(Ptr, this) { + + assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!"); + } + inline ~FreeInst() {} + + virtual Instruction *clone() const { return new FreeInst(Pointer); } + + inline virtual void dropAllReferences() { Pointer = 0; } + + virtual bool setOperand(unsigned i, Value *Val) { + if (i == 0) { + assert(!Val || Val->getType()->isPointerType() && + "Can't free nonpointer!"); + Pointer = Val; + return true; + } + return false; + } + + virtual unsigned getNumOperands() const { return 1; } + virtual const Value *getOperand(unsigned i) const { + return i == 0 ? Pointer : 0; + } + + virtual string getOpcode() const { return "free"; } +}; + +#endif // LLVM_IMEMORY_H |