1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
//===-- 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"
class AllocationInst : public Instruction {
public:
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));
}
}
// getType - Overload to return most specific pointer type...
inline const PointerType *getType() const {
return (const PointerType*)Instruction::getType();
}
virtual Instruction *clone() const = 0;
};
class MallocInst : public AllocationInst {
public:
MallocInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
: AllocationInst(Ty, ArraySize, Instruction::Malloc, Name) {}
virtual Instruction *clone() const {
return new MallocInst(getType(), Operands.size() ? Operands[1] : 0);
}
virtual string getOpcode() const { return "malloc"; }
};
class AllocaInst : public AllocationInst {
public:
AllocaInst(const Type *Ty, Value *ArraySize = 0, const string &Name = "")
: AllocationInst(Ty, ArraySize, Instruction::Alloca, Name) {}
virtual Instruction *clone() const {
return new AllocaInst(getType(), Operands.size() ? Operands[1] : 0);
}
virtual string getOpcode() const { return "alloca"; }
};
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!");
Operands.reserve(1);
Operands.push_back(Use(Ptr, this));
}
inline ~FreeInst() {}
virtual Instruction *clone() const { return new FreeInst(Operands[0]); }
virtual string getOpcode() const { return "free"; }
};
#endif // LLVM_IMEMORY_H
|
