RedundantLoadElimination: support redundant loads of array elements with non-constant index

For example:
```
func test3(_ arr: Array<Int>, index: Int) -> Int {
  return arr[index] + arr[index]
}
```

rdar://138519664

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -142,7 +142,7 @@ private extension LoadInst {
   }
 
   func isRedundant(complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
-    return isRedundant(at: address.accessPath, complexityBudget: &complexityBudget, context)
+    return isRedundant(at: address.constantAccessPath, complexityBudget: &complexityBudget, context)
   }
 
   func isRedundant(at accessPath: AccessPath, complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
@@ -282,7 +282,7 @@ private func provideValue(
   from availableValue: AvailableValue,
   _ context: FunctionPassContext
 ) -> Value {
-  let projectionPath = availableValue.address.accessPath.getMaterializableProjection(to: load.address.accessPath)!
+  let projectionPath = availableValue.address.constantAccessPath.getMaterializableProjection(to: load.address.constantAccessPath)!
 
   switch load.loadOwnership {
   case .unqualified:
@@ -483,7 +483,7 @@ private struct InstructionScanner {
         // This happens if the load is in a loop.
         return .available
       }
-      let precedingLoadPath = precedingLoad.address.accessPath
+      let precedingLoadPath = precedingLoad.address.constantAccessPath
       if precedingLoadPath.getMaterializableProjection(to: accessPath) != nil {
         availableValues.append(.viaLoad(precedingLoad))
         return .available
@@ -500,7 +500,7 @@ private struct InstructionScanner {
       if precedingStore.source is Undef {
         return .overwritten
       }
-      let precedingStorePath = precedingStore.destination.accessPath
+      let precedingStorePath = precedingStore.destination.constantAccessPath
       if precedingStorePath.getMaterializableProjection(to: accessPath) != nil {
         availableValues.append(.viaStore(precedingStore))
         return .available

test/SILOptimizer/redundant_load_elim_ossa.sil

@@ -1288,6 +1288,38 @@ bb0(%0 : $Builtin.RawPointer):
   return %99 : $(Int, Int, Int, Int)
 }
 
+// CHECK-LABEL: sil [ossa] @non_const_index :
+// CHECK:         [[L:%.*]] = load
+// CHECK-NOT:     load
+// CHECK:         tuple ([[L]] : $Int, [[L]] : $Int)
+// CHECK-LABEL: } // end sil function 'non_const_index'
+sil [ossa] @non_const_index : $@convention(thin) (@guaranteed B, Builtin.Word) -> (Int, Int) {
+bb0(%0 : @guaranteed $B, %1 : $Builtin.Word):
+  %2 = ref_tail_addr %0 : $B, $Int
+  %3 = index_addr %2 : $*Int, %1 : $Builtin.Word
+  %4 = load [trivial] %3 : $*Int
+  %5 = load [trivial] %3 : $*Int
+  %6 = tuple (%4 : $Int, %5 : $Int)
+  return %6 : $(Int, Int)
+}
+
+// CHECK-LABEL: sil [ossa] @non_const_index_aliasing :
+// CHECK:         [[L1:%.*]] = load
+// CHECK:         store
+// CHECK:         [[L2:%.*]] = load
+// CHECK:         tuple ([[L1]] : $Int, [[L2]] : $Int)
+// CHECK-LABEL: } // end sil function 'non_const_index_aliasing'
+sil [ossa] @non_const_index_aliasing : $@convention(thin) (@guaranteed B, Builtin.Word, Int) -> (Int, Int) {
+bb0(%0 : @guaranteed $B, %1 : $Builtin.Word, %2 : $Int):
+  %3 = ref_tail_addr %0 : $B, $Int
+  %4 = index_addr %3 : $*Int, %1 : $Builtin.Word
+  %5 = load [trivial] %3 : $*Int
+  store %2 to [trivial] %4: $*Int
+  %7 = load [trivial] %3 : $*Int
+  %8 = tuple (%5 : $Int, %7 : $Int)
+  return %8 : $(Int, Int)
+}
+
 sil [ossa] @overwrite_int : $@convention(thin) (@inout Int, Int) -> ()
 
 // Make sure that the store is forwarded to the load, ie. the load is

test/SILOptimizer/redundant_load_elimination.swift

@@ -1,7 +1,6 @@
 // RUN: %target-swift-frontend -parse-as-library -module-name test %s -O -emit-sil | %FileCheck %s
 
-// REQUIRES: swift_in_compiler
-
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
 
 public final class C {
   let i: Int
@@ -25,3 +24,46 @@ public func testLetField(_ c: C, f: () -> ()) ->  (Int, Int) {
   return (a, b)
 }
 
+let globalLetArray = [1, 2, 3, 4]
+
+// CHECK-LABEL: sil @$s4test5test15indexS2i_tF :
+// CHECK:           load
+// CHECK:           [[L:%.*]] = load
+// CHECK-NOT:       load
+// CHECK:           builtin "sadd_with_overflow{{.*}}"([[L]] : {{.*}}, [[L]] :
+// CHECK:       } // end sil function '$s4test5test15indexS2i_tF'
+public func test1(index: Int) -> Int {
+  let elem1 = globalLetArray[index]
+  let elem2 = globalLetArray[index]
+  return elem1 + elem2
+}
+
+struct Wrapper {
+  let arr: Array<Int>
+  init() {
+    arr = [1, 2, 3, 4]
+  }
+}
+
+// CHECK-LABEL: sil @$s4test5test25indexS2i_tF :
+// CHECK:           [[L:%.*]] = load
+// CHECK-NOT:       load
+// CHECK:           builtin "sadd_with_overflow{{.*}}"([[L]] : {{.*}}, [[L]] :
+// CHECK:       } // end sil function '$s4test5test25indexS2i_tF'
+public func test2(index: Int) -> Int {
+  let w = Wrapper()
+  let elem1 = w.arr[index]
+  let elem2 = w.arr[index]
+  return elem1 + elem2
+}
+
+// CHECK-LABEL: sil @$s4test5test3_5indexSiSaySiG_SitF :
+// CHECK:           load
+// CHECK:           [[L:%.*]] = load
+// CHECK-NOT:       load
+// CHECK:           builtin "sadd_with_overflow{{.*}}"([[L]] : {{.*}}, [[L]] :
+// CHECK:       } // end sil function '$s4test5test3_5indexSiSaySiG_SitF'
+public func test3(_ arr: Array<Int>, index: Int) -> Int {
+  return arr[index] + arr[index]
+}
+