include/llvm/iMemory.h

   1 //===-- llvm/iMemory.h - Memory Operator node definitions --------*- C++ -*--=//
   2 //
   3 // This file contains the declarations of all of the memory related operators.
   4 // This includes: malloc, free, alloca, load, store, getfield, putfield
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #ifndef LLVM_IMEMORY_H
   9 #define LLVM_IMEMORY_H
  10
  11 #include "llvm/Instruction.h"
  12 #include "llvm/DerivedTypes.h"
  13
  14 //===----------------------------------------------------------------------===//
  15 //                             AllocationInst Class
  16 //===----------------------------------------------------------------------===//
  17 //
  18 // AllocationInst - This class is the common base class of MallocInst and
  19 // AllocaInst.
  20 //
  21 class AllocationInst : public Instruction {
  22 public:
  23   AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
  24                  const string &Name = "")
  25     : Instruction(Ty, iTy, Name) {
  26     assert(Ty->isPointerType() && "Can't allocate a non pointer type!");
  27
  28     if (ArraySize) {
  29       // Make sure they didn't try to specify a size for !(unsized array) type
  30       assert(getType()->getValueType()->isArrayType() &&
  31              cast<ArrayType>(getType()->getValueType())->isUnsized() &&
  32            "Trying to allocate something other than unsized array, with size!");
  33
  34       Operands.reserve(1);
  35       Operands.push_back(Use(ArraySize, this));
  36     } else {
  37       // Make sure that the pointer is not to an unsized array!
  38       assert(!getType()->getValueType()->isArrayType() ||
  39              cast<const ArrayType>(getType()->getValueType())->isSized() &&
  40              "Trying to allocate unsized array without size!");
  41     }
  42   }
  43
  44   // isArrayAllocation - Return true if there is an allocation size parameter
  45   // to the allocation instruction.
  46   //
  47   inline bool isArrayAllocation() const { return Operands.size() == 1; }
  48
  49   inline const Value *getArraySize() const {
  50     assert(isArrayAllocation()); return Operands[0];
  51   }
  52   inline Value *getArraySize() {
  53     assert(isArrayAllocation()); return Operands[0];
  54   }
  55
  56   // getType - Overload to return most specific pointer type...
  57   inline const PointerType *getType() const {
  58     return (const PointerType*)Instruction::getType();
  59   }
  60
  61   // getAllocatedType - Return the type that is being allocated by the
  62   // instruction.
  63   inline const Type *getAllocatedType() const {
  64     return getType()->getValueType();
  65   }
  66
  67   virtual Instruction *clone() const = 0;
  68 };
  69
  70
  71 //===----------------------------------------------------------------------===//
  72 //                                MallocInst Class
  73 //===----------------------------------------------------------------------===//
  74
  75 class MallocInst : public AllocationInst {
  76 public:
  77   MallocInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
  78     : AllocationInst(Ty, ArraySize, Malloc, Name) {}
  79
  80   virtual Instruction *clone() const {
  81     return new MallocInst(getType(),
  82                           Operands.size() ? (Value*)Operands[0].get() : 0);
  83   }
  84
  85   virtual const char *getOpcodeName() const { return "malloc"; }
  86
  87   // Methods for support type inquiry through isa, cast, and dyn_cast:
  88   static inline bool classof(const MallocInst *) { return true; }
  89   static inline bool classof(const Instruction *I) {
  90     return (I->getOpcode() == Instruction::Malloc);
  91   }
  92   static inline bool classof(const Value *V) {
  93     return isa<Instruction>(V) && classof(cast<Instruction>(V));
  94   }
  95 };
  96
  97
  98 //===----------------------------------------------------------------------===//
  99 //                                AllocaInst Class
 100 //===----------------------------------------------------------------------===//
 101
 102 class AllocaInst : public AllocationInst {
 103 public:
 104   AllocaInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
 105     : AllocationInst(Ty, ArraySize, Alloca, Name) {}
 106
 107   virtual Instruction *clone() const {
 108     return new AllocaInst(getType(),
 109                           Operands.size() ? (Value*)Operands[0].get() : 0);
 110   }
 111
 112   virtual const char *getOpcodeName() const { return "alloca"; }
 113
 114   // Methods for support type inquiry through isa, cast, and dyn_cast:
 115   static inline bool classof(const AllocaInst *) { return true; }
 116   static inline bool classof(const Instruction *I) {
 117     return (I->getOpcode() == Instruction::Alloca);
 118   }
 119   static inline bool classof(const Value *V) {
 120     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 121   }
 122 };
 123
 124
 125 //===----------------------------------------------------------------------===//
 126 //                                 FreeInst Class
 127 //===----------------------------------------------------------------------===//
 128
 129 class FreeInst : public Instruction {
 130 public:
 131   FreeInst(Value *Ptr, const string &Name = "")
 132     : Instruction(Type::VoidTy, Free, Name) {
 133     assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!");
 134     Operands.reserve(1);
 135     Operands.push_back(Use(Ptr, this));
 136   }
 137
 138   virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
 139
 140   virtual const char *getOpcodeName() const { return "free"; }
 141
 142   virtual bool hasSideEffects() const { return true; }
 143
 144   // Methods for support type inquiry through isa, cast, and dyn_cast:
 145   static inline bool classof(const FreeInst *) { return true; }
 146   static inline bool classof(const Instruction *I) {
 147     return (I->getOpcode() == Instruction::Free);
 148   }
 149   static inline bool classof(const Value *V) {
 150     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 151   }
 152 };
 153
 154
 155 //===----------------------------------------------------------------------===//
 156 //                              MemAccessInst Class
 157 //===----------------------------------------------------------------------===//
 158 //
 159 // MemAccessInst - Common base class of LoadInst, StoreInst, and
 160 // GetElementPtrInst...
 161 //
 162 class MemAccessInst : public Instruction {
 163 protected:
 164   inline MemAccessInst(const Type *Ty, unsigned Opcode,
 165                        const vector<ConstPoolVal*> &Idx,
 166                        const string &Nam = "")
 167     : Instruction(Ty, Opcode, Nam),
 168       indexVec(Idx)
 169   {}
 170
 171 protected:
 172   vector<ConstPoolVal*> indexVec;
 173
 174 public:
 175   // getIndexedType - Returns the type of the element that would be loaded with
 176   // a load instruction with the specified parameters.
 177   //
 178   // A null type is returned if the indices are invalid for the specified
 179   // pointer type.
 180   //
 181   static const Type *getIndexedType(const Type *Ptr,
 182                                     const vector<ConstPoolVal*> &Indices,
 183                                     bool AllowStructLeaf = false);
 184
 185   Value *getPointerOperand() {
 186     return getOperand(getFirstIndexOperandNumber()-1);
 187   }
 188   const Value *getPointerOperand() const {
 189     return getOperand(getFirstIndexOperandNumber()-1);
 190   }
 191
 192   virtual unsigned getFirstIndexOperandNumber() const = 0;
 193
 194   const vector<ConstPoolVal*> &getIndices() const { return indexVec; }
 195   inline bool hasIndices() const {
 196     return getNumOperands() <= getFirstIndexOperandNumber();
 197   }
 198 };
 199
 200
 201 //===----------------------------------------------------------------------===//
 202 //                                LoadInst Class
 203 //===----------------------------------------------------------------------===//
 204
 205 class LoadInst : public MemAccessInst {
 206   LoadInst(const LoadInst &LI) : MemAccessInst(LI.getType(), Load,
 207                                                LI.getIndices()) {
 208     Operands.reserve(LI.Operands.size());
 209     for (unsigned i = 0, E = LI.Operands.size(); i != E; ++i)
 210       Operands.push_back(Use(LI.Operands[i], this));
 211   }
 212 public:
 213   LoadInst(Value *Ptr, const vector<ConstPoolVal*> &Idx,
 214            const string &Name = "");
 215   LoadInst(Value *Ptr, const string &Name = "");
 216
 217   virtual Instruction *clone() const { return new LoadInst(*this); }
 218   virtual const char *getOpcodeName() const { return "load"; }
 219
 220   virtual unsigned getFirstIndexOperandNumber() const { return 1; }
 221
 222   // Methods for support type inquiry through isa, cast, and dyn_cast:
 223   static inline bool classof(const LoadInst *) { return true; }
 224   static inline bool classof(const Instruction *I) {
 225     return (I->getOpcode() == Instruction::Load);
 226   }
 227   static inline bool classof(const Value *V) {
 228     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 229   }
 230 };
 231
 232
 233 //===----------------------------------------------------------------------===//
 234 //                                StoreInst Class
 235 //===----------------------------------------------------------------------===//
 236
 237 class StoreInst : public MemAccessInst {
 238   StoreInst(const StoreInst &SI) : MemAccessInst(SI.getType(), Store,
 239                                                  SI.getIndices()) {
 240     Operands.reserve(SI.Operands.size());
 241     for (unsigned i = 0, E = SI.Operands.size(); i != E; ++i)
 242       Operands.push_back(Use(SI.Operands[i], this));
 243   }
 244 public:
 245   StoreInst(Value *Val, Value *Ptr, const vector<ConstPoolVal*> &Idx,
 246             const string &Name = "");
 247   StoreInst(Value *Val, Value *Ptr, const string &Name = "");
 248   virtual Instruction *clone() const { return new StoreInst(*this); }
 249
 250   virtual const char *getOpcodeName() const { return "store"; }
 251
 252   virtual bool hasSideEffects() const { return true; }
 253   virtual unsigned getFirstIndexOperandNumber() const { return 2; }
 254
 255   // Methods for support type inquiry through isa, cast, and dyn_cast:
 256   static inline bool classof(const StoreInst *) { return true; }
 257   static inline bool classof(const Instruction *I) {
 258     return (I->getOpcode() == Instruction::Store);
 259   }
 260   static inline bool classof(const Value *V) {
 261     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 262   }
 263 };
 264
 265
 266 //===----------------------------------------------------------------------===//
 267 //                             GetElementPtrInst Class
 268 //===----------------------------------------------------------------------===//
 269
 270 class GetElementPtrInst : public MemAccessInst {
 271   GetElementPtrInst(const GetElementPtrInst &EPI)
 272     : MemAccessInst(EPI.getType(), GetElementPtr, EPI.getIndices()) {
 273     Operands.reserve(EPI.Operands.size());
 274     for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
 275       Operands.push_back(Use(EPI.Operands[i], this));
 276   }
 277 public:
 278   GetElementPtrInst(Value *Ptr, const vector<ConstPoolVal*> &Idx,
 279                     const string &Name = "");
 280   virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
 281   virtual const char *getOpcodeName() const { return "getelementptr"; }
 282   virtual unsigned getFirstIndexOperandNumber() const { return 1; }
 283
 284   inline bool isArraySelector() const { return !isStructSelector(); }
 285   bool isStructSelector() const;
 286
 287   // getType - Overload to return most specific pointer type...
 288   inline const PointerType *getType() const {
 289     return cast<const PointerType>(Instruction::getType());
 290   }
 291
 292   // Methods for support type inquiry through isa, cast, and dyn_cast:
 293   static inline bool classof(const GetElementPtrInst *) { return true; }
 294   static inline bool classof(const Instruction *I) {
 295     return (I->getOpcode() == Instruction::GetElementPtr);
 296   }
 297   static inline bool classof(const Value *V) {
 298     return isa<Instruction>(V) && classof(cast<Instruction>(V));
 299   }
 300 };
 301
 302 #endif // LLVM_IMEMORY_H