[llvm] r244302 - ValueMapper: Resolve uniquing cycles more aggressively

[Duncan P. N. Exon Smith via llvm-commits]

Author: dexonsmith
Date: Thu Aug  6 19:44:55 2015
New Revision: 244302

URL: http://llvm.org/viewvc/llvm-project?rev=244302&view=rev
Log:
ValueMapper: Resolve uniquing cycles more aggressively

As a follow-up to r244181, resolve uniquing cycles underneath distinct
nodes on the fly.  This prevents uniquing cycles in early operands from
affecting later operands.  It also removes an iteration through distinct
nodes' operands.

No real functional change here, just more prompt resolution of temporary
nodes.

Modified:
    llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp

Modified: llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp?rev=244302&r1=244301&r2=244302&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp (original)
+++ llvm/trunk/lib/Transforms/Utils/ValueMapper.cpp Thu Aug  6 19:44:55 2015
@@ -191,12 +191,18 @@ static void resolveCycles(Metadata *MD)
 }
 
 /// Remap the operands of an MDNode.
+///
+/// If \c Node is temporary, uniquing cycles are ignored.  If \c Node is
+/// distinct, uniquing cycles are resolved as they're found.
+///
+/// \pre \c Node.isDistinct() or \c Node.isTemporary().
 static bool remapOperands(MDNode &Node,
                           SmallVectorImpl<MDNode *> &DistinctWorklist,
                           ValueToValueMapTy &VM, RemapFlags Flags,
                           ValueMapTypeRemapper *TypeMapper,
                           ValueMaterializer *Materializer) {
   assert(!Node.isUniqued() && "Expected temporary or distinct node");
+  const bool IsDistinct = Node.isDistinct();
 
   bool AnyChanged = false;
   for (unsigned I = 0, E = Node.getNumOperands(); I != E; ++I) {
@@ -206,6 +212,11 @@ static bool remapOperands(MDNode &Node,
     if (Old != New) {
       AnyChanged = true;
       Node.replaceOperandWith(I, New);
+
+      // Resolve uniquing cycles underneath distinct nodes on the fly so they
+      // don't infect later operands.
+      if (IsDistinct)
+        resolveCycles(New);
     }
   }
 
@@ -332,15 +343,9 @@ Metadata *llvm::MapMetadata(const Metada
   resolveCycles(NewMD);
 
   // Remap the operands of distinct MDNodes.
-  while (!DistinctWorklist.empty()) {
-    auto *N = DistinctWorklist.pop_back_val();
-
-    // If an operand changes, then it may be involved in a uniquing cycle.
-    if (remapOperands(*N, DistinctWorklist, VM, Flags, TypeMapper,
-                      Materializer))
-      for (Metadata *MD : N->operands())
-        resolveCycles(MD);
-  }
+  while (!DistinctWorklist.empty())
+    remapOperands(*DistinctWorklist.pop_back_val(), DistinctWorklist, VM, Flags,
+                  TypeMapper, Materializer);
 
   return NewMD;
 }