RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-04 17:56:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

More symbol table bugfixes that are impossible to track down. Goody

Browse Source 
llvm-svn: 960
This commit is contained in:
Chris Lattner 2001-10-23 02:32:45 +00:00
parent 0553612e11
commit db06de9f17
2 changed files with 38 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
include/llvm/SymbolTable.h
View File

@ -24,13 +24,8 @@
#include "llvm/ConstPoolVals.h"
#endif
class Value;
class Type;
// TODO: Change this back to vector<map<const string, Value *> >
// Make the vector be a data member, and base it on UniqueID's
// That should be much more efficient!
//
class SymbolTable : public AbstractTypeUser,
public map<const Type *, map<const string, Value *> > {
public:
@ -47,7 +42,10 @@ public:
typedef VarMap::iterator type_iterator;
typedef VarMap::const_iterator type_const_iterator;
inline SymbolTable(SymbolTable *P = 0) { ParentSymTab = P; }
inline SymbolTable(SymbolTable *P = 0) {
ParentSymTab = P;
InternallyInconsistent = false;
}
~SymbolTable();
SymbolTable *getParentSymTab() { return ParentSymTab; }
@ -106,6 +104,15 @@ public:
void dump() const; // Debug method, print out symbol table
private:
// InternallyInconsistent - There are times when the symbol table is
// internally inconsistent with the rest of the program. In this one case, a
// value exists with a Name, and it's not in the symbol table. When we call
// V->setName(""), it tries to remove itself from the symbol table and dies.
// We know this is happening, and so if the flag InternallyInconsistent is
// set, removal from the symbol table is a noop.
//
bool InternallyInconsistent;
inline super::value_type operator[](const Type *Ty) {
assert(0 && "Should not use this operator to access symbol table!");
return super::value_type();

54
lib/VMCore/SymbolTable.cpp
View File

@ -80,6 +80,7 @@ void SymbolTable::remove(Value *N) {
// removeEntry - Remove a value from the symbol table...
//
Value *SymbolTable::removeEntry(iterator Plane, type_iterator Entry) {
if (InternallyInconsistent) return 0;
assert(Plane != super::end() &&
Entry != Plane->second.end() && "Invalid entry to remove!");
@ -206,37 +207,32 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType,
// The only thing we are allowing for now is two method prototypes being
// folded into one.
//
if (Method *ExistM = dyn_cast<Method>(TI->second))
if (Method *NewM = dyn_cast<Method>(V.second))
if (ExistM->isExternal() && NewM->isExternal()) {
// Ok we have two external methods. Make all uses of the new one
// use the old one...
//
NewM->replaceAllUsesWith(ExistM);
Method *ExistM = dyn_cast<Method>(TI->second);
Method *NewM = dyn_cast<Method>(V.second);
// Now we just convert it to an unnamed method... which won't get
// added to our symbol table. The problem is that if we call
// setName on the method that it will try to remove itself from
// the symbol table and die... because it's not in the symtab
// right now. To fix this, we temporarily insert it (by setting
// TI's entry to the old value. Then after it is removed, we
// restore ExistM into the symbol table.
//
if (NewM->getType() == NewType) {
TI->second = NewM; // Add newM to the symtab
if (ExistM && NewM && ExistM->isExternal() && NewM->isExternal()) {
// Ok we have two external methods. Make all uses of the new one
// use the old one...
//
NewM->replaceAllUsesWith(ExistM);
// Now we just convert it to an unnamed method... which won't get
// added to our symbol table. The problem is that if we call
// setName on the method that it will try to remove itself from
// the symbol table and die... because it's not in the symtab
// right now. To fix this, we have an internally consistent flag
// that turns remove into a noop. Thus the name will get null'd
// out, but the symbol table won't get upset.
//
InternallyInconsistent = true;
// Remove newM from the symtab
NewM->setName("");
// Readd ExistM to the symbol table....
NewPlane.insert(make_pair(V.first, ExistM));
} else {
NewM->setName("");
}
continue;
}
assert(0 && "Two ploanes folded together with overlapping "
"value names!");
// Remove newM from the symtab
NewM->setName("");
InternallyInconsistent = false;
} else {
assert(0 && "Two ploanes folded together with overlapping "
"value names!");
}
} else {
insertEntry(V.first, NewType, V.second);