* Add new method localLookup

* SymbolTable::remove(Value *N) checks to see if we are internally
  inconsistent before looking for a type plane (caused a crash)
* insertEntry now does a local lookup instead of a global lookup, which was
  causing an infinite loop in the renamer logic.
* Added assertions to make sure stuff stays happy
* Now the linker correctly links the SPECINT2000 mcf benchmark

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1840 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/SymbolTable.h b/include/llvm/SymbolTable.h
index 49e028b4023813ab1056406d587d5ce4ff51f13a..50b933ed5aac4da2d05ba69b55ea37cb007f207d 100644 (file)
--- a/include/llvm/SymbolTable.h
+++ b/include/llvm/SymbolTable.h
@@ -54,6 +54,11 @@ public:
   // lookup - Returns null on failure...
   Value *lookup(const Type *Ty, const std::string &name);
 
+  // localLookup - Look in this symbol table without falling back on parent,
+  // if non-existing.  Returns null on failure...
+  //
+  Value *localLookup(const Type *Ty, const std::string &name);
+
   // insert - Add named definition to the symbol table...
   inline void insert(Value *N) {
     assert(N->hasName() && "Value must be named to go into symbol table!");

diff --git a/lib/VMCore/SymbolTable.cpp b/lib/VMCore/SymbolTable.cpp
index ab15eb6eec6826b097090fa71cd86b5930837a2a..80f8e100e839d5e84cbfaef729830bf15faba849 100644 (file)
--- a/lib/VMCore/SymbolTable.cpp
+++ b/lib/VMCore/SymbolTable.cpp
@@ -73,7 +73,7 @@ string SymbolTable::getUniqueName(const Type *Ty, const string &BaseName) {
 
 
 // lookup - Returns null on failure...
-Value *SymbolTable::lookup(const Type *Ty, const string &Name) {
+Value *SymbolTable::localLookup(const Type *Ty, const string &Name) {
   iterator I = find(Ty);
   if (I != end()) {                      // We have symbols in that plane...
     type_iterator J = I->second.find(Name);
@@ -81,13 +81,23 @@ Value *SymbolTable::lookup(const Type *Ty, const string &Name) {
       return J->second;
   }
 
+  return 0;
+}
+
+// lookup - Returns null on failure...
+Value *SymbolTable::lookup(const Type *Ty, const string &Name) {
+  Value *LV = localLookup(Ty, Name);
+  if (LV) return LV;
   return ParentSymTab ? ParentSymTab->lookup(Ty, Name) : 0;
 }
 
 void SymbolTable::remove(Value *N) {
   assert(N->hasName() && "Value doesn't have name!");
+  if (InternallyInconsistent) return;
 
   iterator I = find(N->getType());
+  assert(I != end() &&
+         "Trying to remove a type that doesn't have a plane yet!");
   removeEntry(I, I->second.find(N->getName()));
 }
 
@@ -142,9 +152,11 @@ Value *SymbolTable::removeEntry(iterator Plane, type_iterator Entry) {
 // name...
 //
 void SymbolTable::insertEntry(const string &Name, const Type *VTy, Value *V) {
+
   // Check to see if there is a naming conflict.  If so, rename this value!
-  if (lookup(VTy, Name)) {
+  if (localLookup(VTy, Name)) {
     string UniqueName = getUniqueName(VTy, Name);
+    assert(InternallyInconsistent == false && "Infinite loop inserting entry!");
     InternallyInconsistent = true;
     V->setName(UniqueName, this);
     InternallyInconsistent = false;
@@ -243,6 +255,8 @@ void SymbolTable::refineAbstractType(const DerivedType *OldType,
           // that turns remove into a noop.  Thus the name will get null'd
           // out, but the symbol table won't get upset.
           //
+          assert(InternallyInconsistent == false &&
+                 "Symbol table already inconsistent!");
           InternallyInconsistent = true;
 
           // Remove newM from the symtab