r600/sfn: Don't try to re-use the iterator when uses is updated

It seems on libc++ the iterator is invalidated when an element is removed
from the set, so restart iteration.

Fixes: f3415c (r600/sfn: copy propagate register load chains)

Closes: mesa/mesa#7931



Signed-off-by: Gert Wollny <gert.wollny@collabora.com>

src/gallium/drivers/r600/sfn/sfn_optimizer.cpp

@@ -360,41 +360,55 @@ CopyPropFwdVisitor::visit(AluInstr *instr)
    auto src = instr->psrc(0);
    auto dest = instr->dest();
 
-   for (auto& i : dest->uses()) {
-      /* SSA can always be propagated, registers only in the same block
+   bool local_progress = false;
+   do {
+      local_progress = false;
+      for (auto& i : dest->uses()) {
+         /* SSA can always be propagated, registers only in the same block
        * and only if they are assigned in the same block */
-      bool can_propagate = dest->has_flag(Register::ssa);
-
-      if (!can_propagate) {
-
-         /* Register can propagate if the assigment was in the same
-          * block, and we don't have a second assignment coming later
-          * (e.g. helper invocation evaluation does
-          *
-          * 1: MOV R0.x, -1
-          * 2: FETCH R0.0 VPM
-          * 3: MOV SN.x, R0.x
-          *
-          * Here we can't prpagate the move in 1 to SN.x in 3 */
-         if ((instr->block_id() == i->block_id() && instr->index() < i->index())) {
-            can_propagate = true;
-            if (dest->parents().size() > 1) {
-               for (auto p : dest->parents()) {
-                  if (p->block_id() == i->block_id() && p->index() > instr->index()) {
-                     can_propagate = false;
-                     break;
+         bool can_propagate = dest->has_flag(Register::ssa);
+
+         if (!can_propagate) {
+
+            /* Register can propagate if the assigment was in the same
+             * block, and we don't have a second assignment coming later
+             * (e.g. helper invocation evaluation does
+             *
+             * 1: MOV R0.x, -1
+             * 2: FETCH R0.0 VPM
+             * 3: MOV SN.x, R0.x
+             *
+             * Here we can't prpagate the move in 1 to SN.x in 3 */
+            if ((instr->block_id() == i->block_id() && instr->index() < i->index())) {
+               can_propagate = true;
+               if (dest->parents().size() > 1) {
+                  for (auto p : dest->parents()) {
+                     if (p->block_id() == i->block_id() && p->index() > instr->index()) {
+                        can_propagate = false;
+                        break;
+                     }
                   }
                }
             }
          }
-      }
 
-      if (can_propagate) {
-         sfn_log << SfnLog::opt << "   Try replace in " << i->block_id() << ":"
-                 << i->index() << *i << "\n";
-         progress |= i->replace_source(dest, src);
+         if (can_propagate) {
+            sfn_log << SfnLog::opt << "   Try replace in " << i->block_id() << ":"
+                    << i->index() << *i << "\n";
+
+            /* A successful copy propagation may break the interator i, because
+             * the uses set changes  (it does so with libc++), therefore restart
+             * the iteration after each successful propagation.
+             * TODO: rewite this to not restart iterating uses each time */
+            if (i->replace_source(dest, src)) {
+               local_progress = true;
+               break;
+            }
+         }
       }
-   }
+   } while (local_progress);
+   progress |= local_progress;
+
    if (instr->dest()) {
       sfn_log << SfnLog::opt << "has uses; " << instr->dest()->uses().size();
    }