SimplifyLoad: remove a load from a global object, e.g. from an outlined array

Loading  array elements or the array's count/capacity can be replaced with the actual value if the array is a statically allocated global let-variable.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -234,12 +234,34 @@ private func getGlobalInitValue(address: Value, _ context: SimplifyContext) -> V
     }
   case let bai as BeginAccessInst:
     return getGlobalInitValue(address: bai.address, context)
+  case let rta as RefTailAddrInst:
+    return getGlobalTailElement(of: rta, index: 0)
+  case let ia as IndexAddrInst:
+    if let rta = ia.base as? RefTailAddrInst,
+       let literal = ia.index as? IntegerLiteralInst,
+       let index = literal.value
+    {
+      return getGlobalTailElement(of: rta, index: index)
+    }
+  case let rea as RefElementAddrInst:
+    if let object = rea.instance.immutableGlobalObjectRoot {
+      return object.baseOperands[rea.fieldIndex].value
+    }
   default:
     break
   }
   return nil
 }
 
+private func getGlobalTailElement(of refTailAddr: RefTailAddrInst, index: Int) -> Value? {
+  if let object = refTailAddr.instance.immutableGlobalObjectRoot,
+     index >= 0 && index < object.tailOperands.count
+  {
+    return object.tailOperands[index].value
+  }
+  return nil
+}
+
 private func getInitializerFromInitFunction(of globalAddr: GlobalAddrInst, _ context: SimplifyContext) -> Value? {
   guard let dependentOn = globalAddr.dependencyToken,
         let builtinOnce = dependentOn as? BuiltinInst,
@@ -321,6 +343,19 @@ private extension Value {
     }
     return (baseAddress: self, offset: 0)
   }
+
+  // If the reference-root of self references a global object, returns the `object` instruction of the
+  // global's initializer. But only if the global is a let-global.
+  var immutableGlobalObjectRoot: ObjectInst? {
+    if let gv = self.referenceRoot as? GlobalValueInst,
+       gv.global.isLet,
+       let initval = gv.global.staticInitValue,
+       let object = initval as? ObjectInst
+    {
+      return object
+    }
+    return nil
+  }
 }
 
 private extension Instruction {

test/SILOptimizer/redundant_load_elimination.swift

@@ -27,7 +27,6 @@ public func testLetField(_ c: C, f: () -> ()) ->  (Int, Int) {
 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]] :

test/SILOptimizer/simplify_load.sil

@@ -23,13 +23,37 @@ sil_global [let] @gstr : $Str = {
 class B { }
 class E : B { }
 
+class C {
+  @_hasStorage var c: Builtin.Int64
+}
+
+class D : C {
+  @_hasStorage var d: Builtin.Int64
+}
+
 sil_global hidden [let] @gb : $B
 sil_global hidden [let] @gb2 : $(B, Int64)
 
 sil_global private @gb_obj : $B = {
   %initval = object $B ()
 }
 
+sil_global [let] @gc : $D = {
+  %0 = integer_literal $Builtin.Int64, 0
+  %1 = integer_literal $Builtin.Int64, 1
+  %2 = integer_literal $Builtin.Int64, 2
+  %3 = integer_literal $Builtin.Int64, 3
+  %initval = object $D (%0, %1, [tail_elems] %2, %3)
+}
+
+sil_global @gc_var : $D = {
+  %0 = integer_literal $Builtin.Int64, 0
+  %1 = integer_literal $Builtin.Int64, 1
+  %2 = integer_literal $Builtin.Int64, 2
+  %3 = integer_literal $Builtin.Int64, 3
+  %initval = object $D (%0, %1, [tail_elems] %2, %3)
+}
+
 sil [global_init_once_fn] @init_gb : $@convention(c) () -> () {
 bb0:
   alloc_global @gb
@@ -469,3 +493,40 @@ bb0(%0 : $*B):
   return %3 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @load_from_global_object :
+// CHECK-DAG:     [[I0:%.*]] = integer_literal $Builtin.Int64, 0
+// CHECK-DAG:     [[I1:%.*]] = integer_literal $Builtin.Int64, 1
+// CHECK-DAG:     [[I2:%.*]] = integer_literal $Builtin.Int64, 2
+// CHECK-DAG:     [[I3:%.*]] = integer_literal $Builtin.Int64, 3
+// CHECK:         [[T:%.*]] = tuple ([[I0]] : $Builtin.Int64, [[I1]] : $Builtin.Int64, [[I2]] : $Builtin.Int64, [[I3]] : $Builtin.Int64)
+// CHECK:         return [[T]]
+// CHECK:       } // end sil function 'load_from_global_object'
+sil [ossa] @load_from_global_object : $@convention(thin) () -> (Builtin.Int64, Builtin.Int64, Builtin.Int64, Builtin.Int64) {
+bb0:
+  %0 = global_value @gc : $D
+  %1 = upcast %0 to $C
+  %2 = ref_element_addr %1, #C.c
+  %3 = ref_element_addr %0, #D.d
+  %4 = ref_tail_addr %1, $Builtin.Int64
+  %5 = integer_literal $Builtin.Word, 1
+  %6 = index_addr %4, %5
+  %7 = load [trivial] %2
+  %8 = load [trivial] %3
+  %9 = load [trivial] %4
+  %10 = load [trivial] %6
+  %11 = tuple (%7, %8, %9, %10)
+  return %11
+}
+
+// CHECK-LABEL: sil [ossa] @dont_load_from_global_var_object :
+// CHECK:         [[L:%.*]] = load
+// CHECK:         return [[L]]
+// CHECK:       } // end sil function 'dont_load_from_global_var_object'
+sil [ossa] @dont_load_from_global_var_object : $@convention(thin) () -> Builtin.Int64 {
+bb0:
+  %0 = global_value @gc_var : $D
+  %1 = ref_element_addr %0, #D.d
+  %2 = load [trivial] %1
+  return %2
+}
+