lib/VMCore/SymbolTable.cpp

   1 //===-- SymbolTable.cpp - Implement the SymbolTable class -------------------=//
   2 //
   3 // This file implements the SymbolTable class for the VMCore library.
   4 //
   5 //===----------------------------------------------------------------------===//
   6
   7 #include "llvm/SymbolTable.h"
   8 #include "llvm/InstrTypes.h"
   9 #ifndef NDEBUG
  10 #include "llvm/BasicBlock.h"   // Required for assertions to work.
  11 #include "llvm/Type.h"
  12 #endif
  13
  14 SymbolTable::~SymbolTable() {
  15 #ifndef NDEBUG   // Only do this in -g mode...
  16   bool Good = true;
  17   for (iterator i = begin(); i != end(); i++) {
  18     if (i->second.begin() != i->second.end()) {
  19       for (type_iterator I = i->second.begin(); I != i->second.end(); I++)
  20         cerr << "Value still in symbol table! Type = " << i->first->getName()
  21              << "  Name = " << I->first << endl;
  22       Good = false;
  23     }
  24   }
  25   assert(Good && "Values remain in symbol table!");
  26 #endif
  27 }
  28
  29 SymbolTable::type_iterator SymbolTable::type_find(const Value *D) {
  30   assert(D->hasName() && "type_find(Value*) only works on named nodes!");
  31   return type_find(D->getType(), D->getName());
  32 }
  33
  34
  35 // find - returns end(Ty->getIDNumber()) on failure...
  36 SymbolTable::type_iterator SymbolTable::type_find(const Type *Ty,
  37                                                   const string &Name) {
  38   iterator I = find(Ty);
  39   if (I == end()) {      // Not in collection yet... insert dummy entry
  40     (*this)[Ty] = VarMap();
  41     I = find(Ty);
  42     assert(I != end() && "How did insert fail?");
  43   }
  44
  45   return I->second.find(Name);
  46 }
  47
  48
  49 // lookup - Returns null on failure...
  50 Value *SymbolTable::lookup(const Type *Ty, const string &Name) {
  51   iterator I = find(Ty);
  52   if (I != end()) {                      // We have symbols in that plane...
  53     type_iterator J = I->second.find(Name);
  54     if (J != I->second.end())            // and the name is in our hash table...
  55       return J->second;
  56   }
  57
  58   return ParentSymTab ? ParentSymTab->lookup(Ty, Name) : 0;
  59 }
  60
  61 void SymbolTable::remove(Value *N) {
  62   assert(N->hasName() && "Value doesn't have name!");
  63   assert(type_find(N) != type_end(N->getType()) &&
  64          "Value not in symbol table!");
  65   type_remove(type_find(N));
  66 }
  67
  68
  69 #define DEBUG_SYMBOL_TABLE 0
  70
  71 Value *SymbolTable::type_remove(const type_iterator &It) {
  72   Value *Result = It->second;
  73 #if DEBUG_SYMBOL_TABLE
  74   cerr << this << " Removing Value: " << Result->getName() << endl;
  75 #endif
  76
  77   find(Result->getType())->second.erase(It);
  78
  79   return Result;
  80 }
  81
  82 void SymbolTable::insert(Value *N) {
  83   assert(N->hasName() && "Value must be named to go into symbol table!");
  84
  85   // TODO: The typeverifier should catch this when its implemented
  86   if (lookup(N->getType(), N->getName())) {
  87     cerr << "SymbolTable WARNING: Name already in symbol table: '"
  88          << N->getName() << "'\n";
  89     abort();  // TODO: REMOVE THIS
  90   }
  91
  92 #if DEBUG_SYMBOL_TABLE
  93   cerr << this << " Inserting definition: " << N->getName() << ": "
  94        << N->getType()->getName() << endl;
  95 #endif
  96
  97   iterator I = find(N->getType());
  98   if (I == end()) {      // Not in collection yet... insert dummy entry
  99     (*this)[N->getType()] = VarMap();
 100     I = find(N->getType());
 101     assert(I != end() && "How did insert fail?");
 102   }
 103
 104   I->second.insert(make_pair(N->getName(), N));
 105 }
 106