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
|
//===-- llvm/ValueSymbolTable.h - Implement a Value Symtab ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the name/Value symbol table for LLVM.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_VALUE_SYMBOL_TABLE_H
#define LLVM_VALUE_SYMBOL_TABLE_H
#include "llvm/Value.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/System/DataTypes.h"
namespace llvm {
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
class BasicBlock;
class Function;
class NamedMDNode;
class Module;
class StringRef;
/// This class provides a symbol table of name/value pairs. It is essentially
/// a std::map<std::string,Value*> but has a controlled interface provided by
/// LLVM as well as ensuring uniqueness of names.
///
class ValueSymbolTable {
friend class Value;
friend class SymbolTableListTraits<Argument, Function>;
friend class SymbolTableListTraits<BasicBlock, Function>;
friend class SymbolTableListTraits<Instruction, BasicBlock>;
friend class SymbolTableListTraits<Function, Module>;
friend class SymbolTableListTraits<GlobalVariable, Module>;
friend class SymbolTableListTraits<GlobalAlias, Module>;
/// @name Types
/// @{
public:
/// @brief A mapping of names to values.
typedef StringMap<Value*> ValueMap;
/// @brief An iterator over a ValueMap.
typedef ValueMap::iterator iterator;
/// @brief A const_iterator over a ValueMap.
typedef ValueMap::const_iterator const_iterator;
/// @}
/// @name Constructors
/// @{
public:
ValueSymbolTable() : vmap(0), LastUnique(0) {}
~ValueSymbolTable();
/// @}
/// @name Accessors
/// @{
public:
/// This method finds the value with the given \p Name in the
/// the symbol table.
/// @returns the value associated with the \p Name
/// @brief Lookup a named Value.
Value *lookup(StringRef Name) const { return vmap.lookup(Name); }
/// @returns true iff the symbol table is empty
/// @brief Determine if the symbol table is empty
inline bool empty() const { return vmap.empty(); }
/// @brief The number of name/type pairs is returned.
inline unsigned size() const { return unsigned(vmap.size()); }
/// This function can be used from the debugger to display the
/// content of the symbol table while debugging.
/// @brief Print out symbol table on stderr
void dump() const;
/// @}
/// @name Iteration
/// @{
public:
/// @brief Get an iterator that from the beginning of the symbol table.
inline iterator begin() { return vmap.begin(); }
/// @brief Get a const_iterator that from the beginning of the symbol table.
inline const_iterator begin() const { return vmap.begin(); }
/// @brief Get an iterator to the end of the symbol table.
inline iterator end() { return vmap.end(); }
/// @brief Get a const_iterator to the end of the symbol table.
inline const_iterator end() const { return vmap.end(); }
/// @}
/// @name Mutators
/// @{
private:
/// This method adds the provided value \p N to the symbol table. The Value
/// must have a name which is used to place the value in the symbol table.
/// If the inserted name conflicts, this renames the value.
/// @brief Add a named value to the symbol table
void reinsertValue(Value *V);
/// createValueName - This method attempts to create a value name and insert
/// it into the symbol table with the specified name. If it conflicts, it
/// auto-renames the name and returns that instead.
ValueName *createValueName(StringRef Name, Value *V);
/// This method removes a value from the symbol table. It leaves the
/// ValueName attached to the value, but it is no longer inserted in the
/// symtab.
void removeValueName(ValueName *V);
/// @}
/// @name Internal Data
/// @{
private:
ValueMap vmap; ///< The map that holds the symbol table.
mutable uint32_t LastUnique; ///< Counter for tracking unique names
/// @}
};
/// This class provides a symbol table of name/NamedMDNode pairs. It is
/// essentially a StringMap wrapper.
class MDSymbolTable {
friend class SymbolTableListTraits<NamedMDNode, Module>;
/// @name Types
/// @{
private:
/// @brief A mapping of names to metadata
typedef StringMap<NamedMDNode*> MDMap;
public:
/// @brief An iterator over a ValueMap.
typedef MDMap::iterator iterator;
/// @brief A const_iterator over a ValueMap.
typedef MDMap::const_iterator const_iterator;
/// @}
/// @name Constructors
/// @{
public:
MDSymbolTable(const MDNode &); // DO NOT IMPLEMENT
void operator=(const MDSymbolTable &); // DO NOT IMPLEMENT
MDSymbolTable() : mmap(0) {}
~MDSymbolTable();
/// @}
/// @name Accessors
/// @{
public:
/// This method finds the value with the given \p Name in the
/// the symbol table.
/// @returns the NamedMDNode associated with the \p Name
/// @brief Lookup a named Value.
NamedMDNode *lookup(StringRef Name) const { return mmap.lookup(Name); }
/// @returns true iff the symbol table is empty
/// @brief Determine if the symbol table is empty
inline bool empty() const { return mmap.empty(); }
/// @brief The number of name/type pairs is returned.
inline unsigned size() const { return unsigned(mmap.size()); }
/// @}
/// @name Iteration
/// @{
public:
/// @brief Get an iterator that from the beginning of the symbol table.
inline iterator begin() { return mmap.begin(); }
/// @brief Get a const_iterator that from the beginning of the symbol table.
inline const_iterator begin() const { return mmap.begin(); }
/// @brief Get an iterator to the end of the symbol table.
inline iterator end() { return mmap.end(); }
/// @brief Get a const_iterator to the end of the symbol table.
inline const_iterator end() const { return mmap.end(); }
/// @}
/// @name Mutators
/// @{
public:
/// insert - The method inserts a new entry into the stringmap. This will
/// replace existing entry, if any.
void insert(StringRef Name, NamedMDNode *Node) {
StringMapEntry<NamedMDNode *> &Entry =
mmap.GetOrCreateValue(Name, Node);
if (Entry.getValue() != Node) {
mmap.remove(&Entry);
(void) mmap.GetOrCreateValue(Name, Node);
}
}
/// This method removes a NamedMDNode from the symbol table.
void remove(StringRef Name) { mmap.erase(Name); }
/// @}
/// @name Internal Data
/// @{
private:
MDMap mmap; ///< The map that holds the symbol table.
/// @}
};
} // End llvm namespace
#endif
|
