SimplifyDestructure: canonicalize destructure_tuple and destructure_struct for trivial tuples/structs

Replace destructure_tuple with tuple_extract instructions and destructure_struct with struct_extract instructions.
This canonicalization helps other optimizations to e.g. CSE tuple_extract/struct_extract.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyDestructure.swift

@@ -15,6 +15,21 @@ import SIL
 extension DestructureTupleInst : OnoneSimplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
 
+    // If the tuple is trivial, replace
+    // ```
+    //   (%1, %2) = destructure_tuple %t
+    // ```
+    // ->
+    // ```
+    //   %1 = tuple_extract %t, 0
+    //   %2 = tuple_extract %t, 1
+    // ```
+    // This canonicalization helps other optimizations to e.g. CSE tuple_extracts.
+    //
+    if replaceWithTupleExtract(context) {
+      return
+    }
+
     // Eliminate the redundant instruction pair
     // ```
     //   %t = tuple (%0, %1, %2)
@@ -26,11 +41,39 @@ extension DestructureTupleInst : OnoneSimplifyable, SILCombineSimplifyable {
       tryReplaceConstructDestructPair(construct: tuple, destruct: self, context)
     }
   }
+
+  private func replaceWithTupleExtract(_ context: SimplifyContext) -> Bool {
+    guard self.tuple.type.isTrivial(in: parentFunction) else {
+      return false
+    }
+    let builder = Builder(before: self, context)
+    for (elementIdx, result) in results.enumerated() {
+      let elementValue = builder.createTupleExtract(tuple: self.tuple, elementIndex: elementIdx)
+      result.uses.replaceAll(with: elementValue, context)
+    }
+    context.erase(instruction: self)
+    return true
+  }
 }
 
 extension DestructureStructInst : OnoneSimplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
 
+    // If the struct is trivial, replace
+    // ```
+    //   (%1, %2) = destructure_struct %s
+    // ```
+    // ->
+    // ```
+    //   %1 = struct_extract %s, #S.field0
+    //   %2 = struct_extract %s, #S.field1
+    // ```
+    // This canonicalization helps other optimizations to e.g. CSE tuple_extracts.
+    //
+    if replaceWithStructExtract(context) {
+      return
+    }
+
     switch self.struct {
     case let str as StructInst:
       // Eliminate the redundant instruction pair
@@ -82,6 +125,19 @@ extension DestructureStructInst : OnoneSimplifyable, SILCombineSimplifyable {
       break
     }
   }
+
+  private func replaceWithStructExtract(_ context: SimplifyContext) -> Bool {
+    guard self.struct.type.isTrivial(in: parentFunction) else {
+      return false
+    }
+    let builder = Builder(before: self, context)
+    for (fieldIdx, result) in results.enumerated() {
+      let fieldValue = builder.createStructExtract(struct: self.struct, fieldIndex: fieldIdx)
+      result.uses.replaceAll(with: fieldValue, context)
+    }
+    context.erase(instruction: self)
+    return true
+  }
 }
 
 private func tryReplaceConstructDestructPair(construct: SingleValueInstruction,

test/SILOptimizer/simplify_destructure_struct.sil

@@ -11,8 +11,13 @@ struct S {
   @_hasStorage let b: Int
 }
 
+struct TrivialS {
+  @_hasStorage let a: Int
+  @_hasStorage let b: Int
+}
+
 // CHECK-LABEL: sil [ossa] @forward_owned :
-// CHECK-NOT:     destructure_tuple
+// CHECK-NOT:     destructure_struct
 // CHECK:         fix_lifetime %1
 // CHECK:         return %0
 // CHECK:       } // end sil function 'forward_owned'
@@ -141,3 +146,15 @@ bb2:
   return %4 : $String
 }
 
+// CHECK-LABEL: sil [ossa] @to_struct_extract :
+// CHECK:         %1 = struct_extract %0 : $TrivialS, #TrivialS.a
+// CHECK:         %2 = struct_extract %0 : $TrivialS, #TrivialS.b
+// CHECK:         %3 = tuple (%1 : $Int, %2 : $Int)
+// CHECK:       } // end sil function 'to_struct_extract'
+sil [ossa] @to_struct_extract : $@convention(thin) (TrivialS) -> (Int, Int) {
+bb0(%0 : $TrivialS):
+  (%1, %2) = destructure_struct %0
+  %3 = tuple (%1, %2)
+  return %3
+}
+

test/SILOptimizer/simplify_destructure_tuple.sil

@@ -6,6 +6,11 @@
 import Swift
 import Builtin
 
+struct TrivialS {
+  @_hasStorage let a: Int
+  @_hasStorage let b: Int
+}
+
 // CHECK-LABEL: sil [ossa] @forward_owned :
 // CHECK-NOT:     destructure_tuple
 // CHECK:         fix_lifetime %1
@@ -65,3 +70,15 @@ bb0(%0 : @owned $String, %1 : $Int):
   return %4 : $String
 }
 
+// CHECK-LABEL: sil [ossa] @to_tuple_extract :
+// CHECK:         %1 = tuple_extract %0 : $(Int, Int), 0
+// CHECK:         %2 = tuple_extract %0 : $(Int, Int), 1
+// CHECK:         %3 = struct $TrivialS (%1 : $Int, %2 : $Int)
+// CHECK:       } // end sil function 'to_tuple_extract'
+sil [ossa] @to_tuple_extract : $@convention(thin) ((Int, Int)) -> TrivialS {
+bb0(%0 : $(Int, Int)):
+  (%1, %2) = destructure_tuple %0
+  %3 = struct $TrivialS (%1, %2)
+  return %3
+}
+