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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
//===-- Module.cpp - Implement the Module class ------------------*- C++ -*--=//
//
// This file implements the Module class for the VMCore library.
//
//===----------------------------------------------------------------------===//
#include "llvm/Module.h"
#include "llvm/InstrTypes.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "Support/STLExtras.h"
#include "Support/LeakDetector.h"
#include "SymbolTableListTraitsImpl.h"
#include <algorithm>
#include <map>
Function *ilist_traits<Function>::createNode() {
FunctionType *FTy =
FunctionType::get(Type::VoidTy, std::vector<const Type*>(), false);
Function *Ret = new Function(FTy, false);
// This should not be garbage monitored.
LeakDetector::removeGarbageObject(Ret);
return Ret;
}
GlobalVariable *ilist_traits<GlobalVariable>::createNode() {
GlobalVariable *Ret = new GlobalVariable(Type::IntTy, false, false);
// This should not be garbage monitored.
LeakDetector::removeGarbageObject(Ret);
return Ret;
}
iplist<Function> &ilist_traits<Function>::getList(Module *M) {
return M->getFunctionList();
}
iplist<GlobalVariable> &ilist_traits<GlobalVariable>::getList(Module *M) {
return M->getGlobalList();
}
// Explicit instantiations of SymbolTableListTraits since some of the methods
// are not in the public header file...
template SymbolTableListTraits<GlobalVariable, Module, Module>;
template SymbolTableListTraits<Function, Module, Module>;
// Define the GlobalValueRefMap as a struct that wraps a map so that we don't
// have Module.h depend on <map>
//
struct GlobalValueRefMap {
typedef std::map<GlobalValue*, ConstantPointerRef*> MapTy;
typedef MapTy::iterator iterator;
std::map<GlobalValue*, ConstantPointerRef*> Map;
};
Module::Module() {
FunctionList.setItemParent(this);
FunctionList.setParent(this);
GlobalList.setItemParent(this);
GlobalList.setParent(this);
GVRefMap = 0;
SymTab = 0;
}
Module::~Module() {
dropAllReferences();
GlobalList.clear();
GlobalList.setParent(0);
FunctionList.clear();
FunctionList.setParent(0);
delete SymTab;
}
// Module::dump() - Allow printing from debugger
void Module::dump() const {
print(std::cerr);
}
SymbolTable *Module::getSymbolTableSure() {
if (!SymTab) SymTab = new SymbolTable();
return SymTab;
}
// hasSymbolTable() - Returns true if there is a symbol table allocated to
// this object AND if there is at least one name in it!
//
bool Module::hasSymbolTable() const {
if (!SymTab) return false;
for (SymbolTable::const_iterator I = SymTab->begin(), E = SymTab->end();
I != E; ++I)
if (I->second.begin() != I->second.end())
return true; // Found nonempty type plane!
return false;
}
// getOrInsertFunction - Look up the specified function in the module symbol
// table. If it does not exist, add a prototype for the function and return
// it. This is nice because it allows most passes to get away with not handling
// the symbol table directly for this common task.
//
Function *Module::getOrInsertFunction(const std::string &Name,
const FunctionType *Ty) {
SymbolTable *SymTab = getSymbolTableSure();
// See if we have a definitions for the specified function already...
if (Value *V = SymTab->lookup(PointerType::get(Ty), Name)) {
return cast<Function>(V); // Yup, got it
} else { // Nope, add one
Function *New = new Function(Ty, false, Name);
FunctionList.push_back(New);
return New; // Return the new prototype...
}
}
// getFunction - Look up the specified function in the module symbol table.
// If it does not exist, return null.
//
Function *Module::getFunction(const std::string &Name, const FunctionType *Ty) {
SymbolTable *SymTab = getSymbolTable();
if (SymTab == 0) return 0; // No symtab, no symbols...
return cast_or_null<Function>(SymTab->lookup(PointerType::get(Ty), Name));
}
// addTypeName - Insert an entry in the symbol table mapping Str to Type. If
// there is already an entry for this name, true is returned and the symbol
// table is not modified.
//
bool Module::addTypeName(const std::string &Name, const Type *Ty) {
SymbolTable *ST = getSymbolTableSure();
if (ST->lookup(Type::TypeTy, Name)) return true; // Already in symtab...
// Not in symbol table? Set the name with the Symtab as an argument so the
// type knows what to update...
((Value*)Ty)->setName(Name, ST);
return false;
}
/// getMainFunction - This function looks up main efficiently. This is such a
/// common case, that it is a method in Module. If main cannot be found, a
/// null pointer is returned.
///
Function *Module::getMainFunction() {
std::vector<const Type*> Params;
// int main(void)...
if (Function *F = getFunction("main", FunctionType::get(Type::IntTy,
Params, false)))
return F;
// void main(void)...
if (Function *F = getFunction("main", FunctionType::get(Type::VoidTy,
Params, false)))
return F;
Params.push_back(Type::IntTy);
// int main(int argc)...
if (Function *F = getFunction("main", FunctionType::get(Type::IntTy,
Params, false)))
return F;
// void main(int argc)...
if (Function *F = getFunction("main", FunctionType::get(Type::VoidTy,
Params, false)))
return F;
for (unsigned i = 0; i != 2; ++i) { // Check argv and envp
Params.push_back(PointerType::get(PointerType::get(Type::SByteTy)));
// int main(int argc, char **argv)...
if (Function *F = getFunction("main", FunctionType::get(Type::IntTy,
Params, false)))
return F;
// void main(int argc, char **argv)...
if (Function *F = getFunction("main", FunctionType::get(Type::VoidTy,
Params, false)))
return F;
}
// Ok, try to find main the hard way...
return getNamedFunction("main");
}
/// getNamedFunction - Return the first function in the module with the
/// specified name, of arbitrary type. This method returns null if a function
/// with the specified name is not found.
///
Function *Module::getNamedFunction(const std::string &Name) {
// Loop over all of the functions, looking for the function desired
for (iterator I = begin(), E = end(); I != E; ++I)
if (I->getName() == Name)
return I;
return 0; // function not found...
}
// getTypeName - If there is at least one entry in the symbol table for the
// specified type, return it.
//
std::string Module::getTypeName(const Type *Ty) {
const SymbolTable *ST = getSymbolTable();
if (ST == 0) return ""; // No symbol table, must not have an entry...
if (ST->find(Type::TypeTy) == ST->end())
return ""; // No names for types...
SymbolTable::type_const_iterator TI = ST->type_begin(Type::TypeTy);
SymbolTable::type_const_iterator TE = ST->type_end(Type::TypeTy);
while (TI != TE && TI->second != (const Value*)Ty)
++TI;
if (TI != TE) // Must have found an entry!
return TI->first;
return ""; // Must not have found anything...
}
// dropAllReferences() - This function causes all the subelementss to "let go"
// of all references that they are maintaining. This allows one to 'delete' a
// whole module at a time, even though there may be circular references... first
// all references are dropped, and all use counts go to zero. Then everything
// is delete'd for real. Note that no operations are valid on an object that
// has "dropped all references", except operator delete.
//
void Module::dropAllReferences() {
for(Module::iterator I = begin(), E = end(); I != E; ++I)
I->dropAllReferences();
for(Module::giterator I = gbegin(), E = gend(); I != E; ++I)
I->dropAllReferences();
// If there are any GlobalVariable references still out there, nuke them now.
// Since all references are hereby dropped, nothing could possibly reference
// them still. Note that destroying all of the constant pointer refs will
// eventually cause the GVRefMap field to be set to null (by
// destroyConstantPointerRef, below).
//
while (GVRefMap)
// Delete the ConstantPointerRef node...
GVRefMap->Map.begin()->second->destroyConstant();
}
// Accessor for the underlying GlobalValRefMap...
ConstantPointerRef *Module::getConstantPointerRef(GlobalValue *V){
// Create ref map lazily on demand...
if (GVRefMap == 0) GVRefMap = new GlobalValueRefMap();
GlobalValueRefMap::iterator I = GVRefMap->Map.find(V);
if (I != GVRefMap->Map.end()) return I->second;
ConstantPointerRef *Ref = new ConstantPointerRef(V);
GVRefMap->Map[V] = Ref;
return Ref;
}
void Module::destroyConstantPointerRef(ConstantPointerRef *CPR) {
assert(GVRefMap && "No map allocated, but we have a CPR?");
if (!GVRefMap->Map.erase(CPR->getValue())) // Remove it from the map...
assert(0 && "ConstantPointerRef not found in module CPR map!");
if (GVRefMap->Map.empty()) { // If the map is empty, delete it.
delete GVRefMap;
GVRefMap = 0;
}
}
void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
GlobalValueRefMap::iterator I = GVRefMap->Map.find(OldGV);
assert(I != GVRefMap->Map.end() &&
"mutateConstantPointerRef; OldGV not in table!");
ConstantPointerRef *Ref = I->second;
// Remove the old entry...
GVRefMap->Map.erase(I);
// Insert the new entry...
GVRefMap->Map.insert(std::make_pair(NewGV, Ref));
}
|