Fix a non-deterministic load forwarding in RLE

Author: trentxintong

lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -1487,13 +1487,26 @@ bool RLEContext::run() {
   // Finally, perform the redundant load replacements.
   llvm::DenseSet<SILInstruction *> InstsToDelete;
   bool SILChanged = false;
-  for (auto &X : BBToLocState) {
-    for (auto &F : X.second.getRL()) {
-      DEBUG(llvm::dbgs() << "Replacing  " << SILValue(F.first) << "With "
-                         << F.second);
+  for (auto &B : *Fn) {
+    auto &State = BBToLocState[&B];
+    auto &Loads = State.getRL();
+    // Nothing to forward.
+    if (Loads.empty())
+      continue;
+    // We iterate the instructions in the basic block in a deterministic order
+    // and use this order to perform the load forwarding. 
+    //
+    // NOTE: we could end up with different SIL depending on the ordering load
+    // forwarding is performed.
+    for (auto I = B.rbegin(), E = B.rend(); I != E; ++I) {
+      auto Iter = Loads.find(&*I);
+      if (Iter == Loads.end())
+        continue;
+      DEBUG(llvm::dbgs() << "Replacing  " << SILValue(Iter->first) << "With "
+            << Iter->second);
       SILChanged = true;
-      F.first->replaceAllUsesWith(F.second);
-      InstsToDelete.insert(F.first);
+      Iter->first->replaceAllUsesWith(Iter->second);
+      InstsToDelete.insert(Iter->first);
       ++NumForwardedLoads;
     }
   }

test/SILOptimizer/redundant_load_elim.sil

@@ -1128,3 +1128,21 @@ bb0(%0 : $AB):
   %4 = tuple ()
   return %4 : $()
 }
+
+// Make sure we have a deterministic forward ordering and also both loads are forwarded.
+//
+// CHECK-LABEL: sil @load_store_deterministic_forwarding
+// CHECK: bb0
+// CHECK-NEXT: [[VAL:%.*]] = integer_literal $Builtin.Int64, 0
+// CHECK-NEXT: store 
+// CHECK-NEXT: store 
+// CHECK-NEXT: return [[VAL]] : $Builtin.Int64
+sil @load_store_deterministic_forwarding : $@convention(thin) (@inout Builtin.Int64, @inout Builtin.Int64) -> (Builtin.Int64) {
+bb0(%0 : $*Builtin.Int64, %1 : $*Builtin.Int64):
+  %2 = integer_literal $Builtin.Int64, 0
+  store %2 to %0 : $*Builtin.Int64
+  %3 = load %0 : $*Builtin.Int64
+  store %3 to %1: $*Builtin.Int64
+  %4 = load %1 : $*Builtin.Int64
+  return %4 : $Builtin.Int64
+}