Refactor code to make it useful outside of Constants.cpp

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

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 7a6834839698c4a40237136d991ccee612ecf63d..7051814a7c0362470f222f54bfc08b9823c56602 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -466,26 +466,6 @@ void ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV) {
 //===----------------------------------------------------------------------===//
 //                      Factory Function Implementation
 
-// ReplaceUsesOfWith - This is exactly the same as Value::replaceAllUsesWith,
-// except that it doesn't have all of the asserts.  The asserts fail because we
-// are half-way done resolving types, which causes some types to exist as two
-// different Type*'s at the same time.  This is a sledgehammer to work around
-// this problem.
-//
-static void ReplaceUsesOfWith(Value *Old, Value *New) {
-  while (!Old->use_empty()) {
-    User *Use = Old->use_back();
-    // Must handle Constants specially, we cannot call replaceUsesOfWith on a
-    // constant!
-    if (Constant *C = dyn_cast<Constant>(Use)) {
-      C->replaceUsesOfWithOnConstant(Old, New);
-    } else {
-      Use->replaceUsesOfWith(Old, New);
-    }
-  }
-}
-
-
 // ConstantCreator - A class that is used to create constants by
 // ValueMap*.  This class should be partially specialized if there is
 // something strange that needs to be done to interface to the ctor for the
@@ -596,7 +576,7 @@ void ConstantArray::refineAbstractType(const DerivedType *OldTy,
     C.push_back(cast<Constant>(getOperand(i)));
   Constant *New = ConstantArray::get(cast<ArrayType>(NewTy), C);
   if (New != this) {
-    ReplaceUsesOfWith(this, New);
+    uncheckedReplaceAllUsesWith(New);
     destroyConstant();    // This constant is now dead, destroy it.
   }
 }
@@ -665,7 +645,7 @@ void ConstantStruct::refineAbstractType(const DerivedType *OldTy,
     C.push_back(cast<Constant>(getOperand(i)));
   Constant *New = ConstantStruct::get(cast<StructType>(NewTy), C);
   if (New != this) {
-    ReplaceUsesOfWith(this, New);
+    uncheckedReplaceAllUsesWith(New);
     destroyConstant();    // This constant is now dead, destroy it.
   }
 }
@@ -706,7 +686,7 @@ void ConstantPointerNull::refineAbstractType(const DerivedType *OldTy,
   // Make everyone now use a constant of the new type...
   Constant *New = ConstantPointerNull::get(cast<PointerType>(NewTy));
   if (New != this) {
-    ReplaceUsesOfWith(this, New);
+    uncheckedReplaceAllUsesWith(New);
     
     // This constant is now dead, destroy it.
     destroyConstant();
@@ -859,7 +839,7 @@ void ConstantExpr::refineAbstractType(const DerivedType *OldTy,
     New = ConstantExpr::getGetElementPtr(getOperand(0), C);
   }
   if (New != this) {
-    ReplaceUsesOfWith(this, New);
+    uncheckedReplaceAllUsesWith(New);
     destroyConstant();    // This constant is now dead, destroy it.
   }
 }

diff --git a/lib/VMCore/Value.cpp b/lib/VMCore/Value.cpp
index 6cb0b09f5202972f01b8e00d6a542505e0e596fe..c3bd28b514b79a19055e3c04202c5cadcc2b4ee2 100644 (file)
--- a/lib/VMCore/Value.cpp
+++ b/lib/VMCore/Value.cpp
@@ -66,6 +66,26 @@ void Value::replaceAllUsesWith(Value *New) {
   }
 }
 
+// uncheckedReplaceAllUsesWith - This is exactly the same as replaceAllUsesWith,
+// except that it doesn't have all of the asserts.  The asserts fail because we
+// are half-way done resolving types, which causes some types to exist as two
+// different Type*'s at the same time.  This is a sledgehammer to work around
+// this problem.
+//
+void Value::uncheckedReplaceAllUsesWith(Value *New) {
+  while (!Uses.empty()) {
+    User *Use = Uses.back();
+    // Must handle Constants specially, we cannot call replaceUsesOfWith on a
+    // constant!
+    if (Constant *C = dyn_cast<Constant>(Use)) {
+      C->replaceUsesOfWithOnConstant(this, New);
+    } else {
+      Use->replaceUsesOfWith(this, New);
+    }
+  }
+}
+
+
 // refineAbstractType - This function is implemented because we use
 // potentially abstract types, and these types may be resolved to more
 // concrete types after we are constructed.  For the value class, we simply