llvm-6502/include/llvm/SymbolTable.h
Chris Lattner bf4515e218 move some method declarations around to make it clear that users should
not call insert(Value *Val), remove(Value* Val), or
changeName(Value *V, const std::string &Name)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@20488 91177308-0d34-0410-b5e6-96231b3b80d8
2005-03-06 06:03:44 +00:00

307 lines
11 KiB
C++

//===-- llvm/SymbolTable.h - Implement a type plane'd symtab ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// 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 the main symbol table for LLVM.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SYMBOL_TABLE_H
#define LLVM_SYMBOL_TABLE_H
#include "llvm/Value.h"
#include <map>
namespace llvm {
/// 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:
/// @brief A mapping of names to types.
typedef std::map<const std::string, const 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;
/// @brief A const_iterator over the type planes
typedef PlaneMap::const_iterator plane_const_iterator;
/// @}
/// @name Constructors
/// @{
public:
SymbolTable() : LastUnique(0) {}
~SymbolTable();
/// @}
/// @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;
/// 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 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(); }
/// @brief The number of name/type pairs is returned.
inline unsigned num_types() const { return (unsigned)tmap.size(); }
/// 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 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();
}
/// 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();
}
/// 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();
}
/// 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();
}
/// Get an iterator to the start of the name/Type map.
inline type_iterator type_begin() { return tmap.begin(); }
/// @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.
/// @brief 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);
}
/// @}
/// @name Mutators
/// @{
public:
/// This method will strip the symbol table of its names leaving the type and
/// values.
/// @brief Strip the symbol table.
bool strip();
/// 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.
void insert(const std::string &Name, const Type *Typ);
/// Remove a type at the specified position in the symbol table.
/// @returns the removed Type.
Type* remove(type_iterator TI);
/// @}
/// @name Mutators used by Value::setName and other LLVM internals.
/// @{
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);
}
/// 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);
/// changeName - Given a value with a non-empty name, remove its existing
/// entry from the symbol table and insert a new one for Name. This is
/// equivalent to doing "remove(V), V->Name = Name, insert(V)", but is faster,
/// and will not temporarily remove the symbol table plane if V is the last
/// value in the symtab with that name (which could invalidate iterators to
/// that plane).
void changeName(Value *V, const std::string &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);
/// 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.
/// @brief The mapping of types to names to values.
PlaneMap pmap;
/// This is the type 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;
/// 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