1 //===-- llvm/TypeSymbolTable.h - Implement a Type Symtab --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the name/type symbol table for LLVM.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_TYPE_SYMBOL_TABLE_H
15 #define LLVM_TYPE_SYMBOL_TABLE_H
17 #include "llvm/Type.h"
18 #include "llvm/ADT/StringRef.h"
25 /// This class provides a symbol table of name/type pairs with operations to
26 /// support constructing, searching and iterating over the symbol table. The
27 /// class derives from AbstractTypeUser so that the contents of the symbol
28 /// table can be updated when abstract types become concrete.
29 class TypeSymbolTable : public AbstractTypeUser {
35 /// @brief A mapping of names to types.
36 typedef std::map<const std::string, const Type*> TypeMap;
38 /// @brief An iterator over the TypeMap.
39 typedef TypeMap::iterator iterator;
41 /// @brief A const_iterator over the TypeMap.
42 typedef TypeMap::const_iterator const_iterator;
45 /// @name Constructors
49 TypeSymbolTable():LastUnique(0) {}
57 /// Generates a unique name for a type based on the \p BaseName by
58 /// incrementing an integer and appending it to the name, if necessary
59 /// @returns the unique name
60 /// @brief Get a unique name for a type
61 std::string getUniqueName(StringRef BaseName) const;
63 /// This method finds the type with the given \p name in the type map
65 /// @returns null if the name is not found, otherwise the Type
66 /// associated with the \p name.
67 /// @brief Lookup a type by name.
68 Type *lookup(StringRef name) const;
70 /// Lookup the type associated with name.
71 /// @returns end() if the name is not found, or an iterator at the entry for
73 iterator find(StringRef Name) {
74 return tmap.find(Name);
77 /// Lookup the type associated with name.
78 /// @returns end() if the name is not found, or an iterator at the entry for
80 const_iterator find(StringRef Name) const {
81 return tmap.find(Name);
84 /// @returns true iff the symbol table is empty.
85 /// @brief Determine if the symbol table is empty
86 inline bool empty() const { return tmap.empty(); }
88 /// @returns the size of the symbol table
89 /// @brief The number of name/type pairs is returned.
90 inline unsigned size() const { return unsigned(tmap.size()); }
92 /// This function can be used from the debugger to display the
93 /// content of the symbol table while debugging.
94 /// @brief Print out symbol table on stderr
101 /// Get an iterator to the start of the symbol table
102 inline iterator begin() { return tmap.begin(); }
104 /// @brief Get a const_iterator to the start of the symbol table
105 inline const_iterator begin() const { return tmap.begin(); }
107 /// Get an iterator to the end of the symbol table.
108 inline iterator end() { return tmap.end(); }
110 /// Get a const_iterator to the end of the symbol table.
111 inline const_iterator end() const { return tmap.end(); }
118 /// Inserts a type into the symbol table with the specified name. There can be
119 /// a many-to-one mapping between names and types. This method allows a type
120 /// with an existing entry in the symbol table to get a new name.
121 /// @brief Insert a type under a new name.
122 void insert(StringRef Name, const Type *Typ);
124 /// Remove a type at the specified position in the symbol table.
125 /// @returns the removed Type.
126 /// @returns the Type that was erased from the symbol table.
127 Type* remove(iterator TI);
130 /// @name AbstractTypeUser Methods
133 /// This function is called when one of the types in the type plane
135 virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
137 /// This function markes a type as being concrete (defined).
138 virtual void typeBecameConcrete(const DerivedType *AbsTy);
141 /// @name Internal Data
144 TypeMap tmap; ///< This is the mapping of names to types.
145 mutable uint32_t LastUnique; ///< Counter for tracking unique names
151 } // End llvm namespace