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
| //===- llvm/ValueSymbolTable.h - Implement a Value Symtab -------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the name/Value symbol table for LLVM.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_IR_VALUESYMBOLTABLE_H
#define LLVM_IR_VALUESYMBOLTABLE_H
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/Value.h"
#include <cstdint>
namespace llvm {
class Argument;
class BasicBlock;
class Function;
class GlobalAlias;
class GlobalIFunc;
class GlobalVariable;
class Instruction;
template <unsigned InternalLen> class SmallString;
template <typename ValueSubClass> class SymbolTableListTraits;
/// 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 SymbolTableListTraits<Argument>;
friend class SymbolTableListTraits<BasicBlock>;
friend class SymbolTableListTraits<Function>;
friend class SymbolTableListTraits<GlobalAlias>;
friend class SymbolTableListTraits<GlobalIFunc>;
friend class SymbolTableListTraits<GlobalVariable>;
friend class SymbolTableListTraits<Instruction>;
friend class Value;
/// @name Types
/// @{
public:
/// A mapping of names to values.
using ValueMap = StringMap<Value*>;
/// An iterator over a ValueMap.
using iterator = ValueMap::iterator;
/// A const_iterator over a ValueMap.
using const_iterator = ValueMap::const_iterator;
/// @}
/// @name Constructors
/// @{
ValueSymbolTable() : vmap(0) {}
~ValueSymbolTable();
/// @}
/// @name Accessors
/// @{
/// This method finds the value with the given \p Name in the
/// the symbol table.
/// @returns the value associated with the \p Name
/// Lookup a named Value.
Value *lookup(StringRef Name) const { return vmap.lookup(Name); }
/// @returns true iff the symbol table is empty
/// Determine if the symbol table is empty
inline bool empty() const { return vmap.empty(); }
/// 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.
/// Print out symbol table on stderr
void dump() const;
/// @}
/// @name Iteration
/// @{
/// Get an iterator that from the beginning of the symbol table.
inline iterator begin() { return vmap.begin(); }
/// Get a const_iterator that from the beginning of the symbol table.
inline const_iterator begin() const { return vmap.begin(); }
/// Get an iterator to the end of the symbol table.
inline iterator end() { return vmap.end(); }
/// Get a const_iterator to the end of the symbol table.
inline const_iterator end() const { return vmap.end(); }
/// @}
/// @name Mutators
/// @{
private:
ValueName *makeUniqueName(Value *V, SmallString<256> &UniqueName);
/// 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.
/// 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
/// @{
ValueMap vmap; ///< The map that holds the symbol table.
mutable uint32_t LastUnique = 0; ///< Counter for tracking unique names
/// @}
};
} // end namespace llvm
#endif // LLVM_IR_VALUESYMBOLTABLE_H
|