[llvm-commits] CVS: llvm/include/llvm/SymbolTable.h
LLVM
llvm at cs.uiuc.edu
Tue May 25 07:22:32 PDT 2004
Changes in directory llvm/include/llvm:
SymbolTable.h updated: 1.30 -> 1.31
---
Log message:
Completely rewrote the class. SymbolTable now separates Type* from Value* in preparation\
for making Type not derive from Value. There are now separate interfaces \
for looking up, finding, and inserting Types and Values. There are also \
three separate iterator interfaces, one for type planes, one for the types \
(type type plane), and one for values within a type plane. See the \
documentation in the Header file.
---
Diffs of the changes: (+336 -83)
Index: llvm/include/llvm/SymbolTable.h
diff -u llvm/include/llvm/SymbolTable.h:1.30 llvm/include/llvm/SymbolTable.h:1.31
--- llvm/include/llvm/SymbolTable.h:1.30 Wed Dec 31 01:08:19 2003
+++ llvm/include/llvm/SymbolTable.h Tue May 25 03:45:53 2004
@@ -2,21 +2,13 @@
//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file was developed by the LLVM research group and re-written by Reid
+// Spencer. It is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
-// This file implements a symbol table that has planes broken up by type.
-// Identical types may have overlapping symbol names as long as they are
-// distinct.
-//
-// Note that this implements a chained symbol table. If a name being 'lookup'd
-// isn't found in the current symbol table, then the parent symbol table is
-// searched.
-//
-// This chaining behavior does NOT affect iterators though: only the lookup
-// method.
+// This file implements the main symbol table for LLVM.
//
//===----------------------------------------------------------------------===//
@@ -28,112 +20,373 @@
namespace llvm {
-class SymbolTable : public AbstractTypeUser,
- public std::map<const Type *,
- std::map<const std::string, Value *> > {
+/// This class provides a symbol table of name/value pairs that is broken
+/// up by type. For each Type* there is a "plane" of name/value pairs in
+/// the symbol table. Identical types may have overlapping symbol names as
+/// long as they are distinct. The SymbolTable also tracks, separately, a
+/// map of name/type pairs. This allows types to be named. Types are treated
+/// distinctly from Values.
+///
+/// The SymbolTable provides several utility functions for answering common
+/// questions about its contents as well as an iterator interface for
+/// directly iterating over the contents. To reduce confusion, the terms
+/// "type", "value", and "plane" are used consistently. For example,
+/// There is a TypeMap typedef that is the mapping of names to Types.
+/// Similarly there is a ValueMap typedef that is the mapping of
+/// names to Values. Finally, there is a PlaneMap typedef that is the
+/// mapping of types to planes of ValueMap. THis is the basic structure
+/// of the symbol table. When you call type_begin() you're asking
+/// for an iterator at the start of the TypeMap. When you call
+/// plane_begin(), you're asking for an iterator at the start of
+/// the PlaneMap. Finally, when you call value_begin(), you're asking
+/// for an iterator at the start of a ValueMap for a specific type
+/// plane.
+class SymbolTable : public AbstractTypeUser {
+
+/// @name Types
+/// @{
public:
- typedef std::map<const std::string, Value *> VarMap;
- typedef std::map<const Type *, VarMap> super;
- typedef VarMap::iterator type_iterator;
- typedef VarMap::const_iterator type_const_iterator;
+ /// @brief A mapping of names to types.
+ typedef std::map<const std::string, Type*> TypeMap;
+
+ /// @brief An iterator over the TypeMap.
+ typedef TypeMap::iterator type_iterator;
+
+ /// @brief A const_iterator over the TypeMap.
+ typedef TypeMap::const_iterator type_const_iterator;
+
+ /// @brief A mapping of names to values.
+ typedef std::map<const std::string, Value *> ValueMap;
+
+ /// @brief An iterator over a ValueMap.
+ typedef ValueMap::iterator value_iterator;
+
+ /// @brief A const_iterator over a ValueMap.
+ typedef ValueMap::const_iterator value_const_iterator;
+
+ /// @brief A mapping of types to names to values (type planes).
+ typedef std::map<const Type *, ValueMap> PlaneMap;
+
+ /// @brief An iterator over the type planes.
+ typedef PlaneMap::iterator plane_iterator;
- inline SymbolTable() : InternallyInconsistent(false), LastUnique(0) {}
+ /// @brief A const_iterator over the type planes
+ typedef PlaneMap::const_iterator plane_const_iterator;
+
+/// @}
+/// @name Constructors
+/// @{
+public:
+
+ inline SymbolTable()
+ : pmap(), tmap(), InternallyInconsistent(false), LastUnique(0) {}
~SymbolTable();
- // lookup - Returns null on failure...
+/// @}
+/// @name Accessors
+/// @{
+public:
+
+ /// This method finds the value with the given \p name in the
+ /// type plane \p Ty and returns it. This method will not find any
+ /// Types, only Values. Use lookupType to find Types by name.
+ /// @returns null on failure, otherwise the Value associated with
+ /// the \p name in type plane \p Ty.
+ /// @brief Lookup a named, typed value.
Value *lookup(const Type *Ty, const std::string &name) const;
- // insert - Add named definition to the symbol table...
- inline void insert(Value *N) {
- assert(N->hasName() && "Value must be named to go into symbol table!");
- insertEntry(N->getName(), N->getType(), N);
+ /// This method finds the type with the given \p name in the
+ /// type map and returns it.
+ /// @returns null if the name is not found, otherwise the Type
+ /// associated with the \p name.
+ /// @brief Lookup a type by name.
+ Type* lookupType( const std::string& name ) const;
+
+ /// @returns true iff the type map is not empty.
+ /// @brief Determine if there are types in the symbol table
+ inline bool hasTypes() const { return ! tmap.empty(); }
+
+ /// @returns true iff the type map and the type plane are both not
+ /// empty.
+ /// @brief Determine if the symbol table is empty
+ inline bool isEmpty() const { return pmap.empty() && tmap.empty(); }
+
+ /// The plane associated with the \p TypeID parameter is found
+ /// and the number of entries in the plane is returned.
+ /// @returns Number of entries in the specified type plane or 0.
+ /// @brief Get the size of a type plane.
+ unsigned type_size(const Type *TypeID) const;
+
+ /// @brief The number of name/type pairs is returned.
+ inline unsigned num_types() const { return tmap.size(); }
+
+ /// Finds the value \p val in the symbol table and returns its
+ /// name. Only the type plane associated with the type of \p val
+ /// is searched.
+ /// @brief Return the name of a value
+ std::string get_name( const Value* Val ) const;
+
+ /// Finds the type \p Ty in the symbol table and returns its name.
+ /// @brief Return the name of a type
+ std::string get_name( const Type* Ty ) const;
+
+ /// Given a base name, return a string that is either equal to it or
+ /// derived from it that does not already occur in the symbol table
+ /// for the specified type.
+ /// @brief Get a name unique to this symbol table
+ std::string getUniqueName(const Type *Ty,
+ const std::string &BaseName) const;
+
+ /// 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 Mutators
+/// @{
+public:
+
+ /// This method adds the provided value \p N to the symbol table.
+ /// The Value must have both a name and a type which are extracted
+ /// and used to place the value in the correct type plane under
+ /// the value's name.
+ /// @brief Add a named value to the symbol table
+ inline void insert(Value *Val) {
+ assert(Val && "Can't insert null type into symbol table!");
+ assert(Val->hasName() && "Value must be named to go into symbol table!");
+ insertEntry(Val->getName(), Val->getType(), Val);
}
- void remove(Value *N);
- Value *type_remove(const type_iterator &It) {
- return removeEntry(find(It->second->getType()), It);
+ /// Inserts a constant or type into the symbol table with the specified
+ /// name. There can be a many to one mapping between names and constants
+ /// or types.
+ /// @brief Insert a constant or type.
+ inline void insert(const std::string &Name, Value *Val) {
+ assert(Val && "Can't insert null type into symbol table!");
+ assert((isa<Type>(Val) || isa<Constant>(Val)) &&
+ "Can only insert types and constants into a symbol table!");
+ insertEntry(Name, Val->getType(), Val);
}
- // insert - Insert a constant or type into the symbol table with the specified
- // name... There can be a many to one mapping between names and
- // (constant/type)s.
- //
- inline void insert(const std::string &Name, Value *V) {
- assert((isa<Type>(V) || isa<Constant>(V)) &&
- "Can only insert types and constants here!");
- insertEntry(Name, V->getType(), V);
+ /// Inserts a type into the symbol table with the specified name. There
+ /// can be a many-to-one mapping between names and types. This method
+ /// allows a type with an existing entry in the symbol table to get
+ /// a new name.
+ /// @brief Insert a type under a new name.
+ inline void insert(const std::string &Name, Type *Typ) {
+ assert(Typ && "Can't insert null type into symbol table!");
+ insertEntry(Name, Typ );
}
- /// remove - Remove a constant or type from the symbol table with the
- /// specified name.
- Value *remove(const std::string &Name, Value *V) {
- iterator TI = find(V->getType());
- return removeEntry(TI, TI->second.find(Name));
+ /// This method removes a named value from the symbol table. The
+ /// type and name of the Value are extracted from \p N and used to
+ /// lookup the Value in the correct type plane. If the Value is
+ /// not in the symbol table, this method silently ignores the
+ /// request.
+ /// @brief Remove a named value from the symbol table.
+ void remove(Value* Val);
+
+ /// This method removes a named type from the symbol table. The
+ /// name of the type is extracted from \P T and used to look up
+ /// the Type in the type map. If the Type is not in the symbol
+ /// table, this method silently ignores the request.
+ /// @brief Remove a named type from the symbol table.
+ void remove(Type* Typ );
+
+ /// Remove a constant or type with the specified name from the
+ /// symbol table.
+ /// @returns the removed Value.
+ /// @brief Remove a constant or type from the symbol table.
+ inline Value* remove(const std::string &Name, Value *Val) {
+ assert(Val && "Can't remove null value from symbol table!");
+ plane_iterator PI = pmap.find(Val->getType());
+ return removeEntry(PI, PI->second.find(Name));
}
- // getUniqueName - Given a base name, return a string that is either equal to
- // it (or derived from it) that does not already occur in the symbol table for
- // the specified type.
- //
- std::string getUniqueName(const Type *Ty, const std::string &BaseName);
+ /// Remove a type with the specified name from the symbol table.
+ /// @returns the removed Type.
+ /// @brief Remove a named tyep from the symbol table.
+ inline Type* remove(const std::string& Name, Type* T ) {
+ return removeEntry( tmap.find(Name) );
+ }
- inline unsigned type_size(const Type *TypeID) const {
- return find(TypeID)->second.size();
+ /// Removes a specific value from the symbol table.
+ /// @returns the removed value.
+ /// @brief Remove a specific value given by an iterator
+ inline Value *value_remove(const value_iterator &It) {
+ return this->removeEntry(pmap.find(It->second->getType()), It);
}
- // Note that type_begin / type_end only work if you know that an element of
- // TypeID is already in the symbol table!!!
- //
- inline type_iterator type_begin(const Type *TypeID) {
- return find(TypeID)->second.begin();
+ /// This method will strip the symbol table of its names leaving
+ /// the type and values.
+ /// @brief Strip the symbol table.
+ bool strip();
+
+ /// @brief Empty the symbol table completely.
+ inline void clear() { pmap.clear(); tmap.clear(); }
+
+/// @}
+/// @name Iteration
+/// @{
+public:
+
+ /// Get an iterator that starts at the beginning of the type planes.
+ /// The iterator will iterate over the Type/ValueMap pairs in the
+ /// type planes.
+ inline plane_iterator plane_begin() { return pmap.begin(); }
+
+ /// Get a const_iterator that starts at the beginning of the type
+ /// planes. The iterator will iterate over the Type/ValueMap pairs
+ /// in the type planes.
+ inline plane_const_iterator plane_begin() const { return pmap.begin(); }
+
+ /// Get an iterator at the end of the type planes. This serves as
+ /// the marker for end of iteration over the type planes.
+ inline plane_iterator plane_end() { return pmap.end(); }
+
+ /// Get a const_iterator at the end of the type planes. This serves as
+ /// the marker for end of iteration over the type planes.
+ inline plane_const_iterator plane_end() const { return pmap.end(); }
+
+ /// Get an iterator that starts at the beginning of a type plane.
+ /// The iterator will iterate over the name/value pairs in the type plane.
+ /// @note The type plane must already exist before using this.
+ inline value_iterator value_begin(const Type *Typ) {
+ assert(Typ && "Can't get value iterator with null type!");
+ return pmap.find(Typ)->second.begin();
}
- inline type_const_iterator type_begin(const Type *TypeID) const {
- return find(TypeID)->second.begin();
+
+ /// Get a const_iterator that starts at the beginning of a type plane.
+ /// The iterator will iterate over the name/value pairs in the type plane.
+ /// @note The type plane must already exist before using this.
+ inline value_const_iterator value_begin(const Type *Typ) const {
+ assert(Typ && "Can't get value iterator with null type!");
+ return pmap.find(Typ)->second.begin();
}
- inline type_iterator type_end(const Type *TypeID) {
- return find(TypeID)->second.end();
+ /// Get an iterator to the end of a type plane. This serves as the marker
+ /// for end of iteration of the type plane.
+ /// @note The type plane must already exist before using this.
+ inline value_iterator value_end(const Type *Typ) {
+ assert(Typ && "Can't get value iterator with null type!");
+ return pmap.find(Typ)->second.end();
}
- inline type_const_iterator type_end(const Type *TypeID) const {
- return find(TypeID)->second.end();
+
+ /// Get a const_iterator to the end of a type plane. This serves as the
+ /// marker for end of iteration of the type plane.
+ /// @note The type plane must already exist before using this.
+ inline value_const_iterator value_end(const Type *Typ) const {
+ assert(Typ && "Can't get value iterator with null type!");
+ return pmap.find(Typ)->second.end();
}
- void dump() const; // Debug method, print out symbol table
+ /// Get an iterator to the start of the name/Type map.
+ inline type_iterator type_begin() { return tmap.begin(); }
-private:
- // InternallyInconsistent - There are times when the symbol table is
- // internally inconsistent with the rest of the program. In this one case, a
- // value exists with a Name, and it's not in the symbol table. When we call
- // V->setName(""), it tries to remove itself from the symbol table and dies.
- // We know this is happening, and so if the flag InternallyInconsistent is
- // set, removal from the symbol table is a noop.
- //
- bool InternallyInconsistent;
+ /// @brief Get a const_iterator to the start of the name/Type map.
+ inline type_const_iterator type_begin() const { return tmap.begin(); }
+
+ /// Get an iterator to the end of the name/Type map. This serves as the
+ /// marker for end of iteration of the types.
+ inline type_iterator type_end() { return tmap.end(); }
+
+ /// Get a const-iterator to the end of the name/Type map. This serves
+ /// as the marker for end of iteration of the types.
+ inline type_const_iterator type_end() const { return tmap.end(); }
+
+ /// This method returns a plane_const_iterator for iteration over
+ /// the type planes starting at a specific plane, given by \p Ty.
+ /// @brief Find a type plane.
+ inline plane_const_iterator find(const Type* Typ ) const {
+ assert(Typ && "Can't find type plane with null type!");
+ return pmap.find( Typ );
+ }
+
+ /// This method returns a plane_iterator for iteration over the
+ /// type planes starting at a specific plane, given by \p Ty.
+ /// @breif Find a type plane.
+ inline plane_iterator find( const Type* Typ ) {
+ assert(Typ && "Can't find type plane with null type!");
+ return pmap.find(Typ);
+ }
- // LastUnique - This value is used to retain the last unique value used
- // by getUniqueName to generate unique names.
- unsigned long LastUnique;
-
- inline super::value_type operator[](const Type *Ty) {
- assert(0 && "Should not use this operator to access symbol table!");
- return super::value_type();
+ /// This method returns a ValueMap* for a specific type plane. This
+ /// interface is deprecated and may go away in the future.
+ /// @deprecated
+ /// @brief Find a type plane
+ inline const ValueMap* findPlane( const Type* Typ ) const {
+ assert(Typ && "Can't find type plane with null type!");
+ plane_const_iterator I = pmap.find( Typ );
+ if ( I == pmap.end() ) return 0;
+ return &I->second;
}
- // insertEntry - Insert a value into the symbol table with the specified
- // name...
- //
+/// @}
+/// @name Internal Methods
+/// @{
+private:
+ /// @brief Insert a value into the symbol table with the specified name.
void insertEntry(const std::string &Name, const Type *Ty, Value *V);
- // removeEntry - Remove a value from the symbol table...
- //
- Value *removeEntry(iterator Plane, type_iterator Entry);
+ /// @brief Insert a type into the symbol table with the specified name.
+ void insertEntry(const std::string &Name, Type *T);
+
+ /// Remove a specific value from a specific plane in the SymbolTable.
+ /// @returns the removed Value.
+ Value* removeEntry(plane_iterator Plane, value_iterator Entry);
+
+ /// Remove a specific type from the SymbolTable.
+ /// @returns the removed Type.
+ Type* removeEntry(type_iterator Entry);
- // This function is called when one of the types in the type plane are refined
+ /// This function is called when one of the types in the type plane
+ /// is refined.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
+
+ /// This function markes a type as being concrete (defined).
virtual void typeBecameConcrete(const DerivedType *AbsTy);
+
+/// @}
+/// @name Internal Data
+/// @{
+private:
+
+ /// This is the main content of the symbol table. It provides
+ /// separate type planes for named values. That is, each named
+ /// value is organized into a separate dictionary based on
+ /// Type. This means that the same name can be used for different
+ /// types without conflict. Note that the Type::TypeTy plane is
+ /// not stored in this map but is in tmap.
+ /// @brief The mapping of types to names to values.
+ PlaneMap pmap;
+
+ /// This is the Type::TypeTy plane. It is separated from the pmap
+ /// because the elements of the map are name/Type pairs not
+ /// name/Value pairs and Type is not a Value.
+ TypeMap tmap;
+
+ /// There are times when the symbol table is internally inconsistent with
+ /// the rest of the program. In this one case, a value exists with a Name,
+ /// and it's not in the symbol table. When we call V->setName(""), it
+ /// tries to remove itself from the symbol table and dies. We know this
+ /// is happening, and so if the flag InternallyInconsistent is set,
+ /// removal from the symbol table is a noop.
+ /// @brief Indicator of symbol table internal inconsistency.
+ bool InternallyInconsistent;
+
+ /// This value is used to retain the last unique value used
+ /// by getUniqueName to generate unique names.
+ mutable unsigned long LastUnique;
+
+/// @}
+
};
} // End llvm namespace
+// vim: sw=2
+
#endif
+
More information about the llvm-commits
mailing list