#define LLVM_IMEMORY_H
#include "llvm/Instruction.h"
-#include "llvm/DerivedTypes.h"
+class PointerType;
+//===----------------------------------------------------------------------===//
+// AllocationInst Class
+//===----------------------------------------------------------------------===//
+//
+// AllocationInst - This class is the common base class of MallocInst and
+// 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!");
+ const std::string &Name = "", Instruction *InsertBefore = 0);
+public:
- 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!");
+ // isArrayAllocation - Return true if there is an allocation size parameter
+ // to the allocation instruction that is not 1.
+ //
+ bool isArrayAllocation() const;
- Operands.reserve(1);
- Operands.push_back(Use(ArraySize, this));
- }
- }
+ // 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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
};
+
+//===----------------------------------------------------------------------===//
+// MallocInst Class
+//===----------------------------------------------------------------------===//
+
class MallocInst : public AllocationInst {
+ MallocInst(const MallocInst &MI);
public:
- MallocInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
- : AllocationInst(Ty, ArraySize, Instruction::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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
};
+
+//===----------------------------------------------------------------------===//
+// AllocaInst Class
+//===----------------------------------------------------------------------===//
+
class AllocaInst : public AllocationInst {
+ AllocaInst(const AllocaInst &);
public:
- AllocaInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
- : AllocationInst(Ty, ArraySize, Instruction::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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
};
+//===----------------------------------------------------------------------===//
+// FreeInst Class
+//===----------------------------------------------------------------------===//
+
+struct FreeInst : public Instruction {
+ FreeInst(Value *Ptr, Instruction *InsertBefore = 0);
+
+ virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
-class FreeInst : public Instruction {
-public:
- FreeInst(Value *Ptr, const string &Name = "")
- : Instruction(Type::VoidTy, Instruction::Free, Name) {
- assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!");
+ virtual bool mayWriteToMemory() const { return true; }
+
+ // 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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
+// LoadInst Class
+//===----------------------------------------------------------------------===//
+
+class LoadInst : public Instruction {
+ LoadInst(const LoadInst &LI) : Instruction(LI.getType(), Load) {
Operands.reserve(1);
- Operands.push_back(Use(Ptr, this));
+ Operands.push_back(Use(LI.Operands[0], this));
}
- inline ~FreeInst() {}
+public:
+ LoadInst(Value *Ptr, const std::string &Name = "",
+ Instruction *InsertBefore = 0);
- virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
+ virtual Instruction *clone() const { return new LoadInst(*this); }
- virtual const char *getOpcodeName() const { return "free"; }
+ 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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
+// StoreInst Class
+//===----------------------------------------------------------------------===//
+
+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, Instruction *InsertBefore = 0);
+ virtual Instruction *clone() const { return new StoreInst(*this); }
+
+ virtual bool mayWriteToMemory() const { return true; }
+
+ 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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
+};
+
+
+//===----------------------------------------------------------------------===//
+// GetElementPtrInst Class
+//===----------------------------------------------------------------------===//
+
+class GetElementPtrInst : public Instruction {
+ GetElementPtrInst(const GetElementPtrInst &EPI)
+ : 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 std::vector<Value*> &Idx,
+ const std::string &Name = "", Instruction *InsertBefore =0);
+ virtual Instruction *clone() const { return new GetElementPtrInst(*this); }
+
+ // 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<Value*> &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<Instruction>(V) && classof(cast<Instruction>(V));
+ }
};
#endif // LLVM_IMEMORY_H
projects / oota-llvm.git / blobdiff