Merge pull request #70738 from nate-chandler/opaque-values/20240105/1/init-tuple-typed

[OpaqueValues] Assign tuple into tuple-typed memory.

Author: nate-chandler

include/swift/SIL/SILBuilder.h

@@ -1672,6 +1672,7 @@ class SILBuilder {
   createTupleAddrConstructor(SILLocation Loc, SILValue DestAddr,
                              ArrayRef<SILValue> Elements,
                              IsInitialization_t IsInitOfDest) {
+    assert(getFunction().getModule().useLoweredAddresses());
     return insert(TupleAddrConstructorInst::create(getSILDebugLocation(Loc),
                                                    DestAddr, Elements,
                                                    IsInitOfDest, getModule()));

lib/SIL/Verifier/SILVerifier.cpp

@@ -3338,6 +3338,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   }
 
   void checkTupleAddrConstructorInst(TupleAddrConstructorInst *taci) {
+    require(F.getModule().useLoweredAddresses(),
+            "tuple_addr_constructor is invalid in opaque values");
     require(taci->getNumElements() > 0,
             "Cannot be applied to tuples that do not contain any real "
             "elements. E.x.: ((), ())");

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)
+  }
+}