Merge pull request #67515 from eeckstein/static-globals-improvements

Enable large generic structs in statically initialized global variables

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -48,6 +48,10 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
     return
   }
 
+  // Sometimes structs are not stored in one piece, but as individual elements.
+  // Merge such individual stores to a single store of the whole struct.
+  mergeStores(in: function, context)
+
   guard let (allocInst, storeToGlobal) = getGlobalInitialization(of: function) else {
     return
   }
@@ -137,3 +141,80 @@ private extension Function {
     return block
   }
 }
+
+/// Merges stores to individual struct fields to a single store of the whole struct.
+///
+///   store %element1 to %element1Addr
+///   store %element2 to %element2Addr
+/// ->
+///   %s = struct $S (%element1, %element2)
+///   store %s to @structAddr
+private func mergeStores(in function: Function, _ context: FunctionPassContext) {
+  for inst in function.instructions {
+    if let store = inst as? StoreInst {
+      if let elementStores = getSequenceOfElementStores(firstStore: store) {
+        merge(elementStores: elementStores, context)
+      }
+    }
+  }
+}
+
+/// Returns a sequence of individual stores to elements of a struct.
+///
+///   %addr1 = struct_element_addr %structAddr, #field1
+///   store %element1 to %addr1
+///   // ...
+///   %addr_n = struct_element_addr %structAddr, #field_n
+///   store %element_n to %addr_n
+///
+private func getSequenceOfElementStores(firstStore: StoreInst) -> [StoreInst]? {
+  guard let elementAddr = firstStore.destination as? StructElementAddrInst else {
+    return nil
+  }
+  let structAddr = elementAddr.struct
+  let numElements = structAddr.type.getNominalFields(in: firstStore.parentFunction).count
+  var elementStores = Array<StoreInst?>(repeating: nil, count: numElements)
+  var numStoresFound = 0
+
+  for inst in InstructionList(first: firstStore) {
+    switch inst {
+    case let store as StoreInst:
+      guard store.storeOwnership == .trivial,
+            let sea = store.destination as? StructElementAddrInst,
+            sea.struct == structAddr,
+            // Multiple stores to the same element?
+            elementStores[sea.fieldIndex] == nil else {
+        return nil
+      }
+
+      elementStores[sea.fieldIndex] = store
+      numStoresFound += 1
+      if numStoresFound == numElements {
+        // If we saw  `numElements` distinct stores, it implies that all elements in `elementStores` are not nil.
+        return elementStores.map { $0! }
+      }
+    default:
+      if inst.mayReadOrWriteMemory {
+        return nil
+      }
+    }
+  }
+  return nil
+}
+
+private func merge(elementStores: [StoreInst], _ context: FunctionPassContext) {
+  let lastStore = elementStores.last!
+  let builder = Builder(after: lastStore, context)
+
+  let structAddr = (lastStore.destination as! StructElementAddrInst).struct
+  let str = builder.createStruct(type: structAddr.type.objectType, elements: elementStores.map { $0.source })
+  builder.createStore(source: str, destination: structAddr, ownership: lastStore.storeOwnership)
+
+  for store in elementStores {
+    let destAddr = store.destination as! StructElementAddrInst
+    context.erase(instruction: store)
+    if destAddr.uses.isEmpty {
+      context.erase(instruction: destAddr)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -81,7 +81,7 @@ private extension BuiltinInst {
     // because memory effects are not computed in the Onone pipeline, yet.
     // This is no problem because the callee (usually a global init function )is mostly very small,
     // or contains the side-effect instruction `alloc_global` right at the beginning.
-    if callee.instructions.contains(where: { $0.mayReadOrWriteMemory || $0.hasUnspecifiedSideEffects }) {
+    if callee.instructions.contains(where: hasSideEffectForBuiltinOnce) {
       return
     }
     context.erase(instruction: self)
@@ -133,6 +133,16 @@ private extension BuiltinInst {
   }
 }
 
+private func hasSideEffectForBuiltinOnce(_ instruction: Instruction) -> Bool {
+  switch instruction {
+  case is DebugStepInst, is DebugValueInst:
+    return false
+  default:
+    return instruction.mayReadOrWriteMemory ||
+           instruction.hasUnspecifiedSideEffects
+  }
+}
+
 private func typesOfValuesAreEqual(_ lhs: Value, _ rhs: Value, in function: Function) -> Bool? {
   if lhs == rhs {
     return true

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/init_static_globals.sil

@@ -31,6 +31,11 @@ struct GenericStruct<T> {
   var x: T
 }
 
+struct TwoFields {
+  let a: Int32
+  let b: Int32
+}
+
 let nontrivialglobal: TClass
 
 // CHECK-LABEL: sil_global hidden [let] @$trivialglobal : $TStruct = {
@@ -74,6 +79,17 @@ sil_global private @g3_token : $Builtin.Word
 sil_global [let] @g4 : $Optional<UnsafeMutablePointer<Int>>
 sil_global private @g4_token : $Builtin.Word
 
+// CHECK-LABEL: sil_global [let] @g5 : $TwoFields = {
+// CHECK-NEXT:    %0 = integer_literal $Builtin.Int32, 11
+// CHECK-NEXT:    %1 = struct $Int32 (%0 : $Builtin.Int32)
+// CHECK-NEXT:    %2 = integer_literal $Builtin.Int32, 10
+// CHECK-NEXT:    %3 = struct $Int32 (%2 : $Builtin.Int32)
+// CHECK-NEXT:    %initval = struct $TwoFields (%1 : $Int32, %3 : $Int32)
+// CHECK-NEXT:  }
+sil_global [let] @g5 : $TwoFields
+
+sil_global [let] @g6 : $TwoFields
+sil_global [let] @g7 : $TwoFields
 
 // CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_trivialglobal_func :
 // CHECK-NOT:     alloc_global
@@ -189,3 +205,44 @@ bb0:
   %10 = tuple ()
   return %10 : $()
 }
+
+// CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_separate_stores :
+// CHECK-NOT:     alloc_global
+// CHECK-NOT:     store
+// CHECK:       } // end sil function 'globalinit_separate_stores'
+sil [global_init_once_fn] [ossa] @globalinit_separate_stores : $@convention(c) () -> () {
+bb0:
+  alloc_global @g5
+  %1 = global_addr @g5 : $*TwoFields
+  %2 = integer_literal $Builtin.Int32, 10
+  %3 = struct $Int32 (%2 : $Builtin.Int32)
+  %4 = struct_element_addr %1 : $*TwoFields, #TwoFields.b
+  store %3 to [trivial] %4 : $*Int32
+  %6 = integer_literal $Builtin.Int32, 11
+  %7 = struct $Int32 (%6 : $Builtin.Int32)
+  %8 = struct_element_addr %1 : $*TwoFields, #TwoFields.a
+  store %7 to [trivial] %8 : $*Int32
+  %10 = tuple ()
+  return %10 : $()
+}
+
+// CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_wrong_separate_stores :
+// CHECK:         alloc_global
+// CHECK:         store
+// CHECK:         store
+// CHECK:       } // end sil function 'globalinit_wrong_separate_stores'
+sil [global_init_once_fn] [ossa] @globalinit_wrong_separate_stores : $@convention(c) () -> () {
+bb0:
+  alloc_global @g5
+  %1 = global_addr @g5 : $*TwoFields
+  %2 = integer_literal $Builtin.Int32, 10
+  %3 = struct $Int32 (%2 : $Builtin.Int32)
+  %4 = struct_element_addr %1 : $*TwoFields, #TwoFields.b
+  store %3 to [trivial] %4 : $*Int32
+  %6 = integer_literal $Builtin.Int32, 11
+  %7 = struct $Int32 (%6 : $Builtin.Int32)
+  store %7 to [trivial] %4 : $*Int32
+  %10 = tuple ()
+  return %10 : $()
+}
+

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
+}
+

test/SILOptimizer/simplify_builtin.sil

@@ -274,6 +274,8 @@ bb0:
   %1 = global_addr @g : $*Int32
   %2 = integer_literal $Builtin.Int32, 10
   %3 = struct $Int32 (%2 : $Builtin.Int32)
+  debug_step
+  debug_value %1 : $*Int32
   %6 = tuple ()
   return %6 : $()
 }