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
|
//===-- Module.cpp - Implement the Module class ------------------*- C++ -*--=//
//
// This file implements the Module class for the VMCore library.
//
//===----------------------------------------------------------------------===//
#include "llvm/Module.h"
#include "llvm/Function.h"
#include "llvm/GlobalVariable.h"
#include "llvm/InstrTypes.h"
#include "llvm/Type.h"
#include "llvm/ConstantVals.h"
#include "llvm/DerivedTypes.h"
#include "Support/STLExtras.h"
#include "ValueHolderImpl.h"
#include <map>
// Instantiate Templates - This ugliness is the price we have to pay
// for having a DefHolderImpl.h file seperate from DefHolder.h! :(
//
template class ValueHolder<GlobalVariable, Module, Module>;
template class ValueHolder<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 : public std::map<GlobalValue*, ConstantPointerRef*>{
};
Module::Module() : GlobalList(this, this), FunctionList(this, this) {
GVRefMap = 0;
SymTab = 0;
}
Module::~Module() {
dropAllReferences();
GlobalList.delete_all();
GlobalList.setParent(0);
FunctionList.delete_all();
FunctionList.setParent(0);
delete SymTab;
}
SymbolTable *Module::getSymbolTableSure() {
if (!SymTab) SymTab = new SymbolTable(0);
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;
}
// 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 subinstructions to "let
// go" of all references that they are maintaining. This allows one to
// 'delete' a whole class 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_each(FunctionList.begin(), FunctionList.end(),
std::mem_fun(&Function::dropAllReferences));
for_each(GlobalList.begin(), GlobalList.end(),
std::mem_fun(&GlobalVariable::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.
if (GVRefMap) {
for (GlobalValueRefMap::iterator I = GVRefMap->begin(), E = GVRefMap->end();
I != E; ++I) {
// Delete the ConstantPointerRef node...
I->second->destroyConstant();
}
// Since the table is empty, we can now delete it...
delete GVRefMap;
}
}
// 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->find(V);
if (I != GVRefMap->end()) return I->second;
ConstantPointerRef *Ref = new ConstantPointerRef(V);
GVRefMap->insert(std::make_pair(V, Ref));
return Ref;
}
void Module::mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV) {
GlobalValueRefMap::iterator I = GVRefMap->find(OldGV);
assert(I != GVRefMap->end() &&
"mutateConstantPointerRef; OldGV not in table!");
ConstantPointerRef *Ref = I->second;
// Remove the old entry...
GVRefMap->erase(I);
// Insert the new entry...
GVRefMap->insert(std::make_pair(NewGV, Ref));
}
|
