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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
//===-- iMemory.cpp - Implement Memory instructions --------------*- C++ -*--=//
//
// This file implements the various memory related classes defined in iMemory.h
//
//===----------------------------------------------------------------------===//
#include "llvm/iMemory.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
static inline const Type *checkType(const Type *Ty) {
assert(Ty && "Invalid indices for type!");
return Ty;
}
AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
const std::string &Name = "")
: Instruction(Ty, iTy, Name) {
assert(Ty->isPointerType() && "Can't allocate a non pointer type!");
// ArraySize defaults to 1.
if (!ArraySize) ArraySize = ConstantUInt::get(Type::UIntTy, 1);
Operands.reserve(1);
assert(ArraySize->getType() == Type::UIntTy &&
"Malloc/Allocation array size != UIntTy!");
Operands.push_back(Use(ArraySize, this));
}
bool AllocationInst::isArrayAllocation() const {
return getNumOperands() == 1 &&
getOperand(0) != ConstantUInt::get(Type::UIntTy, 1);
}
const Type *AllocationInst::getAllocatedType() const {
return getType()->getElementType();
}
//===----------------------------------------------------------------------===//
// MemAccessInst Implementation
//===----------------------------------------------------------------------===//
// 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.
//
const Type* MemAccessInst::getIndexedType(const Type *Ptr,
const std::vector<Value*> &Idx,
bool AllowCompositeLeaf = false) {
if (!Ptr->isPointerType()) return 0; // Type isn't a pointer type!
// Handle the special case of the empty set index set...
if (Idx.empty()) return cast<PointerType>(Ptr)->getElementType();
unsigned CurIDX = 0;
while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) {
if (Idx.size() == CurIDX) {
if (AllowCompositeLeaf || CT->isFirstClassType()) return Ptr;
return 0; // Can't load a whole structure or array!?!?
}
Value *Index = Idx[CurIDX++];
if (!CT->indexValid(Index)) return 0;
Ptr = CT->getTypeAtIndex(Index);
}
return CurIDX == Idx.size() ? Ptr : 0;
}
//===----------------------------------------------------------------------===//
// LoadInst Implementation
//===----------------------------------------------------------------------===//
LoadInst::LoadInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name = "")
: MemAccessInst(checkType(getIndexedType(Ptr->getType(), Idx)), Load, Name) {
assert(getIndexedType(Ptr->getType(), Idx) && "Load operands invalid!");
Operands.reserve(1+Idx.size());
Operands.push_back(Use(Ptr, this));
for (unsigned i = 0, E = Idx.size(); i != E; ++i)
Operands.push_back(Use(Idx[i], this));
}
LoadInst::LoadInst(Value *Ptr, const std::string &Name = "")
: MemAccessInst(cast<PointerType>(Ptr->getType())->getElementType(),
Load, Name) {
Operands.reserve(1);
Operands.push_back(Use(Ptr, this));
}
//===----------------------------------------------------------------------===//
// StoreInst Implementation
//===----------------------------------------------------------------------===//
StoreInst::StoreInst(Value *Val, Value *Ptr, const std::vector<Value*> &Idx)
: MemAccessInst(Type::VoidTy, Store, "") {
assert(getIndexedType(Ptr->getType(), Idx) && "Store operands invalid!");
Operands.reserve(2+Idx.size());
Operands.push_back(Use(Val, this));
Operands.push_back(Use(Ptr, this));
for (unsigned i = 0, E = Idx.size(); i != E; ++i)
Operands.push_back(Use(Idx[i], this));
}
StoreInst::StoreInst(Value *Val, Value *Ptr)
: MemAccessInst(Type::VoidTy, Store, "") {
Operands.reserve(2);
Operands.push_back(Use(Val, this));
Operands.push_back(Use(Ptr, this));
}
//===----------------------------------------------------------------------===//
// GetElementPtrInst Implementation
//===----------------------------------------------------------------------===//
GetElementPtrInst::GetElementPtrInst(Value *Ptr, const std::vector<Value*> &Idx,
const std::string &Name = "")
: MemAccessInst(PointerType::get(checkType(getIndexedType(Ptr->getType(),
Idx, true))),
GetElementPtr, Name) {
assert(getIndexedType(Ptr->getType(), Idx, true) && "gep operands invalid!");
Operands.reserve(1+Idx.size());
Operands.push_back(Use(Ptr, this));
for (unsigned i = 0, E = Idx.size(); i != E; ++i)
Operands.push_back(Use(Idx[i], this));
}
//===----------------------------------------------------------------------===//
// FreeInst Implementation
//===----------------------------------------------------------------------===//
FreeInst::FreeInst(Value *Ptr) : Instruction(Type::VoidTy, Free, "") {
assert(Ptr->getType()->isPointerType() && "Can't free nonpointer!");
Operands.reserve(1);
Operands.push_back(Use(Ptr, this));
}
|
