ObjectOutliner: support outlining of classes in global let variables

```
  let c = SomeClass()
```

is turned into

```
  private let outlinedVariable = SomeClass()  // statically initialized and allocated in the data section
  let c = outlinedVariable
```

rdar://111021230
rdar://115502043

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -12,8 +12,9 @@
 
 import SIL
 
-/// Outlines COW objects from functions into statically initialized global variables.
-/// This is currently only done for Arrays.
+/// Outlines class objects from functions into statically initialized global variables.
+/// This is currently done for Arrays and for global let variables.
+///
 /// If a function constructs an Array literal with constant elements (done by storing
 /// the element values into the array buffer), a new global variable is created which
 /// contains the constant elements in its static initializer.
@@ -26,14 +27,25 @@ import SIL
 /// ```
 /// is turned into
 /// ```
-///   private let outlinedVariable_from_arrayLookup = [10, 11, 12]  // statically initialized
+///   private let outlinedVariable = [10, 11, 12]  // statically initialized and allocated in the data section
 ///
 ///   public func arrayLookup(_ i: Int) -> Int {
-///     return outlinedVariable_from_arrayLookup[i]
+///     return outlinedVariable[i]
 ///   }
 /// ```
 ///
-/// As a second optimization, if the array is a string literal which is a parameter to the
+/// Similar with global let variables:
+/// ```
+///   let c = SomeClass()
+/// ```
+/// is turned into
+/// ```
+///   private let outlinedVariable = SomeClass()  // statically initialized and allocated in the data section
+///
+///   let c = outlinedVariable
+/// ```
+///
+/// As a second optimization, if an array is a string literal which is a parameter to the
 /// `_findStringSwitchCase` library function and the array has many elements (> 16), the
 /// call is redirected to `_findStringSwitchCaseWithCache`. This function builds a cache
 /// (e.g. a Dictionary) and stores it into a global variable.
@@ -55,14 +67,11 @@ private func optimizeObjectAllocation(allocRef: AllocRefInstBase, _ context: Fun
     return nil
   }
 
-  // The presence of an end_cow_mutation guarantees that the originally initialized
-  // object is not mutated (because it must be copied before mutation).
-  guard let endCOW = findEndCOWMutation(of: allocRef),
-        !endCOW.doKeepUnique else {
+  guard let endOfInitInst = findEndOfInitialization(of: allocRef) else {
     return nil
   }
 
-  guard let (storesToClassFields, storesToTailElements) = getInitialization(of: allocRef) else {
+  guard let (storesToClassFields, storesToTailElements) = getInitialization(of: allocRef, ignore: endOfInitInst) else {
     return nil
   }
 
@@ -77,32 +86,39 @@ private func optimizeObjectAllocation(allocRef: AllocRefInstBase, _ context: Fun
   return replace(object: allocRef, with: outlinedGlobal, context)
 }
 
-private func findEndCOWMutation(of object: Value) -> EndCOWMutationInst? {
+// The end-of-initialization is either an end_cow_mutation, because it guarantees that the originally initialized
+// object is not mutated (it must be copied before mutation).
+// Or it is the store to a global let variable in the global's initializer function.
+private func findEndOfInitialization(of object: Value) -> Instruction? {
   for use in object.uses {
-    switch use.instruction {
-    case let uci as UpcastInst:
-      if let ecm = findEndCOWMutation(of: uci) {
-        return ecm
-      }
-    case let urci as UncheckedRefCastInst:
-      if let ecm = findEndCOWMutation(of: urci) {
-        return ecm
-      }
-    case let mv as MoveValueInst:
-      if let ecm = findEndCOWMutation(of: mv) {
+    let user = use.instruction
+    switch user {
+    case is UpcastInst,
+         is UncheckedRefCastInst,
+         is MoveValueInst,
+         is EndInitLetRefInst:
+      if let ecm = findEndOfInitialization(of: user as! SingleValueInstruction) {
         return ecm
       }
     case let ecm as EndCOWMutationInst:
       return ecm
+    case let store as StoreInst:
+      if let ga = store.destination as? GlobalAddrInst,
+         ga.global.isLet,
+         ga.parentFunction.initializedGlobal == ga.global
+      {
+        return store
+      }
     default:
       break
     }
   }
   return nil
 }
 
-private func getInitialization(of allocRef: AllocRefInstBase) -> (storesToClassFields: [StoreInst],
-                                                                  storesToTailElements: [StoreInst])? {
+private func getInitialization(of allocRef: AllocRefInstBase, ignore ignoreInst: Instruction)
+  -> (storesToClassFields: [StoreInst], storesToTailElements: [StoreInst])?
+{
   guard let numTailElements = allocRef.numTailElements else {
     return nil
   }
@@ -115,9 +131,10 @@ private func getInitialization(of allocRef: AllocRefInstBase) -> (storesToClassF
   //   store %0 to %3
   //   %4 = tuple_element_addr %2, 1
   //   store %1 to %4
-  var tailStores = Array<StoreInst?>(repeating: nil, count: numTailElements * allocRef.numStoresPerTailElement)
+  let tailCount = numTailElements != 0 ? numTailElements * allocRef.numStoresPerTailElement : 0
+  var tailStores = Array<StoreInst?>(repeating: nil, count: tailCount)
 
-  if !findInitStores(of: allocRef, &fieldStores, &tailStores) {
+  if !findInitStores(of: allocRef, &fieldStores, &tailStores, ignore: ignoreInst) {
     return nil
   }
 
@@ -130,19 +147,16 @@ private func getInitialization(of allocRef: AllocRefInstBase) -> (storesToClassF
 
 private func findInitStores(of object: Value,
                             _ fieldStores: inout [StoreInst?],
-                            _ tailStores: inout [StoreInst?]) -> Bool {
+                            _ tailStores: inout [StoreInst?],
+                            ignore ignoreInst: Instruction) -> Bool {
   for use in object.uses {
-    switch use.instruction {
-    case let uci as UpcastInst:
-      if !findInitStores(of: uci, &fieldStores, &tailStores) {
-        return false
-      }
-    case let urci as UncheckedRefCastInst:
-      if !findInitStores(of: urci, &fieldStores, &tailStores) {
-        return false
-      }
-    case let mvi as MoveValueInst:
-      if !findInitStores(of: mvi, &fieldStores, &tailStores) {
+    let user = use.instruction
+    switch user {
+    case is UpcastInst,
+         is UncheckedRefCastInst,
+         is MoveValueInst,
+         is EndInitLetRefInst:
+      if !findInitStores(of: user as! SingleValueInstruction, &fieldStores, &tailStores, ignore: ignoreInst) {
         return false
       }
     case let rea as RefElementAddrInst:
@@ -153,6 +167,8 @@ private func findInitStores(of object: Value,
       if !findStores(toTailAddress: rta, tailElementIndex: 0, stores: &tailStores) {
         return false
       }
+    case ignoreInst:
+      break
     default:
       if !isValidUseOfObject(use) {
         return false
@@ -243,8 +259,7 @@ private func isValidUseOfObject(_ use: Operand) -> Bool {
        is DeallocStackRefInst,
        is StrongRetainInst,
        is StrongReleaseInst,
-       is FixLifetimeInst,
-       is EndCOWMutationInst:
+       is FixLifetimeInst:
     return true
 
   case let mdi as MarkDependenceInst:
@@ -314,23 +329,24 @@ private func constructObject(of allocRef: AllocRefInstBase,
   }
   let globalBuilder = Builder(staticInitializerOf: global, context)
 
-  // Create the initializers for the tail elements.
-  let numTailTupleElems = allocRef.numStoresPerTailElement
-  if numTailTupleElems > 1 {
-    // The elements are tuples: combine numTailTupleElems elements to a single tuple instruction.
-    for elementIdx in 0..<allocRef.numTailElements! {
-      var tupleElems = [Value]()
-      for tupleIdx in 0..<numTailTupleElems {
-        let store = storesToTailElements[elementIdx * numTailTupleElems + tupleIdx]
-        tupleElems.append(cloner.clone(store.source as! SingleValueInstruction))
+  if !storesToTailElements.isEmpty {
+    // Create the initializers for the tail elements.
+    let numTailTupleElems = allocRef.numStoresPerTailElement
+    if numTailTupleElems > 1 {
+      // The elements are tuples: combine numTailTupleElems elements to a single tuple instruction.
+      for elementIdx in 0..<allocRef.numTailElements! {
+        let tupleElems = (0..<numTailTupleElems).map { tupleIdx in
+            let store = storesToTailElements[elementIdx * numTailTupleElems + tupleIdx]
+            return cloner.clone(store.source as! SingleValueInstruction)
+        }
+        let tuple = globalBuilder.createTuple(type: allocRef.tailAllocatedTypes[0], elements: tupleElems)
+        objectArgs.append(tuple)
+      }
+    } else {
+      // The non-tuple element case.
+      for store in storesToTailElements {
+        objectArgs.append(cloner.clone(store.source as! SingleValueInstruction))
       }
-      let tuple = globalBuilder.createTuple(type: allocRef.tailAllocatedTypes[0], elements: tupleElems)
-      objectArgs.append(tuple)
-    }
-  } else {
-    // The non-tuple element case.
-    for store in storesToTailElements {
-      objectArgs.append(cloner.clone(store.source as! SingleValueInstruction))
     }
   }
   globalBuilder.createObject(type: allocRef.type, arguments: objectArgs, numBaseElements: storesToClassFields.count)
@@ -374,6 +390,10 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
       worklist.pushIfNotVisited(usersOf: endMutation)
       endMutation.uses.replaceAll(with: endMutation.instance, context)
       context.erase(instruction: endMutation)
+    case let eilr as EndInitLetRefInst:
+      worklist.pushIfNotVisited(usersOf: eilr)
+      eilr.uses.replaceAll(with: eilr.operand.value, context)
+      context.erase(instruction: eilr)
     case let upCast as UpcastInst:
       worklist.pushIfNotVisited(usersOf: upCast)
     case let refCast as UncheckedRefCastInst:
@@ -407,6 +427,11 @@ private extension AllocRefInstBase {
   }
 
   var numTailElements: Int? {
+
+    if tailAllocatedCounts.count == 0 {
+      return 0
+    }
+
     // We only support a single tail allocated array.
     // Stdlib's tail allocated arrays don't have any side-effects in the constructor if the element type is trivial.
     // TODO: also exclude custom tail allocated arrays which might have side-effects in the destructor.

test/SILOptimizer/objectoutliner.sil

@@ -18,6 +18,9 @@ sil_global [let] @g1 : $Int32 = {
   %initval = struct $Int32 (%0 : $Builtin.Int32)
 }
 
+sil_global [let] @gobj : $Obj
+sil_global @gobj_var : $Obj
+
 // CHECK-LABEL: sil_global private @outline_global_simpleTv_ : $Obj = {
 // CHECK-NEXT:    %0 = integer_literal $Builtin.Int64, 1
 // CHECK-NEXT:    %1 = struct $Int64 (%0 : $Builtin.Int64)
@@ -61,6 +64,12 @@ sil_global [let] @g1 : $Int32 = {
 // CHECK-NEXT:    %initval = object $Obj (%1 : $Int64, [tail_elems] %4 : $UnsafePointer<Int32>)
 // CHECK-NEXT:  }
 
+// CHECK-LABEL: sil_global private @init_gobjTv_ : $Obj = {
+// CHECK-NEXT:    %0 = integer_literal $Builtin.Int64, 27
+// CHECK-NEXT:    %1 = struct $Int64 (%0 : $Builtin.Int64)
+// CHECK-NEXT:    %initval = object $Obj (%1 : $Int64)
+// CHECK-NEXT:  }
+
 // CHECK-LABEL: sil @outline_global_simple
 // CHECK: [[G:%[0-9]+]] = global_value @outline_global_simpleTv_ : $Obj
 // CHECK: strong_retain [[G]] : $Obj
@@ -197,19 +206,18 @@ bb0:
   return %r : $()
 }
 
-// CHECK-LABEL: sil @dont_outline_without_tail_elems
+// CHECK-LABEL: sil @dont_outline_without_end_cow_mutation
 // CHECK: alloc_ref
 // CHECK: store
 // CHECK: return
-sil @dont_outline_without_tail_elems : $@convention(thin) () -> () {
+sil @dont_outline_without_end_cow_mutation : $@convention(thin) () -> () {
 bb0:
   %1 = integer_literal $Builtin.Int64, 1
   %4 = struct $Int64 (%1 : $Builtin.Int64)
   %7 = alloc_ref $Obj
   %9 = ref_element_addr %7 : $Obj, #Obj.value
   store %4 to %9 : $*Int64
-  %10 = end_cow_mutation %7 : $Obj
-  strong_release %10 : $Obj
+  strong_release %7 : $Obj
   %r = tuple ()
   return %r : $()
 }
@@ -448,3 +456,44 @@ bb0:
   return %r : $()
 }
 
+// CHECK-LABEL: sil [global_init_once_fn] @init_gobj :
+// CHECK:         [[A:%.*]] = global_addr @gobj : $*Obj
+// CHECK:         [[G:%[0-9]+]] = global_value @init_gobjTv_ : $Obj
+// CHECK:         strong_retain [[G]] : $Obj
+// CHECK:         store [[G]] to [[A]]
+// CHECK:       } // end sil function 'init_gobj'
+sil [global_init_once_fn] @init_gobj : $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @gobj
+  %2 = global_addr @gobj : $*Obj
+  %3 = integer_literal $Builtin.Int64, 27
+  %4 = struct $Int64 (%3 : $Builtin.Int64)
+  %5 = alloc_ref $Obj
+  %8 = end_init_let_ref %5 : $Obj
+  %9 = ref_element_addr %8 : $Obj, #Obj.value
+  store %4 to %9 : $*Int64
+  store %8 to %2 : $*Obj
+  %12 = tuple ()
+  return %12 : $()
+}
+
+// CHECK-LABEL: sil [global_init_once_fn] @init_gobj_var :
+// CHECK:         alloc_ref
+// CHECK-NOT:     global_value
+// CHECK:       } // end sil function 'init_gobj_var'
+sil [global_init_once_fn] @init_gobj_var : $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @gobj_var
+  %2 = global_addr @gobj_var : $*Obj
+  %3 = integer_literal $Builtin.Int64, 27
+  %4 = struct $Int64 (%3 : $Builtin.Int64)
+  %5 = alloc_ref $Obj
+  %8 = end_init_let_ref %5 : $Obj
+  %9 = ref_element_addr %8 : $Obj, #Obj.value
+  store %4 to %9 : $*Int64
+  store %8 to %2 : $*Obj
+  %12 = tuple ()
+  return %12 : $()
+}
+
+

test/SILOptimizer/static_objects.swift

@@ -0,0 +1,56 @@
+// RUN: %target-swift-frontend -parse-as-library %s -O -sil-verify-all -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test -emit-sil | %FileCheck %s
+// RUN: %target-swift-frontend -parse-as-library %s -O -sil-verify-all -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test -emit-ir | %FileCheck %s -check-prefix=CHECK-LLVM
+
+// Also do an end-to-end test to check all components, including IRGen.
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -parse-as-library -O -Xllvm -sil-disable-pass=FunctionSignatureOpts -module-name=test %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
+// REQUIRES: executable_test,swift_stdlib_no_asserts,optimized_stdlib
+// REQUIRES: CPU=arm64 || CPU=x86_64
+// REQUIRES: swift_in_compiler
+
+
+public class C {
+  var x: Int
+
+  init(x: Int) {
+    self.x = x
+  }
+}
+
+public class D: C {}
+
+// CHECK-LABEL: sil_global private @$s4test1c_WZTv_ : $C = {
+// CHECK-NEXT:    %0 = integer_literal $Builtin.Int64, 27         // user: %1
+// CHECK-NEXT:    %1 = struct $Int (%0 : $Builtin.Int64)          // user: %2
+// CHECK-NEXT:    %initval = object $C (%1 : $Int)
+// CHECK-NEXT:  }
+
+// CHECK-LLVM-LABEL: @"$s4test1c_WZTv_" ={{.*}} global %{{[a-zA-Z_0-9]*}}c { [1 x i64] zeroinitializer, %{{[a-zA-Z_0-9]*}} <{ %swift.refcounted zeroinitializer, %TSi <{ i64 27 }> }
+
+public let c = C(x: 27)
+
+
+// CHECK-LABEL: sil [noinline] @$s4test6testitAA1CCyF : $@convention(thin) () -> @owned C {
+// CHECK:         [[C:%.*]] = global_value @$s4test1c_WZTv_ : $C
+// CHECK-NEXT:    return [[C]]
+// CHECK:       } // end sil function '$s4test6testitAA1CCyF'
+
+// CHECK-LLVM-LABEL: define {{.*}} @"$s4test6testitAA1CCyF"
+// CHECK-LLVM:         [[C:%.*]] = tail call ptr @swift_initStaticObject({{.*}} getelementptr {{.*}}, ptr @"$s4test1c_WZTv_", i64 0, i32 1))
+// CHECK-LLVM-NEXT:    ret ptr [[C]]
+// CHECK-LLVM:       }
+@inline(never)
+public func testit() -> C {
+  return c
+}
+
+@main struct Main {
+  static func main() {
+    // CHECK-OUTPUT: c.x=27
+    print("c.x=\(testit().x)")
+    // CHECK-OUTPUT: c=test.C
+    print("c=\(testit())")
+  }
+}
+