Optimizer: add simplification for the value_to_bridge_object instruction

This comes up in the code for constructing an empty string literal.
With this optimization it's possible to statically initialize empty string global variables.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -21,4 +21,5 @@ swift_compiler_sources(Optimizer
   SimplifyStrongRetainRelease.swift
   SimplifyStructExtract.swift
   SimplifyTupleExtract.swift
-  SimplifyUncheckedEnumData.swift)
+  SimplifyUncheckedEnumData.swift
+  SimplifyValueToBridgeObject.swift)

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyValueToBridgeObject.swift

@@ -0,0 +1,38 @@
+//===--- SimplifyValueToBridgeObject.swift --------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension ValueToBridgeObjectInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Optimize the sequence
+    // ```
+    //   %1 = value_to_bridge_object %0
+    //   %2 = struct $SomeInt (%1)
+    //   %3 = unchecked_trivial_bit_cast %2
+    //   %4 = struct_extract %3, #valueFieldInInt
+    //   %5 = value_to_bridge_object %4
+    // ```
+    // to
+    // ```
+    //   %5 = value_to_bridge_object %0
+    // ```
+    // This sequence comes up in the code for constructing an empty string literal.
+    //
+    if let se = self.value as? StructExtractInst,
+       let utbc = se.struct as? UncheckedTrivialBitCastInst,
+       let vtbo = utbc.fromValue as? ValueToBridgeObjectInst {
+      self.operand.set(to: vtbo.value, context)
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -388,6 +388,10 @@ final public class UncheckedAddrCastInst : SingleValueInstruction, UnaryInstruct
   public var fromAddress: Value { operand.value }
 }
 
+final public class UncheckedTrivialBitCastInst : SingleValueInstruction, UnaryInstruction {
+  public var fromValue: Value { operand.value }
+}
+
 final public
 class RawPointerToRefInst : SingleValueInstruction, UnaryInstruction {
   public var pointer: Value { operand.value }
@@ -626,7 +630,9 @@ final public
 class ObjCMetatypeToObjectInst : SingleValueInstruction, UnaryInstruction {}
 
 final public
-class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {}
+class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {
+  public var value: Value { return operand.value }
+}
 
 final public
 class MarkDependenceInst : SingleValueInstruction {

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -77,6 +77,7 @@ public func registerSILClasses() {
   register(UpcastInst.self)
   register(UncheckedRefCastInst.self)
   register(UncheckedAddrCastInst.self)
+  register(UncheckedTrivialBitCastInst.self)
   register(MarkMustCheckInst.self)
   register(ObjectInst.self)
   register(RawPointerToRefInst.self)

test/SILOptimizer/simplify_value_to_bridge_object.sil

@@ -0,0 +1,36 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -onone-simplification -simplify-instruction=value_to_bridge_object | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+import Swift
+import Builtin
+
+// CHECK-LABEL: sil @empty_string_literal_sequence
+// CHECK:         %1 = value_to_bridge_object %0
+// CHECK:         return %1
+// CHECK:       } // end sil function 'empty_string_literal_sequence'
+sil @empty_string_literal_sequence : $@convention(thin) (Builtin.Int64) -> Builtin.BridgeObject {
+bb0(%0 : $Builtin.Int64):
+  %1 = value_to_bridge_object %0 : $Builtin.Int64
+  %2 = unchecked_trivial_bit_cast %1 : $Builtin.BridgeObject to $UInt64
+  %3 = struct_extract %2 : $UInt64, #UInt64._value
+  %4 = value_to_bridge_object %3 : $Builtin.Int64
+  return %4 : $Builtin.BridgeObject
+}
+
+// CHECK-LABEL: sil [ossa] @keep_both_vtbo_instructions
+// CHECK:         %1 = value_to_bridge_object %0
+// CHECK:         %2 = value_to_bridge_object %0
+// CHECK:         %3 = tuple (%1 : $Builtin.BridgeObject, %2 : $Builtin.BridgeObject)
+// CHECK:         return %3
+// CHECK:       } // end sil function 'keep_both_vtbo_instructions'
+sil [ossa] @keep_both_vtbo_instructions : $@convention(thin) (Builtin.Int64) -> (Builtin.BridgeObject, Builtin.BridgeObject) {
+bb0(%0 : $Builtin.Int64):
+  %1 = value_to_bridge_object %0 : $Builtin.Int64
+  %2 = unchecked_trivial_bit_cast %1 : $Builtin.BridgeObject to $UInt64
+  %3 = struct_extract %2 : $UInt64, #UInt64._value
+  %4 = value_to_bridge_object %3 : $Builtin.Int64
+  %5 = tuple (%1 : $Builtin.BridgeObject, %4 : $Builtin.BridgeObject)
+  return %5 : $(Builtin.BridgeObject, Builtin.BridgeObject)
+}
+

test/SILOptimizer/static_strings.swift

@@ -19,6 +19,8 @@ public struct S {
   public static let largestr = "abc123asd3sdj3basfasdf"
   // CHECK: {{^@"}}[[UNICODE:.*unicodestr.*pZ]]" ={{.*}} global {{.*}} inttoptr {{.*}} add
   public static let unicodestr = "❄️gastroperiodyni"
+  // CHECK: {{^@"}}[[EMPTY:.*emptystr.*pZ]]" ={{.*}} global {{.*}} inttoptr
+  public static let emptystr = ""
 }
 
 // unsafeMutableAddressor for S.smallstr
@@ -57,6 +59,18 @@ public struct S {
 // CHECK-NEXT:   ret {{.*}}
 // CHECK-NEXT: }
 
+// unsafeMutableAddressor for S.emptystr
+// CHECK: define {{.*emptystr.*}}u"
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret {{.*}} @"[[EMPTY]]"
+// CHECK-NEXT: }
+
+// getter for S.emptystr
+// CHECK: define {{.*emptystr.*}}gZ"
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   ret {{.*}}
+// CHECK-NEXT: }
+
 // CHECK-LABEL: define {{.*}}get_smallstr
 // CHECK:      entry:
 // CHECK-NEXT:   ret {{.*}}
@@ -84,25 +98,38 @@ public func get_unicodestr() -> String {
   return S.unicodestr
 }
 
+// CHECK-LABEL: define {{.*}}get_emptystr
+// CHECK:      entry:
+// CHECK-NEXT:   ret {{.*}}
+// CHECK-NEXT: }
+@inline(never)
+public func get_emptystr() -> String {
+  return S.emptystr
+}
+
 // Also check if the generated code is correct.
 
 // CHECK-OUTPUT: abc123a
 // CHECK-OUTPUT: abc123asd3sdj3basfasdf
 // CHECK-OUTPUT: ❄️gastroperiodyni
+// CHECK-OUTPUT: <>
 print(get_smallstr())
 print(get_largestr())
 print(get_unicodestr())
+print("<\(get_emptystr())>")
 
 // Really load the globals from their addresses.
 @_optimize(none)
 func print_strings_from_addressors() {
   print(S.smallstr)
   print(S.largestr)
   print(S.unicodestr)
+  print("<\(S.emptystr)>")
 }
 
 // CHECK-OUTPUT: abc123a
 // CHECK-OUTPUT: abc123asd3sdj3basfasdf
 // CHECK-OUTPUT: ❄️gastroperiodyni
+// CHECK-OUTPUT: <>
 print_strings_from_addressors()