For PR411:

Take an incremental step towards type plane elimination. This change
separates types from values in the symbol tables by finally making use
of the TypeSymbolTable class. This yields more natural interfaces for
dealing with types and unclutters the SymbolTable class.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32956 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 0 insertions, 110 deletions

diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp
index 7ea3377ab9..c20366cf35 100644
--- a/lib/VMCore/SymbolTable.cpp
+++ b/lib/VMCore/SymbolTable.cpp
@@ -24,12 +24,6 @@ using namespace llvm;
 #define DEBUG_ABSTYPE 0
 
 SymbolTable::~SymbolTable() {
-  // Drop all abstract type references in the type plane...
-  for (type_iterator TI = tmap.begin(), TE = tmap.end(); TI != TE; ++TI) {
-    if (TI->second->isAbstract())   // If abstract, drop the reference...
-      cast<DerivedType>(TI->second)->removeAbstractTypeUser(this);
-  }
-
  // TODO: FIXME: BIG ONE: This doesn't unreference abstract types for the
  // planes that could still have entries!
 
@@ -82,14 +76,6 @@ Value *SymbolTable::lookup(const Type *Ty, const std::string &Name) const {
 }
 
 
-// lookup a type by name - returns null on failure
-Type* SymbolTable::lookupType(const std::string& Name) const {
-  type_const_iterator TI = tmap.find(Name);
-  if (TI != tmap.end())
-    return const_cast<Type*>(TI->second);
-  return 0;
-}
-
 /// 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
@@ -158,32 +144,6 @@ void SymbolTable::remove(Value *N) {
   }
 }
 
-// remove - Remove a type from the symbol table...
-Type* SymbolTable::remove(type_iterator Entry) {
-  assert(Entry != tmap.end() && "Invalid entry to remove!");
-
-  const Type* Result = Entry->second;
-
-#if DEBUG_SYMBOL_TABLE
-  dump();
-  DOUT << " Removing type: " << Entry->first << "\n";
-#endif
-
-  tmap.erase(Entry);
-
-  // If we are removing an abstract type, remove the symbol table from it's use
-  // list...
-  if (Result->isAbstract()) {
-#if DEBUG_ABSTYPE
-    DOUT  << "Removing abstract type from symtab"
-          << Result->getDescription() << "\n";
-#endif
-    cast<DerivedType>(Result)->removeAbstractTypeUser(this);
-  }
-
-  return const_cast<Type*>(Result);
-}
-
 
 // insertEntry - Insert a value into the symbol table with the specified name.
 void SymbolTable::insertEntry(const std::string &Name, const Type *VTy,
@@ -230,34 +190,6 @@ void SymbolTable::insertEntry(const std::string &Name, const Type *VTy,
 }
 
 
-// insertEntry - Insert a type into the symbol table with the specified
-// name...
-//
-void SymbolTable::insert(const std::string& Name, const Type* T) {
-  assert(T && "Can't insert null type into symbol table!");
-
-  // Check to see if there is a naming conflict.  If so, rename this type!
-  std::string UniqueName = Name;
-  if (lookupType(Name))
-    UniqueName = getUniqueName(T, Name);
-
-#if DEBUG_SYMBOL_TABLE
-  dump();
-  DOUT << " Inserting type: " << UniqueName << ": "
-       << T->getDescription() << "\n";
-#endif
-
-  // Insert the tmap entry
-  tmap.insert(make_pair(UniqueName, T));
-
-  // If we are adding an abstract type, add the symbol table to it's use list.
-  if (T->isAbstract()) {
-    cast<DerivedType>(T)->addAbstractTypeUser(this);
-#if DEBUG_ABSTYPE
-    DOUT << "Added abstract type to ST: " << T->getDescription() << "\n";
-#endif
-  }
-}
 
 // Strip the symbol table of its names.
 bool SymbolTable::strip() {
@@ -278,11 +210,6 @@ bool SymbolTable::strip() {
     }
   }
 
-  for (type_iterator TI = tmap.begin(); TI != tmap.end(); ) {
-    remove(TI++);
-    RemovedSymbol = true;
-  }
-
   return RemovedSymbol;
 }
 
@@ -375,28 +302,6 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType,
     // Remove the plane that is no longer used
     pmap.erase(PI);
   }
-
-  // Loop over all of the types in the symbol table, replacing any references
-  // to OldType with references to NewType.  Note that there may be multiple
-  // occurrences, and although we only need to remove one at a time, it's
-  // faster to remove them all in one pass.
-  //
-  for (type_iterator I = type_begin(), E = type_end(); I != E; ++I) {
-    if (I->second == (Type*)OldType) {  // FIXME when Types aren't const.
-#if DEBUG_ABSTYPE
-      DOUT << "Removing type " << OldType->getDescription() << "\n";
-#endif
-      OldType->removeAbstractTypeUser(this);
-
-      I->second = (Type*)NewType;  // TODO FIXME when types aren't const
-      if (NewType->isAbstract()) {
-#if DEBUG_ABSTYPE
-        DOUT << "Added type " << NewType->getDescription() << "\n";
-#endif
-        cast<DerivedType>(NewType)->addAbstractTypeUser(this);
-      }
-    }
-  }
 }
 
 
@@ -408,13 +313,6 @@ void SymbolTable::typeBecameConcrete(const DerivedType *AbsTy) {
   // plane is a use of the abstract type which must be dropped.
   if (PI != pmap.end())
     AbsTy->removeAbstractTypeUser(this);
-
-  // Loop over all of the types in the symbol table, dropping any abstract
-  // type user entries for AbsTy which occur because there are names for the
-  // type.
-  for (type_iterator TI = type_begin(), TE = type_end(); TI != TE; ++TI)
-    if (TI->second == (Type*)AbsTy)   // FIXME when Types aren't const.
-      AbsTy->removeAbstractTypeUser(this);
 }
 
 static void DumpVal(const std::pair<const std::string, Value *> &V) {
@@ -430,17 +328,9 @@ static void DumpPlane(const std::pair<const Type *,
   for_each(P.second.begin(), P.second.end(), DumpVal);
 }
 
-static void DumpTypes(const std::pair<const std::string, const Type*>& T ) {
-  DOUT << "  '" << T.first << "' = ";
-  T.second->dump();
-  DOUT << "\n";
-}
-
 void SymbolTable::dump() const {
   DOUT << "Symbol table dump:\n  Plane:";
   for_each(pmap.begin(), pmap.end(), DumpPlane);
-  DOUT << "  Types: ";
-  for_each(tmap.begin(), tmap.end(), DumpTypes);
 }
 
 // vim: sw=2 ai