SILOptimizer: Add destructure peepholes

```
 (%7, ...) = destructure_tuple %6 : $(A, ...)
 tuple_addr_constructor [assign] %9 : $*(A, ...) with (%7 : $A, ...)
   =>
 store [assign] %6 to %9
```

and

```
 (tuple (destructure_tuple %t))
  => %t
```

Author: aschwaighofer

lib/SILOptimizer/Mandatory/LowerTupleAddrConstructor.cpp

@@ -22,6 +22,54 @@ using namespace swift;
 
 namespace {
 
+static bool peepholeTupleDestructorOperand(TupleAddrConstructorInst *ctor) {
+
+  // (%7, ...) = destructure_tuple %6 : $(A, ...)
+  // tuple_addr_constructor [assign] %9 : $*(A, ...) with (%7 : $A, ...)
+  //   =>
+  // store [assign] %6 to %9
+
+  auto numTupleElts = ctor->getNumElements();
+  if (ctor->getNumElements() == 0)
+    return false;
+
+  auto multiVal = dyn_cast<MultipleValueInstructionResult>(ctor->getElement(0));
+  if (!multiVal) {
+    return false;
+  }
+  auto destructure = dyn_cast<DestructureTupleInst>(multiVal->getParent());
+  if (!destructure) {
+    return false;
+  }
+
+  if (destructure->getNumResults() != numTupleElts) {
+    return false;
+  }
+
+  for (unsigned i = 0; i < numTupleElts; ++i) {
+    if (destructure->getResult(i) != ctor->getElement(i)) {
+      return false;
+    }
+    if (!destructure->getResult(i)->getSingleUse()) {
+      return false;
+    }
+  }
+  if (ctor->getDest()->getType().getObjectType() !=
+      destructure->getOperand()->getType())
+    return false;
+
+  // Okay now we can peephole this to an assign.
+  SILBuilderWithScope b(ctor);
+  b.emitStoreValueOperation(ctor->getLoc(),
+                            destructure->getOperand(), ctor->getDest(),
+                            bool(ctor->isInitializationOfDest()) ?
+                              StoreOwnershipQualifier::Init
+                            : StoreOwnershipQualifier::Assign);
+  ctor->eraseFromParent();
+  destructure->eraseFromParent();
+  return true;
+}
+
 class LowerTupleAddrConstructorTransform : public SILFunctionTransform {
   void run() override {
     SILFunction *function = getFunction();
@@ -36,6 +84,14 @@ class LowerTupleAddrConstructorTransform : public SILFunctionTransform {
         if (!inst)
           continue;
 
+        // (tuple_addr_constructor [assign/init] %addr,
+        //                         (destructure_tuple %tuple))
+        // ->
+        // (store [assign/init] %tuple to %addr)
+        if (peepholeTupleDestructorOperand(inst)) {
+          continue;
+        }
+
         SILBuilderWithScope builder(inst);
 
         unsigned count = 0;

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -140,6 +140,7 @@ struct OwnershipModelEliminatorVisitor
   bool visitApplyInst(ApplyInst *ai);
 
   void splitDestroy(DestroyValueInst *destroy);
+  bool peepholeTupleConstructorUser(DestructureTupleInst *dti);
   bool visitDestroyValueInst(DestroyValueInst *dvi);
   bool visitDeallocBoxInst(DeallocBoxInst *dbi) {
     if (!dbi->isDeadEnd())
@@ -712,8 +713,50 @@ bool OwnershipModelEliminatorVisitor::visitDestructureStructInst(
   return true;
 }
 
+bool OwnershipModelEliminatorVisitor::peepholeTupleConstructorUser(DestructureTupleInst *dti) {
+  auto destructureResults = dti->getResults();
+  TupleInst *ti = nullptr;
+  for (unsigned index : indices(destructureResults)) {
+    SILValue result = destructureResults[index];
+    // We must have a single use of the destructure value.
+    auto *use = result->getSingleUse();
+    if (!use) {
+      ti = nullptr;
+      break;
+    }
+    // The user must be a single tuple constructor.
+    auto *tupleUsr = dyn_cast<TupleInst>(use->getUser());
+    if (!tupleUsr || (ti && ti != tupleUsr)) {
+      ti = nullptr;
+      break;
+    }
+    // Indices of destructure and tuple must match.
+    if (use->getOperandNumber() != index) {
+      ti = nullptr;
+      break;
+    }
+    ti = tupleUsr;
+  }
+  if (!ti)
+    return false;
+
+  if (ti->getType() != dti->getOperand()->getType())
+    return false;
+
+  ti->replaceAllUsesWith(dti->getOperand());
+  eraseInstruction(ti);
+  eraseInstruction(dti);
+  return true;
+}
+
 bool OwnershipModelEliminatorVisitor::visitDestructureTupleInst(
     DestructureTupleInst *dti) {
+
+  // (tuple (destructure)) -> (id)
+  if (peepholeTupleConstructorUser(dti)) {
+    return true;
+  }
+
   splitDestructure(dti, dti->getOperand());
   return true;
 }

test/SILOptimizer/ownership_model_eliminator.sil

@@ -20,6 +20,10 @@ struct PairOfInt {
   var rhs : Builtin.Int32
 }
 
+struct ContainsTuple {
+  var tuple : (Builtin.Int32, Builtin.Int32)
+}
+
 // CHECK-LABEL: sil @load : $@convention(thin) (@in Builtin.NativeObject, @in Builtin.Int32) -> () {
 // CHECK: bb0([[ARG1:%[0-9]+]] : $*Builtin.NativeObject, [[ARG2:%[0-9]+]] : $*Builtin.Int32):
 // CHECK: [[LOAD2:%[0-9]+]] = load [[ARG1]] : $*Builtin.NativeObject
@@ -456,3 +460,21 @@ exit:
   %retval = tuple ()
   return %retval : $()
 }
+
+// CHECK-LABEL: sil @destructure_tuple_peephole : $@convention(thin) (ContainsTuple) -> () {
+// CHECK: bb0([[ARG:%.*]] : $ContainsTuple):
+// CHECK:  [[S:%.*]] = alloc_stack $(Builtin.Int32, Builtin.Int32)
+// CHECK:  [[T:%.*]] = struct_extract [[ARG]] : $ContainsTuple, #ContainsTuple.tuple
+// CHECK:  store [[T]] to [[S]] : $*(Builtin.Int32, Builtin.Int32)
+// CHECK: } // end sil function 'destructure_tuple_peephole'
+sil [ossa] @destructure_tuple_peephole : $@convention(thin) (ContainsTuple) -> () {
+entry(%arg : $ContainsTuple):
+  %stk = alloc_stack $(Builtin.Int32, Builtin.Int32)
+  %tpl = struct_extract %arg : $ContainsTuple, #ContainsTuple.tuple
+  (%1, %2) = destructure_tuple %tpl : $(Builtin.Int32, Builtin.Int32)
+  %3 = tuple (%1 : $Builtin.Int32, %2 : $Builtin.Int32)
+  store %3 to [trivial] %stk : $*(Builtin.Int32, Builtin.Int32)
+  dealloc_stack %stk : $*(Builtin.Int32, Builtin.Int32)
+  %retval = tuple ()
+  return %retval : $()
+}

test/Serialization/transparent-std.swift

@@ -20,13 +20,10 @@ func test_foo(x: Builtin.Int1, y: Builtin.Int1) -> Builtin.Int1 {
 // SIL: [[TUP:%.*]] = tuple ([[ARG0]] : $Builtin.Int64, [[ARG1]] : $Builtin.NativeObject)
 // SIL: retain_value [[TUP]]
 // SIL: [[CASTED_PTR:%.*]] = pointer_to_address [[ARG2]]
-// SIL: [[CASTED_PTR_0:%.*]] = tuple_element_addr [[CASTED_PTR]] : $*(Builtin.Int64, Builtin.NativeObject), 0
-// SIL: store [[ARG0]] to [[CASTED_PTR_0]]
-// SIL: [[CASTED_PTR_1:%.*]] = tuple_element_addr [[CASTED_PTR]] : $*(Builtin.Int64, Builtin.NativeObject), 1
-// SIL: [[OLD_VALUE:%.*]] = load [[CASTED_PTR_1]]
-// SIL: store [[ARG1]] to [[CASTED_PTR_1]]
-// SIL: strong_release [[OLD_VALUE]]
-// SIL: } // end sil function '$s19def_transparent_std12assign_tuple1x1yyBi64__Bot_BptF' 
+// SIL: [[OLD_VALUE:%.*]] = load [[CASTED_PTR]]
+// SIL: store [[TUP]] to [[CASTED_PTR]]
+// SIL: release_value [[OLD_VALUE]]
+// SIL: } // end sil function '$s19def_transparent_std12assign_tuple1x1yyBi64__Bot_BptF'
 func test_tuple(x: (Builtin.Int64, Builtin.NativeObject),
                 y: Builtin.RawPointer) {
   assign_tuple(x: x, y: y)