Merge pull request #67243 from kubamracek/section-ump

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

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -82,6 +82,8 @@ extension Instruction {
         return type.isBuiltinInteger || type.isBuiltinFloat
       case .PtrToInt:
         return bi.operands[0].value is StringLiteralInst
+      case .IntToPtr:
+        return bi.operands[0].value is IntegerLiteralInst
       case .StringObjectOr:
         // The first operand can be a string literal (i.e. a pointer), but the
         // second operand must be a constant. This enables creating a

lib/IRGen/GenConstant.cpp

@@ -302,6 +302,10 @@ Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
         auto *ptr = emitConstantValue(IGM, args[0]).claimNextConstant();
         return llvm::ConstantExpr::getPtrToInt(ptr, IGM.IntPtrTy);
       }
+      case BuiltinValueKind::IntToPtr: {
+        auto *num = emitConstantValue(IGM, args[0]).claimNextConstant();
+        return llvm::ConstantExpr::getIntToPtr(num, IGM.Int8PtrTy);
+      }
       case BuiltinValueKind::ZExtOrBitCast: {
         auto *val = emitConstantValue(IGM, args[0]).claimNextConstant();
         return llvm::ConstantExpr::getZExtOrBitCast(val,

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

@@ -66,6 +66,14 @@ sil_global private @g1_token : $Builtin.Word
 sil_global [let] @g2 : $Int32
 sil_global private @g2_token : $Builtin.Word
 
+// CHECK-LABEL: sil_global [let] @g3 : $Optional<UnsafeMutablePointer<Int>>
+sil_global [let] @g3 : $Optional<UnsafeMutablePointer<Int>>
+sil_global private @g3_token : $Builtin.Word
+
+// CHECK-LABEL: sil_global [let] @g4 : $Optional<UnsafeMutablePointer<Int>>
+sil_global [let] @g4 : $Optional<UnsafeMutablePointer<Int>>
+sil_global private @g4_token : $Builtin.Word
+
 
 // CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_trivialglobal_func :
 // CHECK-NOT:     alloc_global
@@ -151,3 +159,33 @@ bb0:
   return %6 : $()
 }
 
+// CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_enum :
+// CHECK-NOT:     alloc_global
+// CHECK-NOT:     store
+// CHECK:       } // end sil function 'globalinit_enum'
+sil [global_init_once_fn] [ossa] @globalinit_enum : $@convention(c) () -> () {
+bb0:
+  alloc_global @g3
+  %2 = global_addr @g3 : $*Optional<UnsafeMutablePointer<Int>>
+  %3 = enum $Optional<UnsafeMutablePointer<Int>>, #Optional.none!enumelt
+  store %3 to [trivial] %2 : $*Optional<UnsafeMutablePointer<Int>>
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// CHECK-LABEL: sil [global_init_once_fn] [ossa] @globalinit_enum_inttoptr :
+// CHECK-NOT:     alloc_global
+// CHECK-NOT:     store
+// CHECK:       } // end sil function 'globalinit_enum_inttoptr'
+sil [global_init_once_fn] [ossa] @globalinit_enum_inttoptr : $@convention(c) () -> () {
+bb0:
+  alloc_global @g4
+  %2 = global_addr @g4 : $*Optional<UnsafeMutablePointer<Int>>
+  %4 = integer_literal $Builtin.Word, 1111638594
+  %5 = builtin "inttoptr_Word"(%4 : $Builtin.Word) : $Builtin.RawPointer
+  %6 = struct $UnsafeMutablePointer<Int> (%5 : $Builtin.RawPointer)
+  %7 = enum $Optional<UnsafeMutablePointer<Int>>, #Optional.some!enumelt, %6 : $UnsafeMutablePointer<Int>
+  store %7 to [trivial] %2 : $*Optional<UnsafeMutablePointer<Int>>
+  %10 = tuple ()
+  return %10 : $()
+}

test/SILOptimizer/optimize_keypath.swift

@@ -5,7 +5,7 @@
 
 // RUN: %target-build-swift -O %s -o %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
-// REQUIRES: executable_test,swift_stdlib_no_asserts,optimized_stdlib
+// REQUIRES: executable_test,optimized_stdlib
 // REQUIRES: CPU=arm64 || CPU=x86_64
 
 // REQUIRES: swift_in_compiler
@@ -388,9 +388,8 @@ func testClassMemberComputedModify<T : P>(_ s: inout GenClass<T>) {
 // CHECK: [[F:%[0-9]+]] = select_enum [[O:%[0-9]+]]
 // CHECK: cond_fail [[F]]
 // CHECK: unchecked_enum_data [[O]]
-// CHECK: [[E2:%[0-9]+]] = init_enum_data_addr [[E1:%[0-9]+]]
-// CHECK: store {{%[0-9]+}} to [[E2]]
-// CHECK: inject_enum_addr [[E1]]
+// CHECK: [[E2:%[0-9]+]] = enum $Optional<SimpleStruct.Nested>
+// CHECK: store [[E2]] to {{%[0-9]+}}
 // CHECK: return
 @inline(never)
 @_semantics("optimize.sil.specialize.generic.never")
@@ -405,9 +404,8 @@ func testModifyOptionalForce(_ s: inout SimpleStruct) {
 // CHECK: [[F:%[0-9]+]] = select_enum
 // CHECK: cond_fail [[F]]
 // CHECK: unchecked_enum_data [[E1:%[0-9]+]]
-// CHECK: [[E2:%[0-9]+]] = init_enum_data_addr [[E1:%[0-9]+]]
-// CHECK: store {{%[0-9]+}} to [[E2]]
-// CHECK: inject_enum_addr [[E1]]
+// CHECK: [[E2:%[0-9]+]] = enum $Optional<SimpleClass.Nested>
+// CHECK: store [[E2]] to {{%[0-9]+}}
 // CHECK: end_access
 // CHECK: return
 @inline(never)

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