6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-30 17:33:24 +00:00
Code Issues Projects Releases Wiki Activity

Allow unresolved/opaque types to be read and written to bytecode files

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@959 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2001-10-23 01:53:22 +00:00
parent d48d6c74ad
commit 5855f0db2a
2 changed files with 74 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Bytecode/Writer/ConstantWriter.cpp
View File

@ -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"

102
lib/VMCore/SymbolTable.cpp
View File

@ -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,31 +72,53 @@ 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<DerivedType>(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<const Type>(Result);
if (T->isAbstract())
if (T->isAbstract()) {
#if DEBUG_ABSTYPE
cerr << "Removing abs type from symtab" << T->getDescription() << endl;
#endif
cast<DerivedType>(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<DerivedType>(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<const Type>(V);
if (T->isAbstract())
if (T->isAbstract()) {
cast<DerivedType>(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<DerivedType>(NewType)->addAbstractTypeUser(this);
#if DEBUG_ABSTYPE
cerr << "refined to abstype: " << NewType->getDescription() <<endl;
#endif
}
}
VarMap &NewPlane = NewTypeIt->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,11 +267,19 @@ 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<const DerivedType>(NewType)->addAbstractTypeUser(this);
}
}
}
@ -252,7 +288,7 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType,
#include <algorithm>
static void DumpVal(const pair<const string, Value *> &V) {
cout << " '%" << V.first << "' = " << V.second << endl;
cout << " '" << V.first << "' = " << V.second << endl;
}
static void DumpPlane(const pair<const Type *, map<const string, Value *> >&P) {