From 5855f0db2a89999746606f19d893a18e60139b2f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 23 Oct 2001 01:53:22 +0000 Subject: [PATCH] Allow unresolved/opaque types to be read and written to bytecode files git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@959 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Bytecode/Writer/ConstantWriter.cpp | 5 ++ lib/VMCore/SymbolTable.cpp | 102 +++++++++++++++++-------- 2 files changed, 74 insertions(+), 33 deletions(-) diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp index 4400290328a..8beb1325791 100644 --- a/lib/Bytecode/Writer/ConstantWriter.cpp +++ b/lib/Bytecode/Writer/ConstantWriter.cpp @@ -80,6 +80,11 @@ void BytecodeWriter::outputType(const Type *T) { break; } + case Type::OpaqueTyID: { + // No need to emit anything, just the count of opaque types is enough. + break; + } + //case Type::PackedTyID: default: cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize" diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp index 1275d087917..ecac7c2a3d1 100644 --- a/lib/VMCore/SymbolTable.cpp +++ b/lib/VMCore/SymbolTable.cpp @@ -10,6 +10,9 @@ #include "llvm/DerivedTypes.h" #include "llvm/Method.h" +#define DEBUG_SYMBOL_TABLE 0 +#define DEBUG_ABSTYPE 0 + SymbolTable::~SymbolTable() { // Drop all abstract type references in the type plane... iterator TyPlane = find(Type::TypeTy); @@ -36,25 +39,6 @@ SymbolTable::~SymbolTable() { #endif } -SymbolTable::type_iterator SymbolTable::type_find(const Value *D) { - assert(D->hasName() && "type_find(Value*) only works on named nodes!"); - return type_find(D->getType(), D->getName()); -} - - -// find - returns end(Ty->getIDNumber()) on failure... -SymbolTable::type_iterator SymbolTable::type_find(const Type *Ty, - const string &Name) { - iterator I = find(Ty); - if (I == end()) { // Not in collection yet... insert dummy entry - (*this)[Ty] = VarMap(); - I = find(Ty); - assert(I != end() && "How did insert fail?"); - } - - return I->second.find(Name); -} - // getUniqueName - 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. @@ -88,30 +72,52 @@ Value *SymbolTable::lookup(const Type *Ty, const string &Name) { void SymbolTable::remove(Value *N) { assert(N->hasName() && "Value doesn't have name!"); - assert(type_find(N) != type_end(N->getType()) && - "Value not in symbol table!"); - type_remove(type_find(N)); + + iterator I = find(N->getType()); + removeEntry(I, I->second.find(N->getName())); } +// removeEntry - Remove a value from the symbol table... +// +Value *SymbolTable::removeEntry(iterator Plane, type_iterator Entry) { + assert(Plane != super::end() && + Entry != Plane->second.end() && "Invalid entry to remove!"); -#define DEBUG_SYMBOL_TABLE 0 - -Value *SymbolTable::type_remove(const type_iterator &It) { - Value *Result = It->second; + Value *Result = Entry->second; const Type *Ty = Result->getType(); #if DEBUG_SYMBOL_TABLE cerr << this << " Removing Value: " << Result->getName() << endl; #endif // Remove the value from the plane... - find(Ty)->second.erase(It); + Plane->second.erase(Entry); + + // If the plane is empty, remove it now! + if (Plane->second.empty()) { + // If the plane represented an abstract type that we were interested in, + // unlink ourselves from this plane. + // + if (Plane->first->isAbstract()) { +#if DEBUG_ABSTYPE + cerr << "Plane Empty: Removing type: " << Plane->first->getDescription() + << endl; +#endif + cast(Plane->first)->removeAbstractTypeUser(this); + } + + erase(Plane); + } // If we are removing an abstract type, remove the symbol table from it's use // list... if (Ty == Type::TypeTy) { const Type *T = cast(Result); - if (T->isAbstract()) + if (T->isAbstract()) { +#if DEBUG_ABSTYPE + cerr << "Removing abs type from symtab" << T->getDescription() << endl; +#endif cast(T)->removeAbstractTypeUser(this); + } } return Result; @@ -140,8 +146,12 @@ void SymbolTable::insertEntry(const string &Name, const Type *VTy, Value *V) { // future, which would cause the plane of the old type to get merged into // a new type plane. // - if (VTy->isAbstract()) + if (VTy->isAbstract()) { cast(VTy)->addAbstractTypeUser(this); +#if DEBUG_ABSTYPE + cerr << "Added abstract type value: " << VTy->getDescription() << endl; +#endif + } } I->second.insert(make_pair(Name, V)); @@ -149,8 +159,12 @@ void SymbolTable::insertEntry(const string &Name, const Type *VTy, Value *V) { // If we are adding an abstract type, add the symbol table to it's use list. if (VTy == Type::TypeTy) { const Type *T = cast(V); - if (T->isAbstract()) + if (T->isAbstract()) { cast(T)->addAbstractTypeUser(this); +#if DEBUG_ABSTYPE + cerr << "Added abstract type to ST: " << T->getDescription() << endl; +#endif + } } } @@ -161,9 +175,17 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, // Get a handle to the new type plane... iterator NewTypeIt = find(NewType); - if (NewTypeIt == super::end()) // If no plane exists, add one + if (NewTypeIt == super::end()) { // If no plane exists, add one NewTypeIt = super::insert(make_pair(NewType, VarMap())).first; + if (NewType->isAbstract()) { + cast(NewType)->addAbstractTypeUser(this); +#if DEBUG_ABSTYPE + cerr << "refined to abstype: " << NewType->getDescription() <second; // Search to see if we have any values of the type oldtype. If so, we need to @@ -225,7 +247,13 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, // Ok, now we are not referencing the type anymore... take me off your user // list please! +#if DEBUG_ABSTYPE + cerr << "Removing type " << OldType->getDescription() << endl; +#endif OldType->removeAbstractTypeUser(this); + + // Remove the plane that is no longer used + erase(TPI); } TPI = find(Type::TypeTy); @@ -239,10 +267,18 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, VarMap &TyPlane = TPI->second; for (VarMap::iterator I = TyPlane.begin(), E = TyPlane.end(); I != E; ++I) if (I->second == (Value*)OldType) { // FIXME when Types aren't const. +#if DEBUG_ABSTYPE + cerr << "Removing type " << OldType->getDescription() << endl; +#endif OldType->removeAbstractTypeUser(this); + I->second = (Value*)NewType; // TODO FIXME when types aren't const - if (NewType->isAbstract()) + if (NewType->isAbstract()) { +#if DEBUG_ABSTYPE + cerr << "Added type " << NewType->getDescription() << endl; +#endif cast(NewType)->addAbstractTypeUser(this); + } } } @@ -252,7 +288,7 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType, #include static void DumpVal(const pair &V) { - cout << " '%" << V.first << "' = " << V.second << endl; + cout << " '" << V.first << "' = " << V.second << endl; } static void DumpPlane(const pair >&P) {