RedundantLoadElimination: insert mark_dependence instructions for a removed load

If the memory location depends on something, insert a dependency for the loaded value:
```
  %2 = mark_dependence %1 on %0
  %3 = load %2
```
->
```
  %2 = mark_dependence %1 on %0 // not needed anymore, can be removed eventually
  %3 = load %2
  %4 = mark_dependence %3 on %0
  // replace %3 with %4
```

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -279,6 +279,10 @@ private func replace(load: LoadInst, with availableValues: [AvailableValue], _ c
     //
     newValue = ssaUpdater.getValue(inMiddleOf: load.parentBlock)
   }
+
+  // Make sure to keep dependencies valid after replacing the load
+  insertMarkDependencies(for: load, context)
+
   load.replace(with: newValue, context)
 }
 
@@ -306,6 +310,39 @@ private func provideValue(
   }
 }
 
+/// If the memory location depends on something, insert a dependency for the loaded value:
+///
+///     %2 = mark_dependence %1 on %0
+///     %3 = load %2
+/// ->
+///     %2 = mark_dependence %1 on %0 // not needed anymore, can be removed eventually
+///     %3 = load %2
+///     %4 = mark_dependence %3 on %0
+///     // replace %3 with %4
+///
+private func insertMarkDependencies(for load: LoadInst, _ context: FunctionPassContext) {
+  var inserter = MarkDependenceInserter(load: load, context: context)
+  _ = inserter.walkUp(address: load.address, path: UnusedWalkingPath())
+}
+
+private struct MarkDependenceInserter : AddressUseDefWalker {
+  let load: LoadInst
+  let context: FunctionPassContext
+  
+  mutating func walkUp(address: Value, path: UnusedWalkingPath) -> WalkResult {
+    if let mdi = address as? MarkDependenceInst {
+      let builder = Builder(after: load, context)
+      let newMdi = builder.createMarkDependence(value: load, base: mdi.base, kind: mdi.dependenceKind)
+      load.uses.ignore(user: newMdi).replaceAll(with: newMdi, context)
+    }
+    return walkUpDefault(address: address, path: path)
+  }
+  
+  mutating func rootDef(address: Value, path: UnusedWalkingPath) -> WalkResult {
+    return .continueWalk
+  }
+}
+
 /// In case of a `load [take]` shrink lifetime of the value in memory back to the `availableValue`
 /// and return the (possibly projected) available value. For example:
 ///

test/SILOptimizer/redundant_load_elim_ossa.sil

@@ -1271,6 +1271,39 @@ bb0(%0 : $*Builtin.Int64, %1 : @guaranteed $Builtin.NativeObject):
   return %6 : $(Builtin.Int64, Builtin.Int64)
 }
 
+// CHECK-LABEL: sil [ossa] @insert_mark_dependence :
+// CHECK:         mark_dependence
+// CHECK:         [[MD:%.*]] = mark_dependence %0 : $B on %1
+// CHECK:         return [[MD]]
+// CHECK-LABEL: } // end sil function 'insert_mark_dependence'
+sil [ossa] @insert_mark_dependence : $@convention(thin) (@owned B, @guaranteed B) -> @owned B {
+bb0(%0 : @owned $B, %1 : @guaranteed $B):
+  %2 = alloc_stack $B
+  store %0 to [init] %2
+  %4 = mark_dependence %2 on %1
+  %5 = load [take] %4
+  dealloc_stack %2
+  return %5
+}
+
+// CHECK-LABEL: sil [ossa] @insert_two_mark_dependences :
+// CHECK:         mark_dependence
+// CHECK:         mark_dependence
+// CHECK:         [[MD1:%.*]] = mark_dependence %0 : $B on %1
+// CHECK:         [[MD2:%.*]] = mark_dependence [[MD1]] : $B on %2
+// CHECK:         return [[MD2]]
+// CHECK-LABEL: } // end sil function 'insert_two_mark_dependences'
+sil [ossa] @insert_two_mark_dependences : $@convention(thin) (@owned B, @guaranteed B, @guaranteed B) -> @owned B {
+bb0(%0 : @owned $B, %1 : @guaranteed $B, %2 : @guaranteed $B):
+  %3 = alloc_stack $B
+  store %0 to [init] %3
+  %5 = mark_dependence %3 on %1
+  %6 = mark_dependence %5 on %2
+  %7 = load [take] %6
+  dealloc_stack %3
+  return %7
+}
+
 // CHECK-LABEL: sil [ossa] @dont_crash_on_index_addr_projection :
 // CHECK-LABEL: } // end sil function 'dont_crash_on_index_addr_projection'
 sil [ossa] @dont_crash_on_index_addr_projection : $@convention(thin) (Builtin.RawPointer) -> (Int, Int, Int, Int) {