InitializeStaticGlobals: support initializing globals with @_rawLayout types, like Atomic

Look through `@_rawLayout` projections, which "type casts" a raw-layout struct to it's content, which must match the like-type of the raw-layout, e.g.

```
@_rawLayout(like: T)
struct S {}

  %2 = builtin "addressOfRawLayout"<S>(%1 : $*S) : $Builtin.RawPointer
  %3 = pointer_to_address %2 to $*T
```

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -358,7 +358,7 @@ private struct InitValueBuilder: AddressDefUseWalker {
   mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
     switch address.instruction {
     case let store as StoreInst:
-      let accessPath = store.destination.constantAccessPath
+      let accessPath = store.destination.lookThroughRawLayoutAddress.constantAccessPath
       switch accessPath.base {
       case .global, .stack:
         if !initValue.setElement(to: store.source, at: accessPath.projectionPath, type: originalAddress.type) {
@@ -385,8 +385,18 @@ private struct InitValueBuilder: AddressDefUseWalker {
       }
     case is LoadInst, is DeallocStackInst:
       return .continueWalk
-    case let bi as BuiltinInst where bi.id == .PrepareInitialization:
-      return .continueWalk
+    case let bi as BuiltinInst:
+      switch bi.id {
+      case .PrepareInitialization:
+        return .continueWalk
+      case .AddressOfRawLayout:
+        if let addr2Ptr = bi.uses.getSingleUser(ofType: PointerToAddressInst.self) {
+          return walkDownUses(ofAddress: addr2Ptr, path: path)
+        }
+        return .abortWalk
+      default:
+        return .abortWalk
+      }
     default:
       return .abortWalk
     }
@@ -466,14 +476,7 @@ private extension Function {
       case let alloc as AllocGlobalInst where alloc.global == global:
         return false
       case let store as StoreInst:
-        switch store.destination.accessBase {
-        case .global(let g) where g == global:
-          return false
-        case .stack:
-          return false
-        default:
-          return true
-        }
+        return !store.destination.lookThroughRawLayoutAddress.isAddressOfStack(orGlobal: global)
       case let bi as BuiltinInst where bi.id == .PrepareInitialization:
         return false
       default:
@@ -496,3 +499,37 @@ private extension Function {
     context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: self)
   }
 }
+
+private extension Value {
+  func isAddressOfStack(orGlobal global: GlobalVariable) -> Bool {
+    switch accessBase {
+    case .global(let g) where g == global:
+      return true
+    case .stack:
+      return true
+    default:
+      return false
+    }
+  }
+
+  /// Looks through a `@_rawLayout` projection, which "type casts" a raw-layout struct to it's content, which
+  /// must match the like-type of the raw-layout, e.g.
+  /// ```
+  /// @_rawLayout(like: T)
+  /// struct S {}
+  ///
+  ///   %2 = builtin "addressOfRawLayout"<S>(%1 : $*S) : $Builtin.RawPointer
+  ///   %3 = pointer_to_address %2 to $*T
+  /// ```
+  var lookThroughRawLayoutAddress: Value {
+    if let ptr2Addr = self as? PointerToAddressInst,
+       let builtin = ptr2Addr.pointer as? BuiltinInst, builtin.id == .AddressOfRawLayout,
+       let likeType = builtin.arguments[0].type.rawLayoutSubstitutedLikeType,
+       builtin.arguments[0].type.rawLayoutSubstitutedCountType == nil,
+       likeType.canonical == type.canonicalType
+    {
+      return builtin.arguments[0]
+    }
+    return self
+  }
+}

test/SILOptimizer/init_static_globals.sil

@@ -1,6 +1,7 @@
-// RUN: %target-sil-opt -enable-sil-verify-all %s -initialize-static-globals | %FileCheck %s
+// RUN: %target-sil-opt -enable-sil-verify-all %s -enable-experimental-feature RawLayout -initialize-static-globals | %FileCheck %s
 
 // REQUIRES: swift_in_compiler
+// REQUIRES: swift_feature_RawLayout
 
 sil_stage canonical
 
@@ -36,6 +37,12 @@ struct TwoFields {
   let b: Int32
 }
 
+@_rawLayout(like: Int32)
+struct Raw: ~Copyable {}
+
+@_rawLayout(likeArrayOf: Int32, count: 2)
+struct RawArray: ~Copyable {}
+
 let nontrivialglobal: TClass
 
 // CHECK-LABEL: sil_global hidden [let] @$trivialglobal : $TStruct = {
@@ -149,6 +156,18 @@ sil_global [let] @inline_array_empty_elements : $InlineArray<3, ()>
 // CHECK-NEXT:  }
 sil_global [let] @gint : $Int32
 
+// CHECK-LABEL: sil_global [let] @graw : $Raw = {
+// CHECK-NEXT:    %0 = integer_literal $Builtin.Int32, 1
+// CHECK-NEXT:    %initval = struct $Int32 (%0)
+// CHECK-NEXT:  }
+sil_global [let] @graw: $Raw
+
+// CHECK-LABEL: sil_global [let] @graw2 : $Raw{{$}}
+sil_global [let] @graw2: $Raw
+
+// CHECK-LABEL: sil_global [let] @grawArray : $RawArray{{$}}
+sil_global [let] @grawArray: $RawArray
+
 sil @unknownfunc : $@convention(thin) () -> ()
 
 // CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_trivialglobal_func :
@@ -521,3 +540,42 @@ bb0(%0 : $Builtin.RawPointer):
   return %21
 }
 
+sil [global_init_once_fn] [ossa] @globalinit_raw_layout: $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @graw
+  %2 = global_addr @graw : $*Raw
+  %3 = integer_literal $Builtin.Int32, 1
+  %4 = struct $Int32 (%3)
+  %5 = builtin "addressOfRawLayout"<Raw>(%2) : $Builtin.RawPointer
+  %6 = pointer_to_address %5 to $*Int32
+  store %4 to [trivial] %6
+  %21 = tuple ()
+  return %21
+}
+
+sil [global_init_once_fn] [ossa] @no_globalinit_raw_layout_wrong_like_type: $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @graw
+  %2 = global_addr @graw : $*Raw
+  %3 = integer_literal $Builtin.Int16, 1
+  %4 = struct $Int16 (%3)
+  %5 = builtin "addressOfRawLayout"<Raw>(%2) : $Builtin.RawPointer
+  %6 = pointer_to_address %5 to $*Int16
+  store %4 to [trivial] %6
+  %21 = tuple ()
+  return %21
+}
+
+sil [global_init_once_fn] [ossa] @no_globalinit_raw_layout_array: $@convention(c) (Builtin.RawPointer) -> () {
+bb0(%0 : $Builtin.RawPointer):
+  alloc_global @grawArray
+  %2 = global_addr @grawArray : $*RawArray
+  %3 = integer_literal $Builtin.Int32, 1
+  %4 = struct $Int32 (%3)
+  %5 = builtin "addressOfRawLayout"<RawArray>(%2) : $Builtin.RawPointer
+  %6 = pointer_to_address %5 to $*Int32
+  store %4 to [trivial] %6
+  %21 = tuple ()
+  return %21
+}
+