LLVM API Documentation
00001 //===-- Internal/SlotTable.h - Type/Value Slot Holder -----------*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file was developed by Reid Spencer and is distributed under 00006 // the University of Illinois Open Source License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file declares the SlotTable class for type plane numbering. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #ifndef LLVM_INTERNAL_SLOTTABLE_H 00015 #define LLVM_INTERNAL_SLOTTABLE_H 00016 00017 #include <vector> 00018 #include <map> 00019 00020 namespace llvm { 00021 00022 // Forward declarations 00023 class Value; 00024 class Type; 00025 class Module; 00026 class Function; 00027 class SymbolTable; 00028 class ConstantArray; 00029 00030 /// This class is the common abstract data type for both the SlotMachine and 00031 /// the SlotCalculator. It provides the two-way mapping between Values and 00032 /// Slots as well as the two-way mapping between Types and Slots. For Values, 00033 /// the slot number can be extracted by simply using the getSlot() 00034 /// method and passing in the Value. For Types, it is the same. 00035 /// @brief Abstract data type for slot numbers. 00036 class SlotTable 00037 { 00038 /// @name Types 00039 /// @{ 00040 public: 00041 00042 /// This type is used throughout the code to make it clear that 00043 /// an unsigned value refers to a Slot number and not something else. 00044 /// @brief Type slot number identification type. 00045 typedef unsigned SlotNum; 00046 00047 /// This type is used throughout the code to make it clear that an 00048 /// unsigned value refers to a type plane number and not something else. 00049 /// @brief The type of a plane number (corresponds to Type::TypeID). 00050 typedef unsigned PlaneNum; 00051 00052 /// @brief Some constants used as flags instead of actual slot numbers 00053 enum Constants { 00054 MAX_SLOT = 4294967294U, 00055 BAD_SLOT = 4294967295U 00056 }; 00057 00058 /// @brief A single plane of Values. Intended index is slot number. 00059 typedef std::vector<const Value*> ValuePlane; 00060 00061 /// @brief A table of Values. Intended index is Type::TypeID. 00062 typedef std::vector<ValuePlane> ValueTable; 00063 00064 /// @brief A map of values to slot numbers. 00065 typedef std::map<const Value*,SlotNum> ValueMap; 00066 00067 /// @brief A single plane of Types. Intended index is slot number. 00068 typedef std::vector<const Type*> TypePlane; 00069 00070 /// @brief A map of types to slot numbers. 00071 typedef std::map<const Type*,SlotNum> TypeMap; 00072 00073 /// @} 00074 /// @name Constructors 00075 /// @{ 00076 public: 00077 /// This constructor initializes all the containers in the SlotTable 00078 /// to empty and then inserts all the primitive types into the type plane 00079 /// by default. This is done as a convenience since most uses of the 00080 /// SlotTable will need the primitive types. If you don't need them, pass 00081 /// in true. 00082 /// @brief Default Constructor 00083 explicit SlotTable( 00084 bool dont_insert_primitives = false ///< Control insertion of primitives. 00085 ); 00086 00087 /// @} 00088 /// @name Accessors 00089 /// @{ 00090 public: 00091 /// @brief Get the number of planes of values. 00092 size_t value_size() const { return vTable.size(); } 00093 00094 /// @brief Determine if a specific type plane in the value table exists 00095 bool plane_exists(PlaneNum plane) const { 00096 return vTable.size() > plane; 00097 } 00098 00099 /// @brief Determine if a specific type plane in the value table is empty 00100 bool plane_empty(PlaneNum plane) const { 00101 return (plane_exists(plane) ? vTable[plane].empty() : true); 00102 } 00103 00104 /// @brief Get the number of entries in a specific plane of the value table 00105 size_t plane_size(PlaneNum plane) const { 00106 return (plane_exists(plane) ? vTable[plane].size() : 0 ); 00107 } 00108 00109 /// @returns true if the slot table is completely empty. 00110 /// @brief Determine if the SlotTable is empty. 00111 bool empty() const; 00112 00113 /// @returns the slot number or BAD_SLOT if Val is not in table. 00114 /// @brief Get a slot number for a Value. 00115 SlotNum getSlot(const Value* Val) const; 00116 00117 /// @returns the slot number or BAD_SLOT if Type is not in the table. 00118 /// @brief Get a slot number for a Type. 00119 SlotNum getSlot(const Type* Typ) const; 00120 00121 /// @returns true iff the Value is in the table. 00122 /// @brief Determine if a Value has a slot number. 00123 bool hasSlot(const Value* Val) { return getSlot(Val) != BAD_SLOT; } 00124 00125 /// @returns true iff the Type is in the table. 00126 /// @brief Determine if a Type has a slot number. 00127 bool hasSlot(const Type* Typ) { return getSlot(Typ) != BAD_SLOT; } 00128 00129 /// @} 00130 /// @name Mutators 00131 /// @{ 00132 public: 00133 /// @brief Completely clear the SlotTable; 00134 void clear(); 00135 00136 /// @brief Resize the table to incorporate at least \p new_size planes 00137 void resize( size_t new_size ); 00138 00139 /// @returns the slot number of the newly inserted value in its plane 00140 /// @brief Add a Value to the SlotTable 00141 SlotNum insert(const Value* Val, PlaneNum plane ); 00142 00143 /// @returns the slot number of the newly inserted type 00144 /// @brief Add a Type to the SlotTable 00145 SlotNum insert( const Type* Typ ); 00146 00147 /// @returns the slot number that \p Val had when it was in the table 00148 /// @brief Remove a Value from the SlotTable 00149 SlotNum remove( const Value* Val, PlaneNum plane ); 00150 00151 /// @returns the slot number that \p Typ had when it was in the table 00152 /// @brief Remove a Type from the SlotTable 00153 SlotNum remove( const Type* Typ ); 00154 00155 /// @} 00156 /// @name Implementation Details 00157 /// @{ 00158 private: 00159 /// Insert the primitive types into the type plane. This is called 00160 /// by the constructor to initialize the type plane. 00161 void insertPrimitives(); 00162 00163 /// @} 00164 /// @name Data 00165 /// @{ 00166 private: 00167 /// A two dimensional table of Values indexed by type and slot number. This 00168 /// allows for efficient lookup of a Value by its type and slot number. 00169 ValueTable vTable; 00170 00171 /// A map of Values to unsigned integer. This allows for efficient lookup of 00172 /// A Value's slot number in its type plane. 00173 ValueMap vMap; 00174 00175 /// A one dimensional vector of Types indexed by slot number. Types are 00176 /// handled separately because they are not Values. 00177 TypePlane tPlane; 00178 00179 /// A map of Types to unsigned integer. This allows for efficient lookup of 00180 /// a Type's slot number in the type plane. 00181 TypeMap tMap; 00182 00183 /// @} 00184 00185 }; 00186 00187 } // End llvm namespace 00188 00189 // vim: sw=2 00190 00191 #endif