Unswitch a loop, add more assertions, eliminate use of removeUserFromConcrete.

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

1 files changed, 14 insertions, 10 deletions

diff --git a/lib/VMCore/Type.cpp b/lib/VMCore/Type.cpp
index d184c3a84d..c60702754b 100644
--- a/lib/VMCore/Type.cpp
+++ b/lib/VMCore/Type.cpp
@@ -736,7 +736,9 @@ public:
   /// The specified iterator tells us what the type USED to look like.
   void finishRefinement(TypeClass *Ty, const DerivedType *OldType,
                         const Type *NewType) {
-    assert((Ty->isAbstract() || !OldType->isAbstract()) &&
+    // Either NewTy == OldTy (in which case the specified type just became
+    // concrete) or they are different an the Ty is thought to be abstract.
+    assert((Ty->isAbstract() || OldType == NewType) &&
            "Refining a non-abstract type!");
 #ifdef DEBUG_MERGE_TYPES
     std::cerr << "refineAbstractTy(" << (void*)OldType << "[" << *OldType
@@ -755,20 +757,22 @@ public:
     // Remember the structural hash for the type before we start hacking on it,
     // in case we need it later.
     unsigned OldTypeHash = ValType::hashTypeStructure(Ty);
-    unsigned NewTypeHash;
 
     // Find the type element we are refining... and change it now!
-    if (OldType != NewType || !OldType->isAbstract()) {
+    if (!OldType->isAbstract()) {
+      // If the element just became concrete, remove 'ty' from the abstract
+      // type user list for the type.
       for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i)
-        if (Ty->ContainedTys[i] == OldType) {
-          Ty->ContainedTys[i].removeUserFromConcrete();
-          Ty->ContainedTys[i] = NewType;
-        }
-      NewTypeHash = ValType::hashTypeStructure(Ty);
+        if (Ty->ContainedTys[i] == OldType)
+          OldType->removeAbstractTypeUser(Ty);
     } else {
-      NewTypeHash = OldTypeHash;
+      assert(OldType != NewType && "Unknown case!");
+      for (unsigned i = 0, e = Ty->ContainedTys.size(); i != e; ++i)
+        if (Ty->ContainedTys[i] == OldType)
+          Ty->ContainedTys[i] = NewType;
     }
-
+    unsigned NewTypeHash = ValType::hashTypeStructure(Ty);
+    
     // If there are no cycles going through this node, we can do a simple,
     // efficient lookup in the map, instead of an inefficient nasty linear
     // lookup.