InitializeStaticGlobals: add a peephole to merge element stores to a single store.

Sometimes structs are not stored in one piece, but as individual elements. Merge such individual stores to a single store of the whole struct.
This enables generating a statically initialized global.

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

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 : $()
+}
+