Enhance enum simplifications in SILOptimizer to allow forced constant-folding of global initializers to work on UnsafeMutablePointer types

Author: kubamracek

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyInitEnumDataAddr.swift

@@ -18,6 +18,7 @@ extension InitEnumDataAddrInst : OnoneSimplifyable {
     // Optimize the sequence
     // ```
     //   %1 = init_enum_data_addr %enum_addr, #someCaseWithPayload
+    //   ...
     //   store %payload to %1
     //   inject_enum_addr %enum_addr, #someCaseWithPayload
     // ```
@@ -26,18 +27,16 @@ extension InitEnumDataAddrInst : OnoneSimplifyable {
     //   %1 = enum  $E, #someCaseWithPayload, %payload
     //   store %1 to %enum_addr
     // ```
-    // This sequence of three instructions must appear in consecutive order.
+    // This store and inject instructions must appear in consecutive order.
     // But usually this is the case, because it's generated this way by SILGen.
+    // We also check that between the init and the store, no instruction writes to memory.
     //
-    if let nextInst = self.next,
-       let store = nextInst as? StoreInst,
+    if let store = self.uses.singleUse?.instruction as? StoreInst,
        store.destination == self,
-       let singleUse = self.uses.singleUse,
-       singleUse.instruction == store,
-       let nextAfterStore = store.next,
-       let inject = nextAfterStore as? InjectEnumAddrInst,
+       let inject = store.next as? InjectEnumAddrInst,
        inject.enum == self.enum,
-       inject.enum.type.isLoadable(in: parentFunction) {
+       inject.enum.type.isLoadable(in: parentFunction),
+       !anyInstructionMayWriteToMemory(between: self, and: store) {
 
       assert(self.caseIndex == inject.caseIndex, "mismatching case indices when creating an enum")
 
@@ -51,3 +50,19 @@ extension InitEnumDataAddrInst : OnoneSimplifyable {
     }
   }
 }
+
+// Returns false if `first` and `last` are in the same basic block and no instructions between them write to memory. True otherwise.
+private func anyInstructionMayWriteToMemory(between first: Instruction, and last: Instruction) -> Bool {
+  var nextInstruction = first.next
+  while let i = nextInstruction {
+    if i == last {
+      return false
+    }
+    if i.mayWriteToMemory {
+      return true
+    }
+    nextInstruction = i.next
+  }
+  // End of basic block, and we did not find `last`
+  return true
+}

test/IRGen/section.swift

@@ -8,11 +8,16 @@
 @_section("__TEXT,__mysection") var g1: (Int, Int) = (42, 43)
 @_section("__TEXT,__mysection") var g2: Bool = true
 @_section("__TEXT,__mysection") public var g3: Bool = true
+@_section("__TEXT,__mysection") var g4: UnsafeMutablePointer<Int>? = nil
+@_section("__TEXT,__mysection") var g5: UnsafeMutablePointer<Int>? = UnsafeMutablePointer(bitPattern: 0x42424242)
 @_section("__TEXT,__mysection") func foo() {}
 
 // SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue var g0: Int { get set }
 // SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue var g1: (Int, Int) { get set }
 // SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue var g2: Bool { get set }
+// SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue public var g3: Bool { get set }
+// SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue var g4: UnsafeMutablePointer<Int>? { get set }
+// SIL: @_section("__TEXT,__mysection") @_hasStorage @_hasInitialValue var g5: UnsafeMutablePointer<Int>? { get set }
 // SIL: @_section("__TEXT,__mysection") func foo()
 // SIL: sil private [global_init_once_fn] @$s7section2g0_WZ : $@convention(c)
 // SIL: sil hidden [global_init] @$s7section2g0Sivau : $@convention(thin)
@@ -22,6 +27,10 @@
 // SIL: sil hidden [global_init] @$s7section2g2Sbvau : $@convention(thin)
 // SIL: sil private [global_init_once_fn] @$s7section2g3_WZ : $@convention(c)
 // SIL: sil [global_init] @$s7section2g3Sbvau : $@convention(thin)
+// SIL: sil private [global_init_once_fn] @$s7section2g4_WZ : $@convention(c)
+// SIL: sil hidden [global_init] @$s7section2g4SpySiGSgvau : $@convention(thin)
+// SIL: sil private [global_init_once_fn] @$s7section2g5_WZ : $@convention(c)
+// SIL: sil hidden [global_init] @$s7section2g5SpySiGSgvau : $@convention(thin)
 // SIL: sil hidden [section "__TEXT,__mysection"] @$s7section3fooyyF : $@convention(thin)
 
 // IR:  @"$s7section2g0_Wz" = internal global {{(i64|i32)}} 0
@@ -32,6 +41,10 @@
 // IR:  @"$s7section2g2Sbvp" = hidden global %TSb <{ i1 true }>, section "__TEXT,__mysection"
 // IR:  @"$s7section2g3_Wz" = internal global {{(i64|i32)}} 0
 // IR:  @"$s7section2g3Sbvp" = {{.*}}global %TSb <{ i1 true }>, section "__TEXT,__mysection"
+// IR:  @"$s7section2g4_Wz" = internal global {{i64|i32}} 0
+// IR:  @"$s7section2g4SpySiGSgvp" = hidden global {{i64|i32}} 0, section "__TEXT,__mysection"
+// IR:  @"$s7section2g5_Wz" = internal global {{i64|i32}} 0
+// IR:  @"$s7section2g5SpySiGSgvp" = hidden global {{i64|i32}} 1111638594, section "__TEXT,__mysection"
 // IR:  define {{.*}}@"$s7section3fooyyF"(){{.*}} section "__TEXT,__mysection"
 
 // ASM: .section{{.*}}__TEXT,__mysection
@@ -46,3 +59,7 @@
 // ASM: $s7section2g2Sbvp:
 // ASM-NOT: .section
 // ASM: $s7section2g3Sbvp:
+// ASM-NOT: .section
+// ASM: $s7section2g4SpySiGSgvp:
+// ASM-NOT: .section
+// ASM: $s7section2g5SpySiGSgvp:

test/IRGen/section_non_const.swift

@@ -75,3 +75,6 @@ struct MyStruct6 {
     }
 }
 @_section("__TEXT,__mysection") var g_MyStruct6: MyStruct6 = MyStruct6(a: 42) // expected-error {{global variable must be a compile-time constant to use @_section attribute}}
+
+@_section("__TEXT,__mysection") var gp1: UnsafeMutablePointer<Int>? = nil
+@_section("__TEXT,__mysection") var gp2: UnsafeMutablePointer<Int>? = UnsafeMutablePointer(bitPattern: 0x42424242)

test/SILOptimizer/simplify_init_enum_data_addr.sil

@@ -10,10 +10,6 @@ enum E {
   case B(AnyObject)
 }
 
-enum GenE<T> {
-  case A(Int)
-  case B(T)
-}
 // CHECK-LABEL: sil @optional_int
 // CHECK:         %2 = enum $Optional<Int>, #Optional.some!enumelt, %1 : $Int
 // CHECK:         store %2 to %0 : $*Optional<Int>
@@ -59,6 +55,11 @@ bb0(%0 : $*E, %1 : $Int):
   return %5 : $()
 }
 
+enum GenE<T> {
+  case A(Int)
+  case B(T)
+}
+
 // CHECK-LABEL: sil [ossa] @not_loadable
 // CHECK:         %2 = init_enum_data_addr
 // CHECK:         store %1 to [trivial] %2
@@ -73,3 +74,24 @@ bb0(%0 : $*GenE<T>, %1 : $Int):
   return %5 : $()
 }
 
+enum F {
+  case A(UnsafeMutableRawPointer)
+  case B(AnyObject)
+}
+
+// CHECK-LABEL: sil [ossa] @enum_data_addr
+// CHECK:         %2 = struct $UnsafeMutableRawPointer (%1 : $Builtin.RawPointer)
+// CHECK:         %3 = enum $F, #F.A!enumelt, %2 : $UnsafeMutableRawPointer
+// CHECK:         store %3 to [init] %0 : $*F
+// CHECK:         %5 = tuple ()
+// CHECK:         return %5
+// CHECK:       } // end sil function 'enum_data_addr'
+sil [ossa] @enum_data_addr : $@convention(thin) (Builtin.RawPointer) -> @out F {
+bb0(%0 : $*F, %1 : $Builtin.RawPointer):
+  %2 = init_enum_data_addr %0 : $*F, #F.A!enumelt
+  %3 = struct $UnsafeMutableRawPointer (%1 : $Builtin.RawPointer)
+  store %3 to [trivial] %2 : $*UnsafeMutableRawPointer
+  inject_enum_addr %0 : $*F, #F.A!enumelt
+  %6 = tuple ()
+  return %6 : $()
+}