MandatoryPerformanceOptimizations: refine the inlining decisions in global initializers

We inline a function (e.g. a struct initializer) into a global init function if the result is part of the initialized global.
Now, also handle functions with indirect return values. Such function can result from not-reabstracted generic specializations.
Handle cases where the result is stored into a temporary alloc_stack or directly stored to (a part) of the global variable.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -134,17 +134,66 @@ private func shouldInline(apply: FullApplySite, callee: Function, alreadyInlined
     // Force inlining them in global initializers so that it's possible to statically initialize the global.
     return true
   }
-  if apply.parentFunction.isGlobalInitOnceFunction,
-      let global = apply.parentFunction.getInitializedGlobal(),
-      global.mustBeInitializedStatically,
-      let applyInst = apply as? ApplyInst,
-      let projectionPath = applyInst.isStored(to: global),
-      alreadyInlinedFunctions.insert(PathFunctionTuple(path: projectionPath, function: callee)).inserted {
+
+  if apply.substitutionMap.isEmpty,
+     let pathIntoGlobal = apply.resultIsUsedInGlobalInitialization(),
+     alreadyInlinedFunctions.insert(PathFunctionTuple(path: pathIntoGlobal, function: callee)).inserted {
     return true
   }
+
   return false
 }
 
+private extension FullApplySite {
+  func resultIsUsedInGlobalInitialization() -> SmallProjectionPath? {
+    guard parentFunction.isGlobalInitOnceFunction,
+          let global = parentFunction.getInitializedGlobal() else {
+      return nil
+    }
+
+    switch numIndirectResultArguments {
+    case 0:
+      return singleDirectResult?.isStored(to: global)
+    case 1:
+      let resultAccessPath = arguments[0].accessPath
+      switch resultAccessPath.base {
+      case .global(let resultGlobal) where resultGlobal == global:
+        return resultAccessPath.materializableProjectionPath
+      case .stack(let allocStack) where resultAccessPath.projectionPath.isEmpty:
+        return allocStack.getStoredValue(by: self)?.isStored(to: global)
+      default:
+        return nil
+      }
+    default:
+      return nil
+    }
+  }
+}
+
+private extension AllocStackInst {
+  func getStoredValue(by storingInstruction: Instruction) -> Value? {
+    // If the only use (beside `storingInstruction`) is a load, it's the value which is
+    // stored by `storingInstruction`.
+    var loadedValue: Value? = nil
+    for use in self.uses {
+      switch use.instruction {
+      case is DeallocStackInst:
+        break
+      case let load as LoadInst:
+        if loadedValue != nil {
+          return nil
+        }
+        loadedValue = load
+      default:
+        if use.instruction != storingInstruction {
+          return nil
+        }
+      }
+    }
+    return loadedValue
+  }
+}
+
 private extension Value {
   /// Analyzes the def-use chain of an apply instruction, and looks for a single chain that leads to a store instruction
   /// that initializes a part of a global variable or the entire variable:
@@ -193,15 +242,13 @@ private extension Value {
         path = path.push(.enumCase, index: ei.caseIndex)
         break
       case let si as StoreInst:
-        guard let storeDestination = si.destination as? GlobalAddrInst else {
-          return nil
-        }
-
-        guard storeDestination.global == global else {
+        let accessPath = si.destination.getAccessPath(fromInitialPath: path)
+        switch accessPath.base {
+        case .global(let storedGlobal) where storedGlobal == global:
+          return accessPath.materializableProjectionPath
+        default:
           return nil
         }
-        
-        return path
       default:
         return nil
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -293,6 +293,13 @@ struct AccessPath : CustomStringConvertible {
     return getProjection(to: other) != nil
   }
 
+  var materializableProjectionPath: SmallProjectionPath? {
+    if projectionPath.isMaterializable {
+      return projectionPath
+    }
+    return nil
+  }
+
   /// Returns the projection path to `other` if this access path is equal or contains `other`.
   ///
   /// For example,

test/SILOptimizer/performance-annotations.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -experimental-performance-annotations -emit-sil %s -o /dev/null -verify
+// RUN: %target-swift-frontend -parse-as-library -emit-sil %s -o /dev/null -verify
 // REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
 // REQUIRES: swift_in_compiler
 
@@ -11,7 +11,7 @@ open class Cl {
   final func finalMethod() {}
 }
 
-func initFunc() -> Int { return 3 }
+func initFunc() -> Int { return Int.random(in: 0..<10) }
 
 struct Str : P {
   let x: Int
@@ -163,8 +163,8 @@ class H {
 }
 
 struct MyStruct {
-  static var v: Int = {  // expected-note {{called from here}}
-    return H().hash      // expected-error {{Using type 'H' can cause metadata allocation or locks}}
+  static var v: Int = {      // expected-error {{Using type 'H' can cause metadata allocation or locks}}
+    return H().hash
   }()
 }
 
@@ -330,3 +330,50 @@ public func testClosurePassing(a: inout Y) -> Int {
     return a.Xsort()
 }
 
+struct LargeGenericStruct<T> {
+  var a: T
+  var b: T
+  var c: T
+  var d: T
+  var e: T
+  var f: T
+  var g: T
+  var h: T
+}
+
+var largeGeneric = LargeGenericStruct<Int>(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8)
+
+@_noLocks
+func testLargeGenericStruct() -> LargeGenericStruct<Int> {
+  return largeGeneric
+}
+
+struct ContainsLargeGenericStruct {
+  var s: LargeGenericStruct<Int>
+}
+
+var clgs = ContainsLargeGenericStruct(s: LargeGenericStruct<Int>(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8))
+
+@_noLocks
+func testClgs() -> ContainsLargeGenericStruct {
+  return clgs
+}
+
+struct NestedGenericStruct<T> {
+  var a: T
+  var b: T
+  var c: LargeGenericStruct<T>
+  var d: T
+  var e: T
+  var f: T
+  var g: T
+  var h: T
+}
+
+var nestedGeneric = NestedGenericStruct(a: 1, b: 2, c: LargeGenericStruct<Int>(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8), d: 4, e: 5, f: 6, g: 7, h: 8)
+
+@_noLocks
+func testNestedGenericStruct() -> NestedGenericStruct<Int> {
+  return nestedGeneric
+}
+