1 //===-- llvm/iMemory.h - Memory Operator node definitions -------*- C++ -*-===//
3 // This file contains the declarations of all of the memory related operators.
4 // This includes: malloc, free, alloca, load, store, and getelementptr
6 //===----------------------------------------------------------------------===//
11 #include "llvm/Instruction.h"
14 //===----------------------------------------------------------------------===//
15 // AllocationInst Class
16 //===----------------------------------------------------------------------===//
18 // AllocationInst - This class is the common base class of MallocInst and
21 class AllocationInst : public Instruction {
23 AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
24 const std::string &Name = "", Instruction *InsertBefore = 0);
27 // isArrayAllocation - Return true if there is an allocation size parameter
28 // to the allocation instruction that is not 1.
30 bool isArrayAllocation() const;
32 // getArraySize - Get the number of element allocated, for a simple allocation
33 // of a single element, this will return a constant 1 value.
35 inline const Value *getArraySize() const { return Operands[0]; }
36 inline Value *getArraySize() { return Operands[0]; }
38 // getType - Overload to return most specific pointer type...
39 inline const PointerType *getType() const {
40 return (const PointerType*)Instruction::getType();
43 // getAllocatedType - Return the type that is being allocated by the
46 const Type *getAllocatedType() const;
48 virtual Instruction *clone() const = 0;
50 // Methods for support type inquiry through isa, cast, and dyn_cast:
51 static inline bool classof(const AllocationInst *) { return true; }
52 static inline bool classof(const Instruction *I) {
53 return I->getOpcode() == Instruction::Alloca ||
54 I->getOpcode() == Instruction::Malloc;
56 static inline bool classof(const Value *V) {
57 return isa<Instruction>(V) && classof(cast<Instruction>(V));
62 //===----------------------------------------------------------------------===//
64 //===----------------------------------------------------------------------===//
66 class MallocInst : public AllocationInst {
67 MallocInst(const MallocInst &MI);
69 MallocInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
70 Instruction *InsertBefore = 0)
71 : AllocationInst(Ty, ArraySize, Malloc, Name, InsertBefore) {}
73 virtual Instruction *clone() const {
74 return new MallocInst(*this);
77 // Methods for support type inquiry through isa, cast, and dyn_cast:
78 static inline bool classof(const MallocInst *) { return true; }
79 static inline bool classof(const Instruction *I) {
80 return (I->getOpcode() == Instruction::Malloc);
82 static inline bool classof(const Value *V) {
83 return isa<Instruction>(V) && classof(cast<Instruction>(V));
88 //===----------------------------------------------------------------------===//
90 //===----------------------------------------------------------------------===//
92 class AllocaInst : public AllocationInst {
93 AllocaInst(const AllocaInst &);
95 AllocaInst(const Type *Ty, Value *ArraySize = 0, const std::string &Name = "",
96 Instruction *InsertBefore = 0)
97 : AllocationInst(Ty, ArraySize, Alloca, Name, InsertBefore) {}
99 virtual Instruction *clone() const {
100 return new AllocaInst(*this);
103 // Methods for support type inquiry through isa, cast, and dyn_cast:
104 static inline bool classof(const AllocaInst *) { return true; }
105 static inline bool classof(const Instruction *I) {
106 return (I->getOpcode() == Instruction::Alloca);
108 static inline bool classof(const Value *V) {
109 return isa<Instruction>(V) && classof(cast<Instruction>(V));
114 //===----------------------------------------------------------------------===//
116 //===----------------------------------------------------------------------===//
118 struct FreeInst : public Instruction {
119 FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
121 virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
123 virtual bool mayWriteToMemory() const { return true; }
125 // Methods for support type inquiry through isa, cast, and dyn_cast:
126 static inline bool classof(const FreeInst *) { return true; }
127 static inline bool classof(const Instruction *I) {
128 return (I->getOpcode() == Instruction::Free);
130 static inline bool classof(const Value *V) {
131 return isa<Instruction>(V) && classof(cast<Instruction>(V));
136 //===----------------------------------------------------------------------===//
138 //===----------------------------------------------------------------------===//
140 class LoadInst : public Instruction {
141 LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) {
142 Volatile = LI.isVolatile();
144 Operands.push_back(Use(LI.Operands[0], this));
146 bool Volatile; // True if this is a volatile load
148 LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
149 LoadInst(Value *Ptr, const std::string &Name = "", bool isVolatile = false,
150 Instruction *InsertBefore = 0);
152 /// isVolatile - Return true if this is a load from a volatile memory
154 bool isVolatile() const { return Volatile; }
156 /// setVolatile - Specify whether this is a volatile load or not.
158 void setVolatile(bool V) { Volatile = V; }
160 virtual Instruction *clone() const { return new LoadInst(*this); }
162 virtual bool mayWriteToMemory() const { return isVolatile(); }
164 Value *getPointerOperand() { return getOperand(0); }
165 const Value *getPointerOperand() const { return getOperand(0); }
166 static unsigned getPointerOperandIndex() { return 0U; }
168 // Methods for support type inquiry through isa, cast, and dyn_cast:
169 static inline bool classof(const LoadInst *) { return true; }
170 static inline bool classof(const Instruction *I) {
171 return I->getOpcode() == Instruction::Load;
173 static inline bool classof(const Value *V) {
174 return isa<Instruction>(V) && classof(cast<Instruction>(V));
179 //===----------------------------------------------------------------------===//
181 //===----------------------------------------------------------------------===//
183 class StoreInst : public Instruction {
184 StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store) {
185 Volatile = SI.isVolatile();
187 Operands.push_back(Use(SI.Operands[0], this));
188 Operands.push_back(Use(SI.Operands[1], this));
190 bool Volatile; // True if this is a volatile store
192 StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
193 StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
194 Instruction *InsertBefore = 0);
197 /// isVolatile - Return true if this is a load from a volatile memory
199 bool isVolatile() const { return Volatile; }
201 /// setVolatile - Specify whether this is a volatile load or not.
203 void setVolatile(bool V) { Volatile = V; }
205 virtual Instruction *clone() const { return new StoreInst(*this); }
207 virtual bool mayWriteToMemory() const { return true; }
209 Value *getPointerOperand() { return getOperand(1); }
210 const Value *getPointerOperand() const { return getOperand(1); }
211 static unsigned getPointerOperandIndex() { return 1U; }
213 // Methods for support type inquiry through isa, cast, and dyn_cast:
214 static inline bool classof(const StoreInst *) { return true; }
215 static inline bool classof(const Instruction *I) {
216 return I->getOpcode() == Instruction::Store;
218 static inline bool classof(const Value *V) {
219 return isa<Instruction>(V) && classof(cast<Instruction>(V));
224 //===----------------------------------------------------------------------===//
225 // GetElementPtrInst Class
226 //===----------------------------------------------------------------------===//
228 class GetElementPtrInst : public Instruction {
229 GetElementPtrInst(const GetElementPtrInst &EPI)
230 : Instruction((Type*)EPI.getType(), GetElementPtr) {
231 Operands.reserve(EPI.Operands.size());
232 for (unsigned i = 0, E = EPI.Operands.size(); i != E; ++i)
233 Operands.push_back(Use(EPI.Operands[i], this));
236 GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
237 const std::string &Name = "", Instruction *InsertBefore =0);
238 virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
240 // getType - Overload to return most specific pointer type...
241 inline const PointerType *getType() const {
242 return (PointerType*)Instruction::getType();
245 /// getIndexedType - Returns the type of the element that would be loaded with
246 /// a load instruction with the specified parameters.
248 /// A null type is returned if the indices are invalid for the specified
251 static const Type *getIndexedType(const Type *Ptr,
252 const std::vector<Value*> &Indices,
253 bool AllowStructLeaf = false);
255 inline op_iterator idx_begin() {
258 inline const_op_iterator idx_begin() const {
261 inline op_iterator idx_end() { return op_end(); }
262 inline const_op_iterator idx_end() const { return op_end(); }
264 Value *getPointerOperand() {
265 return getOperand(0);
267 const Value *getPointerOperand() const {
268 return getOperand(0);
270 static unsigned getPointerOperandIndex() {
271 return 0U; // get index for modifying correct operand
274 inline unsigned getNumIndices() const { // Note: always non-negative
275 return getNumOperands() - 1;
278 inline bool hasIndices() const {
279 return getNumOperands() > 1;
282 // Methods for support type inquiry through isa, cast, and dyn_cast:
283 static inline bool classof(const GetElementPtrInst *) { return true; }
284 static inline bool classof(const Instruction *I) {
285 return (I->getOpcode() == Instruction::GetElementPtr);
287 static inline bool classof(const Value *V) {
288 return isa<Instruction>(V) && classof(cast<Instruction>(V));
292 #endif // LLVM_IMEMORY_H