[OpaqueValues] Assign tuple into tuple.

In address-lowered mode, to initialize tuple-typed memory in a single
step, tuple_addr_constructor must generally be used because it's not
possible to construct a tuple any of whose fields are address-only.  In
opaque values mode, there is no problem constructing such a tuple.  So
construct the tuple and then assign it into the tuple-typed memory; the
single instruction that initializes the memory will be the assign.

Author: nate-chandler

lib/SILGen/RValue.cpp

@@ -579,11 +579,22 @@ void RValue::assignInto(SILGenFunction &SGF, SILLocation loc,
   assert(destAddr->getType().castTo<TupleType>()->getNumElements() ==
          srcTupleType->getNumElements());
 
-  // If we do have any srcMvValues, then emit a TupleAddrConstructor. If we do
-  // not have any, then our tuple must consist only of empty tuples.
-  if (srcMvValues.size())
-    SGF.B.createTupleAddrConstructor(loc, destAddr, srcMvValues,
-                                     IsNotInitialization);
+  // If there are sourced managed values, initialize the address with a tuple.
+  if (srcMvValues.size()) {
+    if (SGF.useLoweredAddresses()) {
+      // Without opaque values, a tuple_addr_constructor is used to initialize
+      // the memory all at once.
+      SGF.B.createTupleAddrConstructor(loc, destAddr, srcMvValues,
+                                       IsNotInitialization);
+    } else {
+      // With opaque values, a tuple can always be formed and assigned to the
+      // memory.
+      auto tupleTy = destAddr->getType().getObjectType();
+      auto tuple = SGF.B.createTuple(loc, tupleTy, srcMvValues);
+      SGF.B.createAssign(loc, tuple.forward(SGF), destAddr,
+                         AssignOwnershipQualifier::Unknown);
+    }
+  }
   srcMvValues = ArrayRef<ManagedValue>();
 }
 

test/SILGen/opaque_values_silgen.swift

@@ -823,3 +823,46 @@ func consumeExprOfLoadExprOfOwnedAddrOnlyLValue<T>(_ ty: T.Type) {
   var t = source(ty)
   sink(consume t)
 }
+
+struct Twople<T> {
+  var storage: (T, T)
+
+// CHECK-LABEL: sil {{.*}}[ossa] @$s20opaque_values_silgen6TwopleV2t12t2ACyxGx_xtcfC : {{.*}} {
+// CHECK:       bb0([[T1:%[^,]+]] : 
+// CHECK-SAME:      [[T2:%[^,]+]] : 
+// CHECK-SAME:  ):
+// CHECK:         [[VAR:%[^,]+]] = alloc_box
+// CHECK:         [[VAR_UNINIT:%[^,]+]] = mark_uninitialized [rootself] [[VAR]]
+// CHECK:         [[VAR_LIFETIME:%[^,]+]] = begin_borrow [lexical] [var_decl] [[VAR_UNINIT]]
+// CHECK:         [[VAR_ADDR:%[^,]+]] = project_box [[VAR_LIFETIME]]
+// CHECK:         [[T1_BORROW:%[^,]+]] = begin_borrow [[T1]]
+// CHECK:         [[T1_COPY:%[^,]+]] = copy_value [[T1_BORROW]]
+// CHECK:         [[T2_BORROW:%[^,]+]] = begin_borrow [[T2]]
+// CHECK:         [[T2_COPY:%[^,]+]] = copy_value [[T2_BORROW]]
+// CHECK:         [[VAR_ACCESS:%[^,]+]] = begin_access [modify] [unknown] [[VAR_ADDR]]
+// CHECK:         [[STORAGE_ACCESS:%[^,]+]] = struct_element_addr [[VAR_ACCESS]]
+
+//                In opaque values mode, without regard to the fact that T is
+//                address-only, a tuple is constructed and assigned into the
+//                storage.
+// CHECK:         [[TUPLE:%[^,]+]] = tuple (
+// CHECK-SAME:        [[T1_COPY]]
+// CHECK-SAME:        [[T2_COPY]]
+// CHECK-SAME:    )
+// CHECK:         assign [[TUPLE]] to [[STORAGE_ACCESS]]
+
+// CHECK:         end_access [[VAR_ACCESS]]
+// CHECK:         end_borrow [[T2_BORROW]]
+// CHECK:         end_borrow [[T1_BORROW]]
+// CHECK:         [[RETVAL:%[^,]+]] = load [copy] [[VAR_ADDR]]
+// CHECK:         destroy_value [[T2]]
+// CHECK:         destroy_value [[T1]]
+// CHECK:         end_borrow [[VAR_LIFETIME]]
+// CHECK:         destroy_value [[VAR_UNINIT]]
+// CHECK:         return [[RETVAL]]
+// CHECK-LABEL: } // end sil function '$s20opaque_values_silgen6TwopleV2t12t2ACyxGx_xtcfC'
+  @_silgen_name("Twople_init_from_t1_t2")
+  init(t1: T, t2: T) {
+    self.storage = (t1, t2)
+  }
+}