forward direct return to direct results

Author: Azoy

lib/SILGen/SILGenFunction.cpp

@@ -657,10 +657,11 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, VarDecl *var) {
   auto resultType = decl->mapTypeIntoContext(interfaceType)->getCanonicalType();
   auto origResultType = AbstractionPattern(resultType);
 
+  SmallVector<SILValue, 4> directResults;
+
   if (F.getConventions().hasIndirectSILResults()) {
     Scope scope(Cleanups, CleanupLocation(var));
 
-    SmallVector<SILValue, 4> directResults;
     SmallVector<CleanupHandle, 4> cleanups;
     auto init = prepareIndirectResultInit(resultType, directResults, cleanups);
 
@@ -671,18 +672,19 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, VarDecl *var) {
     for (auto cleanup : cleanups) {
       Cleanups.forwardCleanup(cleanup);
     }
-
-    Cleanups.emitBranchAndCleanups(ReturnDest, loc, directResults);
   } else {
+    Scope scope(Cleanups, CleanupLocation(var));
+
     // If we have no indirect results, just return the result.
     auto result = emitApplyOfStoredPropertyInitializer(loc, entry, subs,
                                                        resultType,
                                                        origResultType,
                                                        SGFContext())
-                    .getAsSingleValue(*this, loc);
-    B.createReturn(loc, result);
+                    .ensurePlusOne(*this, loc);
+    std::move(result).forwardAll(*this, directResults);
   }
 
+  Cleanups.emitBranchAndCleanups(ReturnDest, loc, directResults);
   emitEpilog(loc);
 }
 

test/SILGen/stored_property_default_arg.swift

@@ -179,3 +179,32 @@ func checkReferenceTypes() {
 // CHECK-NEXT: [[U2:%.*]] = apply [[U2_REF]]({{.*}}, {{.*}}, [[W1]], {{.*}}) : $@convention(method) (@owned Optional<T>, @owned T, @thin U.Type) -> @out U
   let y = U(v: T())
 }
+
+// CHECK: default argument 0 of AA.init(ab:)
+// CHECK-NEXT: sil hidden [ossa] @$s27stored_property_default_arg2AAV2abAcA1ZCSg2ac_AG2adt_tcfcfA_ : $@convention(thin) () -> (@owned Optional<Z>, @owned Optional<Z>) {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   function_ref variable initialization expression of AA.ab
+// CHECK-NEXT:   [[AA_AB_REF:%.*]] = function_ref @$s27stored_property_default_arg2AAV2abAA1ZCSg2ac_AG2adtvpfi : $@convention(thin) () -> (@owned Optional<Z>, @owned Optional<Z>)
+// CHECK-NEXT:   [[AA_AB:%.*]] = apply [[AA_AB_REF]]() : $@convention(thin) () -> (@owned Optional<Z>, @owned Optional<Z>)
+// CHECK-NEXT:   ([[ELT0:%.*]], [[ELT1:%.*]]) = destructure_tuple [[AA_AB]] : $(Optional<Z>, Optional<Z>)
+// CHECK-NEXT:   [[RETURN:%.*]] = tuple ([[ELT0]] : $Optional<Z>, [[ELT1]] : $Optional<Z>)
+// CHECK-NEXT:   return [[RETURN]] : $(Optional<Z>, Optional<Z>)
+// CHECK-NEXT: }
+
+class Z {}
+
+struct AA {
+  var ab: (ac: Z?, ad: Z?) = (ac: Z(), ad: Z())
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s27stored_property_default_arg19checkReferenceTupleyyF : $@convention(thin) () -> () {
+func checkReferenceTuple() {
+// CHECK: function_ref default argument 0 of AA.init(ab:)
+// CHECK-NEXT: [[AB1_REF:%.*]] = function_ref @$s27stored_property_default_arg2AAV2abAcA1ZCSg2ac_AG2adt_tcfcfA_ : $@convention(thin) () -> (@owned Optional<Z>, @owned Optional<Z>)
+// CHECK-NEXT: [[AB1:%.*]] = apply [[AB1_REF]]() : $@convention(thin) () -> (@owned Optional<Z>, @owned Optional<Z>)
+// CHECK-NEXT: ([[ELT0:%.*]], [[ELT1:%.*]]) = destructure_tuple [[AB1]] : $(Optional<Z>, Optional<Z>)
+// CHECK-NEXT: function_ref AA.init(ab:)
+// CHECK-NEXT: [[AA1_REF:%.*]] = function_ref @$s27stored_property_default_arg2AAV2abAcA1ZCSg2ac_AG2adt_tcfC : $@convention(method) (@owned Optional<Z>, @owned Optional<Z>, @thin AA.Type) -> @owned AA
+// CHECK-NEXT: [[AA1:%.*]] = apply [[AA1_REF]]([[ELT0]], [[ELT1]], {{.*}}) : $@convention(method) (@owned Optional<Z>, @owned Optional<Z>, @thin AA.Type) -> @owned AA
+  let ae = AA.init(ab:)()
+}