1 //===-- llvm/TypeSymbolTable.h - Implement a Type Symtab --------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the name/type symbol table for LLVM. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_TYPE_SYMBOL_TABLE_H 15 #define LLVM_TYPE_SYMBOL_TABLE_H 16 17 #include "llvm/Type.h" 18 #include "llvm/ADT/StringRef.h" 19 #include <map> 20 21 namespace llvm { 22 23 class StringRef; 24 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 { 30 31 /// @name Types 32 /// @{ 33 public: 34 35 /// @brief A mapping of names to types. 36 typedef std::map<const std::string, const Type*> TypeMap; 37 38 /// @brief An iterator over the TypeMap. 39 typedef TypeMap::iterator iterator; 40 41 /// @brief A const_iterator over the TypeMap. 42 typedef TypeMap::const_iterator const_iterator; 43 44 /// @} 45 /// @name Constructors 46 /// @{ 47 public: 48 TypeSymbolTable()49 TypeSymbolTable():LastUnique(0) {} 50 ~TypeSymbolTable(); 51 52 /// @} 53 /// @name Accessors 54 /// @{ 55 public: 56 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; 62 63 /// This method finds the type with the given \p name in the type map 64 /// and returns it. 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; 69 70 /// Lookup the type associated with name. 71 /// @returns end() if the name is not found, or an iterator at the entry for 72 /// Type. find(StringRef Name)73 iterator find(StringRef Name) { 74 return tmap.find(Name); 75 } 76 77 /// Lookup the type associated with name. 78 /// @returns end() if the name is not found, or an iterator at the entry for 79 /// Type. find(StringRef Name)80 const_iterator find(StringRef Name) const { 81 return tmap.find(Name); 82 } 83 84 /// @returns true iff the symbol table is empty. 85 /// @brief Determine if the symbol table is empty empty()86 inline bool empty() const { return tmap.empty(); } 87 88 /// @returns the size of the symbol table 89 /// @brief The number of name/type pairs is returned. size()90 inline unsigned size() const { return unsigned(tmap.size()); } 91 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 95 void dump() const; 96 97 /// @} 98 /// @name Iteration 99 /// @{ 100 public: 101 /// Get an iterator to the start of the symbol table begin()102 inline iterator begin() { return tmap.begin(); } 103 104 /// @brief Get a const_iterator to the start of the symbol table begin()105 inline const_iterator begin() const { return tmap.begin(); } 106 107 /// Get an iterator to the end of the symbol table. end()108 inline iterator end() { return tmap.end(); } 109 110 /// Get a const_iterator to the end of the symbol table. end()111 inline const_iterator end() const { return tmap.end(); } 112 113 /// @} 114 /// @name Mutators 115 /// @{ 116 public: 117 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); 123 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); 128 129 /// @} 130 /// @name AbstractTypeUser Methods 131 /// @{ 132 private: 133 /// This function is called when one of the types in the type plane 134 /// is refined. 135 virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy); 136 137 /// This function markes a type as being concrete (defined). 138 virtual void typeBecameConcrete(const DerivedType *AbsTy); 139 140 /// @} 141 /// @name Internal Data 142 /// @{ 143 private: 144 TypeMap tmap; ///< This is the mapping of names to types. 145 mutable uint32_t LastUnique; ///< Counter for tracking unique names 146 147 /// @} 148 149 }; 150 151 } // End llvm namespace 152 153 #endif 154