Optimizer: add simplification for init_enum_data_addr

Optimize the sequence
```
  %1 = init_enum_data_addr %enum_addr, #someCaseWithPayload
  store %payload to %1
  inject_enum_addr %enum_addr, #someCaseWithPayload
```
to
```
  %1 = enum  $E, #someCaseWithPayload, %payload
  store %1 to %enum_addr
```
This sequence of three instructions must appear in consecutive order.
But usually this is the case, because it's generated this way by SILGen.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -16,6 +16,7 @@ swift_compiler_sources(Optimizer
   SimplifyDebugStep.swift
   SimplifyDestructure.swift
   SimplifyGlobalValue.swift
+  SimplifyInitEnumDataAddr.swift
   SimplifyLoad.swift
   SimplifyPartialApply.swift
   SimplifyStrongRetainRelease.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyInitEnumDataAddr.swift

@@ -0,0 +1,53 @@
+//===--- SimplifyInitEnumDataAddr.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 InitEnumDataAddrInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Optimize the sequence
+    // ```
+    //   %1 = init_enum_data_addr %enum_addr, #someCaseWithPayload
+    //   store %payload to %1
+    //   inject_enum_addr %enum_addr, #someCaseWithPayload
+    // ```
+    // to
+    // ```
+    //   %1 = enum  $E, #someCaseWithPayload, %payload
+    //   store %1 to %enum_addr
+    // ```
+    // This sequence of three instructions must appear in consecutive order.
+    // But usually this is the case, because it's generated this way by SILGen.
+    //
+    if let nextInst = self.next,
+       let store = nextInst as? StoreInst,
+       store.destination == self,
+       let singleUse = self.uses.singleUse,
+       singleUse.instruction == store,
+       let nextAfterStore = store.next,
+       let inject = nextAfterStore as? InjectEnumAddrInst,
+       inject.enum == self.enum,
+       inject.enum.type.isLoadable(in: parentFunction) {
+
+      assert(self.caseIndex == inject.caseIndex, "mismatching case indices when creating an enum")
+
+      let builder = Builder(before: store, context)
+      let enumInst = builder.createEnum(caseIndex: self.caseIndex, payload: store.source, enumType: self.enum.type.objectType)
+      let storeOwnership = StoreInst.Ownership(for: self.enum.type, in: parentFunction, initialize: true)
+      builder.createStore(source: enumInst, destination: self.enum, ownership: storeOwnership)
+      context.erase(instruction: store)
+      context.erase(instruction: inject)
+      context.erase(instruction: self)
+    }
+  }
+}

test/SILOptimizer/simplify_init_enum_data_addr.sil

@@ -0,0 +1,75 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -onone-simplification -simplify-instruction=init_enum_data_addr | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+import Swift
+import Builtin
+
+enum E {
+  case A(Int)
+  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>
+// CHECK:         %4 = tuple ()
+// CHECK:         return %4
+// CHECK:       } // end sil function 'optional_int'
+sil @optional_int : $@convention(thin) (Int) -> @out Optional<Int> {
+bb0(%0 : $*Optional<Int>, %1 : $Int):
+  %2 = init_enum_data_addr %0 : $*Optional<Int>, #Optional.some!enumelt
+  store %1 to %2 : $*Int
+  inject_enum_addr %0 : $*Optional<Int>, #Optional.some!enumelt
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @ossa_trivial
+// CHECK:         %2 = enum $Optional<Int>, #Optional.some!enumelt, %1 : $Int
+// CHECK:         store %2 to [trivial] %0 : $*Optional<Int>
+// CHECK:         %4 = tuple ()
+// CHECK:         return %4
+// CHECK:       } // end sil function 'ossa_trivial'
+sil [ossa] @ossa_trivial : $@convention(thin) (Int) -> @out Optional<Int> {
+bb0(%0 : $*Optional<Int>, %1 : $Int):
+  %2 = init_enum_data_addr %0 : $*Optional<Int>, #Optional.some!enumelt
+  store %1 to [trivial] %2 : $*Int
+  inject_enum_addr %0 : $*Optional<Int>, #Optional.some!enumelt
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @ossa_nontrivial
+// CHECK:         %2 = enum $E, #E.A!enumelt, %1 : $Int
+// CHECK:         store %2 to [init] %0 : $*E
+// CHECK:         %4 = tuple ()
+// CHECK:         return %4
+// CHECK:       } // end sil function 'ossa_nontrivial'
+sil [ossa] @ossa_nontrivial : $@convention(thin) (Int) -> @out E {
+bb0(%0 : $*E, %1 : $Int):
+  %2 = init_enum_data_addr %0 : $*E, #E.A!enumelt
+  store %1 to [trivial] %2 : $*Int
+  inject_enum_addr %0 : $*E, #E.A!enumelt
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// CHECK-LABEL: sil [ossa] @not_loadable
+// CHECK:         %2 = init_enum_data_addr
+// CHECK:         store %1 to [trivial] %2
+// CHECK:         inject_enum_addr
+// CHECK:       } // end sil function 'not_loadable'
+sil [ossa] @not_loadable : $@convention(thin) <T> (Int) -> @out GenE<T> {
+bb0(%0 : $*GenE<T>, %1 : $Int):
+  %2 = init_enum_data_addr %0 : $*GenE<T>, #GenE.A!enumelt
+  store %1 to [trivial] %2 : $*Int
+  inject_enum_addr %0 : $*GenE<T>, #GenE.A!enumelt
+  %5 = tuple ()
+  return %5 : $()
+}
+