Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 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" |
Chris Lattner | e2472bb | 2001-07-23 17:46:59 +0000 | [diff] [blame^] | 9 | #include "llvm/Support/StringExtras.h" |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 10 | #ifndef NDEBUG |
| 11 | #include "llvm/BasicBlock.h" // Required for assertions to work. |
| 12 | #include "llvm/Type.h" |
| 13 | #endif |
| 14 | |
| 15 | SymbolTable::~SymbolTable() { |
| 16 | #ifndef NDEBUG // Only do this in -g mode... |
| 17 | bool Good = true; |
Chris Lattner | 4cee8d8 | 2001-06-27 23:41:11 +0000 | [diff] [blame] | 18 | for (iterator i = begin(); i != end(); ++i) { |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 19 | if (i->second.begin() != i->second.end()) { |
Chris Lattner | 4cee8d8 | 2001-06-27 23:41:11 +0000 | [diff] [blame] | 20 | for (type_iterator I = i->second.begin(); I != i->second.end(); ++I) |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 21 | cerr << "Value still in symbol table! Type = " << i->first->getName() |
| 22 | << " Name = " << I->first << endl; |
| 23 | Good = false; |
| 24 | } |
| 25 | } |
| 26 | assert(Good && "Values remain in symbol table!"); |
| 27 | #endif |
| 28 | } |
| 29 | |
| 30 | SymbolTable::type_iterator SymbolTable::type_find(const Value *D) { |
| 31 | assert(D->hasName() && "type_find(Value*) only works on named nodes!"); |
| 32 | return type_find(D->getType(), D->getName()); |
| 33 | } |
| 34 | |
| 35 | |
| 36 | // find - returns end(Ty->getIDNumber()) on failure... |
| 37 | SymbolTable::type_iterator SymbolTable::type_find(const Type *Ty, |
| 38 | const string &Name) { |
| 39 | iterator I = find(Ty); |
| 40 | if (I == end()) { // Not in collection yet... insert dummy entry |
| 41 | (*this)[Ty] = VarMap(); |
| 42 | I = find(Ty); |
| 43 | assert(I != end() && "How did insert fail?"); |
| 44 | } |
| 45 | |
| 46 | return I->second.find(Name); |
| 47 | } |
| 48 | |
Chris Lattner | 01683cc | 2001-06-25 07:33:13 +0000 | [diff] [blame] | 49 | // getUniqueName - Given a base name, return a string that is either equal to |
| 50 | // it (or derived from it) that does not already occur in the symbol table for |
| 51 | // the specified type. |
| 52 | // |
| 53 | string SymbolTable::getUniqueName(const Type *Ty, const string &BaseName) { |
| 54 | iterator I = find(Ty); |
| 55 | if (I == end()) return BaseName; |
| 56 | |
| 57 | string TryName = BaseName; |
| 58 | unsigned Counter = 0; |
| 59 | type_iterator End = I->second.end(); |
| 60 | |
| 61 | while (I->second.find(TryName) != End) // Loop until we find unoccupied |
| 62 | TryName = BaseName + utostr(++Counter); // Name in the symbol table |
| 63 | return TryName; |
| 64 | } |
| 65 | |
| 66 | |
Chris Lattner | 2f7c963 | 2001-06-06 20:29:01 +0000 | [diff] [blame] | 67 | |
| 68 | // lookup - Returns null on failure... |
| 69 | Value *SymbolTable::lookup(const Type *Ty, const string &Name) { |
| 70 | iterator I = find(Ty); |
| 71 | if (I != end()) { // We have symbols in that plane... |
| 72 | type_iterator J = I->second.find(Name); |
| 73 | if (J != I->second.end()) // and the name is in our hash table... |
| 74 | return J->second; |
| 75 | } |
| 76 | |
| 77 | return ParentSymTab ? ParentSymTab->lookup(Ty, Name) : 0; |
| 78 | } |
| 79 | |
| 80 | void SymbolTable::remove(Value *N) { |
| 81 | assert(N->hasName() && "Value doesn't have name!"); |
| 82 | assert(type_find(N) != type_end(N->getType()) && |
| 83 | "Value not in symbol table!"); |
| 84 | type_remove(type_find(N)); |
| 85 | } |
| 86 | |
| 87 | |
| 88 | #define DEBUG_SYMBOL_TABLE 0 |
| 89 | |
| 90 | Value *SymbolTable::type_remove(const type_iterator &It) { |
| 91 | Value *Result = It->second; |
| 92 | #if DEBUG_SYMBOL_TABLE |
| 93 | cerr << this << " Removing Value: " << Result->getName() << endl; |
| 94 | #endif |
| 95 | |
| 96 | find(Result->getType())->second.erase(It); |
| 97 | |
| 98 | return Result; |
| 99 | } |
| 100 | |
| 101 | void SymbolTable::insert(Value *N) { |
| 102 | assert(N->hasName() && "Value must be named to go into symbol table!"); |
| 103 | |
| 104 | // TODO: The typeverifier should catch this when its implemented |
| 105 | if (lookup(N->getType(), N->getName())) { |
| 106 | cerr << "SymbolTable WARNING: Name already in symbol table: '" |
| 107 | << N->getName() << "'\n"; |
| 108 | abort(); // TODO: REMOVE THIS |
| 109 | } |
| 110 | |
| 111 | #if DEBUG_SYMBOL_TABLE |
| 112 | cerr << this << " Inserting definition: " << N->getName() << ": " |
| 113 | << N->getType()->getName() << endl; |
| 114 | #endif |
| 115 | |
| 116 | iterator I = find(N->getType()); |
| 117 | if (I == end()) { // Not in collection yet... insert dummy entry |
| 118 | (*this)[N->getType()] = VarMap(); |
| 119 | I = find(N->getType()); |
| 120 | assert(I != end() && "How did insert fail?"); |
| 121 | } |
| 122 | |
| 123 | I->second.insert(make_pair(N->getName(), N)); |
| 124 | } |
| 125 | |