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

Also, make the ObjectOutliner work for OSSA. Though, it currently doesn't run in the OSSA pipeline.

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,23 +27,43 @@ 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.
 /// Then subsequent calls to this function can do a fast lookup using the cache.
 ///
 let objectOutliner = FunctionPass(name: "object-outliner") {
   (function: Function, context: FunctionPassContext) in
+
+  if function.hasOwnership && !function.isSwift51RuntimeAvailable {
+    // Since Swift 5.1 global objects have immortal ref counts. And that's required for ownership.
+    return
+  }
+
   for inst in function.instructions {
     if let ari = inst as? AllocRefInstBase {
+      if !context.continueWithNextSubpassRun(for: inst) {
+        return
+      }
       if let globalValue = optimizeObjectAllocation(allocRef: ari, context) {
         optimizeFindStringCall(stringArray: globalValue, context)
       }
@@ -55,14 +76,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 +95,42 @@ 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:
+      if ecm.doKeepUnique {
+        return nil
+      }
       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 +143,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 +159,17 @@ 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,
+         is BeginBorrowInst:
+      if !findInitStores(of: user as! SingleValueInstruction, &fieldStores, &tailStores, ignore: ignoreInst) {
         return false
       }
     case let rea as RefElementAddrInst:
@@ -153,6 +180,9 @@ private func findInitStores(of object: Value,
       if !findStores(toTailAddress: rta, tailElementIndex: 0, stores: &tailStores) {
         return false
       }
+    case ignoreInst,
+         is EndBorrowInst:
+      break
     default:
       if !isValidUseOfObject(use) {
         return false
@@ -243,8 +273,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 +343,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)
@@ -349,7 +379,9 @@ private func replace(object allocRef: AllocRefInstBase,
   // Replace the alloc_ref by global_value + strong_retain instructions.
   let builder = Builder(before: allocRef, context)
   let globalValue = builder.createGlobalValue(global: global, isBare: false)
-  builder.createStrongRetain(operand: globalValue)
+  if !allocRef.parentFunction.hasOwnership {
+    builder.createStrongRetain(operand: globalValue)
+  }
 
   rewriteUses(of: allocRef, context)
   allocRef.uses.replaceAll(with: globalValue, context)
@@ -367,13 +399,16 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
     case let beginDealloc as BeginDeallocRefInst:
       worklist.pushIfNotVisited(usersOf: beginDealloc)
       let builder = Builder(before: beginDealloc, context)
-      builder.createStrongRelease(operand: beginDealloc.reference)
+      if !beginDealloc.parentFunction.hasOwnership {
+        builder.createStrongRelease(operand: beginDealloc.reference)
+      }
       beginDealloc.uses.replaceAll(with: beginDealloc.reference, context)
       context.erase(instruction: beginDealloc)
-    case let endMutation as EndCOWMutationInst:
-      worklist.pushIfNotVisited(usersOf: endMutation)
-      endMutation.uses.replaceAll(with: endMutation.instance, context)
-      context.erase(instruction: endMutation)
+    case is EndCOWMutationInst, is EndInitLetRefInst, is MoveValueInst:
+      let svi = inst as! SingleValueInstruction
+      worklist.pushIfNotVisited(usersOf: svi)
+      svi.uses.replaceAll(with: svi.operands[0].value, context)
+      context.erase(instruction: svi)
     case let upCast as UpcastInst:
       worklist.pushIfNotVisited(usersOf: upCast)
     case let refCast as UncheckedRefCastInst:
@@ -407,6 +442,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.

lib/SIL/IR/ValueOwnership.cpp

@@ -71,6 +71,7 @@ CONSTANT_OWNERSHIP_INST(Owned, WeakCopyValue)
 
 CONSTANT_OWNERSHIP_INST(Guaranteed, BeginBorrow)
 CONSTANT_OWNERSHIP_INST(Guaranteed, LoadBorrow)
+CONSTANT_OWNERSHIP_INST(None, GlobalValue)
 CONSTANT_OWNERSHIP_INST(Owned, AllocBox)
 CONSTANT_OWNERSHIP_INST(Owned, AllocExistentialBox)
 CONSTANT_OWNERSHIP_INST(Owned, AllocRef)
@@ -85,7 +86,6 @@ CONSTANT_OWNERSHIP_INST(Owned, EndInitLetRef)
 CONSTANT_OWNERSHIP_INST(Owned, BeginDeallocRef)
 CONSTANT_OWNERSHIP_INST(Owned, KeyPath)
 CONSTANT_OWNERSHIP_INST(Owned, InitExistentialValue)
-CONSTANT_OWNERSHIP_INST(Owned, GlobalValue) // TODO: is this correct?
 
 // One would think that these /should/ be unowned. In truth they are owned since
 // objc metatypes do not go through the retain/release fast path. In their