Add support for indirect tuple-type results.

This could happen as a result of specialization or concrete
address-only values.

For now, it's just tested by SIL unit tests.

Author: atrick

include/swift/SIL/ApplySite.h

@@ -581,9 +581,9 @@ class FullApplySite : public ApplySite {
   }
 
   /// Get the SIL value that represents all of the given call's results. For a
-  /// single direct result, returns the result. For multiple results, returns a
-  /// fake tuple value. The tuple has no storage of its own. The real results
-  /// must be extracted from it.
+  /// single direct result, returns the actual result. For multiple results,
+  /// returns a pseudo-result tuple. The tuple has no storage of its own. The
+  /// real results must be extracted from it.
   ///
   /// For ApplyInst, returns the single-value instruction itself.
   ///
@@ -592,7 +592,7 @@ class FullApplySite : public ApplySite {
   /// For BeginApplyInst, returns an invalid value. For coroutines, there is no
   /// single value representing all results. Yielded values are generally
   /// handled differently since they have the convention of incoming arguments.
-  SILValue getPseudoResult() const {
+  SILValue getResult() const {
     switch (getKind()) {
     case FullApplySiteKind::ApplyInst:
       return SILValue(cast<ApplyInst>(getInstruction()));

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -174,14 +174,19 @@ cleanupAfterCall(FullApplySite apply,
 // that lowers values to storage.
 //===----------------------------------------------------------------------===//
 
-/// If \p pseudoResult has multiple results, return the destructure.
-static DestructureTupleInst *getCallMultiResult(SILValue pseudoResult) {
-  if (pseudoResult->getType().is<TupleType>()) {
-    if (auto *use = pseudoResult->getSingleUse())
-      return cast<DestructureTupleInst>(use->getUser());
+/// If \p pseudoResult represents multiple results and at least one result is
+/// used, then return the destructure.
+static DestructureTupleInst *getCallDestructure(FullApplySite apply) {
+  if (apply.getSubstCalleeConv().getNumDirectSILResults() == 1)
+    return nullptr;
 
-    assert(pseudoResult->use_empty() && "pseudo result can't be used");
-  }
+  SILValue pseudoResult = apply.getResult();
+  assert(pseudoResult->getType().is<TupleType>());
+  if (auto *use = pseudoResult->getSingleUse())
+    return cast<DestructureTupleInst>(use->getUser());
+
+  assert(pseudoResult->use_empty()
+         && "pseudo result can only be used by a single destructure_tuple");
   return nullptr;
 }
 
@@ -205,19 +210,18 @@ static bool
 visitCallResults(FullApplySite apply,
                  llvm::function_ref<bool(SILValue, SILResultInfo)> visitor) {
   auto fnConv = apply.getSubstCalleeConv();
-  SILValue pseudoResult = apply.getPseudoResult();
-  if (auto *destructure = getCallMultiResult(pseudoResult)) {
+  if (auto *destructure = getCallDestructure(apply)) {
     return visitCallMultiResults(destructure, fnConv, visitor);
   }
-  return visitor(pseudoResult, *fnConv.getDirectSILResults().begin());
+  return visitor(apply.getResult(), *fnConv.getDirectSILResults().begin());
 }
 
 /// Return true if the given value is either a "fake" tuple that represents all
 /// of a call's results or an empty tuple of no results. This may return true
 /// for either tuple_inst or a block argument.
 static bool isPseudoCallResult(SILValue value) {
-  if (isa<ApplyInst>(value))
-    return value->getType().is<TupleType>();
+  if (auto *apply = dyn_cast<ApplyInst>(value))
+    return ApplySite(apply).getSubstCalleeConv().getNumDirectSILResults() > 1;
 
   auto *bbArg = dyn_cast<SILPhiArgument>(value);
   if (!bbArg)
@@ -227,11 +231,18 @@ static bool isPseudoCallResult(SILValue value) {
   if (!term)
     return false;
 
-  return isa<TryApplyInst>(term) && bbArg->getType().is<TupleType>();
+  auto *tryApply = dyn_cast<TryApplyInst>(term);
+  if (!tryApply)
+    return false;
+
+  return ApplySite(tryApply).getSubstCalleeConv().getNumDirectSILResults() > 1;
 }
 
 /// Return true if this is a pseudo-return value.
 static bool isPseudoReturnValue(SILValue value) {
+  if (value->getFunction()->getConventions().getNumDirectSILResults() < 2)
+    return false;
+
   if (auto *tuple = dyn_cast<TupleInst>(value)) {
     Operand *singleUse = tuple->getSingleUse();
     return singleUse && isa<ReturnInst>(singleUse->getUser());
@@ -261,9 +272,12 @@ static SILValue getTupleStorageValue(Operand *operand) {
   if (!singleUse || !isa<ReturnInst>(singleUse->getUser()))
     return tuple;
 
+  SILFunction *function = tuple->getFunction();
+  if (function->getConventions().getNumDirectSILResults() < 2)
+    return tuple;
+
   unsigned resultIdx = tuple->getElementIndex(operand);
 
-  SILFunction *function = tuple->getFunction();
   auto loweredFnConv = getLoweredFnConv(function);
   assert(loweredFnConv.getResults().size() == tuple->getElements().size());
 
@@ -279,11 +293,11 @@ static SILValue getTupleStorageValue(Operand *operand) {
 
 /// Return the value representing storage for a single return value.
 ///
-///   bb0(%loweredIndirectResult : $*T, ...)
+///   bb0(%loweredIndirectResult : $*T, ...) // function entry
 ///     return %oper
 ///
 ///   For %oper, return %loweredIndirectResult
-static SILValue getSingleReturnValue(Operand *operand) {
+static SILValue getSingleReturnAddress(Operand *operand) {
   assert(!isPseudoReturnValue(operand->get()));
 
   auto *function = operand->getParentFunction();
@@ -612,7 +626,7 @@ void OpaqueValueVisitor::visitValue(SILValue value) {
 
 // Canonicalize returned values.
 //
-// Given:
+// Given $() -> @out (T, T):
 //   %t = def  : $(T, T)
 //   use %t    : $(T, T)
 //   return %t : $(T, T)
@@ -807,7 +821,7 @@ static SILValue getProjectedUseValue(Operand *operand) {
 
   // Return instructions can project into the return value.
   case SILInstructionKind::ReturnInst:
-    return getSingleReturnValue(operand);
+    return getSingleReturnAddress(operand);
   }
   return SILValue();
 }
@@ -1420,9 +1434,7 @@ AddressMaterialization::materializeProjectionIntoUse(Operand *operand,
   }
   case SILInstructionKind::TupleInst: {
     auto *tupleInst = cast<TupleInst>(user);
-    // Function return values.
-    if (tupleInst->hasOneUse()
-        && isa<ReturnInst>(tupleInst->use_begin()->getUser())) {
+    if (isPseudoReturnValue(tupleInst)) {
       unsigned resultIdx = tupleInst->getElementIndex(operand);
       assert(resultIdx < pass.loweredFnConv.getNumIndirectSILResults());
       // Cannot call getIndirectSILResults here because that API uses the
@@ -1830,9 +1842,8 @@ void ApplyRewriter::convertApplyWithIndirectResults() {
   // Populate newCallArgs.
   makeIndirectArgs(newCallArgs);
 
-  // Record the original results before potentially removing the apply
-  // (try_apply is removed during rewriting).
-  auto *destructure = getCallMultiResult(apply.getPseudoResult());
+  // Record the original result destructure before deleting a try_apply.
+  auto *destructure = getCallDestructure(apply);
 
   switch (apply.getKind()) {
   case FullApplySiteKind::ApplyInst: {
@@ -2071,7 +2082,7 @@ void ApplyRewriter::rewriteTryApply(ArrayRef<SILValue> newCallArgs) {
       tryApply->getNormalBB(), tryApply->getErrorBB(),
       tryApply->getApplyOptions(), tryApply->getSpecializationInfo());
 
-  auto *resultArg = cast<SILArgument>(apply.getPseudoResult());
+  auto *resultArg = cast<SILArgument>(apply.getResult());
 
   auto replaceTermResult = [&](SILValue newResultVal) {
     SILType resultTy = loweredCalleeConv.getSILResultType(typeCtx);
@@ -2091,8 +2102,6 @@ void ApplyRewriter::rewriteTryApply(ArrayRef<SILValue> newCallArgs) {
 
   // Handle a single opaque result value.
   if (pass.valueStorageMap.contains(resultArg)) {
-    assert(!resultArg->getType().is<TupleType>());
-
     // Storage was materialized by materializeIndirectResultAddress.
     auto &origStorage = pass.valueStorageMap.getStorage(resultArg);
     assert(origStorage.isRewritten);
@@ -2142,7 +2151,7 @@ void ApplyRewriter::rewriteTryApply(ArrayRef<SILValue> newCallArgs) {
 //   // no uses of %d1, %d2
 //
 void ApplyRewriter::replaceDirectResults(DestructureTupleInst *oldDestructure) {
-  SILValue newPseudoResult = apply.getPseudoResult();
+  SILValue newPseudoResult = apply.getResult();
 
   DestructureTupleInst *newDestructure = nullptr;
   if (loweredCalleeConv.getNumDirectSILResults() > 1) {
@@ -2950,7 +2959,7 @@ static void rewriteIndirectApply(FullApplySite apply,
   ApplyRewriter(apply, pass).convertApplyWithIndirectResults();
 
   if (!apply.getInstruction()->isDeleted()) {
-    assert(!getCallMultiResult(apply.getPseudoResult())
+    assert(!getCallDestructure(apply)
            && "replaceDirectResults deletes the destructure");
     pass.deleter.forceDelete(apply.getInstruction());
   }

lib/SILOptimizer/Mandatory/AddressLowering.h

@@ -38,13 +38,13 @@ namespace swift {
 /// After allocation, before materialization or rewriting, we may have:
 ///
 ///   %result_addr = alloc_stack       // storage for %result
-///   %result = apply () -> @out T
+///   %result = apply : $() -> @out T
 ///   %extract = struct_extact %result // def-projection of %result
 ///
 /// Or, a projection may project into a composing use (use-projection):
 ///
-///   %struct_addr = alloc_stack     // storage for %struct
-///   %result = apply () -> @out T   // use-projection of %struct at operand #0
+///   %struct_addr = alloc_stack      // storage for %struct
+///   %result = apply : $() -> @out T // use-projection of %struct at operand #0
 ///   %struct = struct %result
 ///
 /// A phi-projection is a use projection that projects its entire value

lib/SILOptimizer/Utils/Generics.cpp

@@ -2242,7 +2242,7 @@ SILFunction *ReabstractionThunkGenerator::createThunk() {
       Arguments.push_back(NewArg);
     }
     FullApplySite ApplySite = createReabstractionThunkApply(Builder);
-    SILValue ReturnValue = ApplySite.getPseudoResult();
+    SILValue ReturnValue = ApplySite.getResult();
     assert(ReturnValue && "getPseudoResult out of sync with ApplySite?!");
     Builder.createReturn(Loc, ReturnValue);
 
@@ -2255,7 +2255,7 @@ SILFunction *ReabstractionThunkGenerator::createThunk() {
 
   FullApplySite ApplySite = createReabstractionThunkApply(Builder);
 
-  SILValue ReturnValue = ApplySite.getPseudoResult();
+  SILValue ReturnValue = ApplySite.getResult();
   assert(ReturnValue && "getPseudoResult out of sync with ApplySite?!");
 
   if (ReturnValueAddr) {

test/SILOptimizer/address_lowering.sil

@@ -79,6 +79,63 @@ bb0(%0 : @owned $T):
   return %0 : $T
 }
 
+// This could happen as a result of either partial specialization from
+// a single type parameter into a generic tuple, or specialization
+// from a single type parameter into a tuple of concrete address-only
+// types.
+//
+// CHECK-LABEL: sil [ossa] @f011_identity_tuple : $@convention(thin) <T> (@in (T, T)) -> @out (T, T) {
+// CHECK: bb0(%0 : $*(T, T), %1 : $*(T, T)):
+// CHECK:   copy_addr [take] %1 to [initialization] %0 : $*(T, T)
+// CHECK-LABEL: } // end sil function 'f011_identity_tuple'
+sil [ossa] @f011_identity_tuple : $@convention(thin) <T> (@in (T, T)) -> @out (T, T) {
+bb0(%0 : @owned $(T, T)):
+  return %0 : $(T, T)
+}
+
+// CHECK-LABEL: sil [ossa] @f012_decompose_tuple_arg : $@convention(thin) <T> (@in (T, T)) -> @out (T, T) {
+// CHECK: bb0(%0 : $*(T, T), %1 : $*(T, T)):
+// CHECK:   [[ARG0:%.*]] = tuple_element_addr %1 : $*(T, T), 0
+// CHECK:   [[ARG1:%.*]] = tuple_element_addr %1 : $*(T, T), 1
+// CHECK:   [[RET0:%.*]] = tuple_element_addr %0 : $*(T, T), 0
+// CHECK:   apply %{{.*}}<T>([[RET0]], [[ARG0]]) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> @out τ_0_0
+// CHECK:   [[RET1:%.*]] = tuple_element_addr %0 : $*(T, T), 1
+// CHECK:   copy_addr [take] [[ARG1]] to [initialization] [[RET1]] : $*T
+// CHECK-LABEL: } // end sil function 'f012_decompose_tuple_arg'
+sil [ossa] @f012_decompose_tuple_arg : $@convention(thin) <T> (@in (T, T)) -> @out (T, T) {
+bb0(%0 : @owned $(T, T)):
+  (%arg0, %arg1) = destructure_tuple %0 : $(T, T)
+  %f = function_ref @f010_addrlower_identity : $@convention(thin) <T> (@in T) -> @out T
+  %call = apply %f<T>(%arg0) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> @out τ_0_0
+  %result = tuple (%call : $T, %arg1 : $T)
+  return %result : $(T, T)
+}
+
+// CHECK-LABEL: sil [ossa] @f013_pass_tuple_arg : $@convention(thin) <T> (@in T) -> @out T {
+// CHECK: bb0(%0 : $*T, %1 : $*T):
+// CHECK:   [[IN:%.*]] = alloc_stack $(T, T)
+// CHECK:   [[OUT:%.*]] = alloc_stack $(T, T)
+// CHECK:   [[IN1:%.*]] = tuple_element_addr [[IN]] : $*(T, T), 1
+// CHECK:   copy_addr %1 to [initialization] [[IN1]] : $*T
+// CHECK:   [[IN0:%.*]] = tuple_element_addr %2 : $*(T, T), 0
+// CHECK:   copy_addr [take] %1 to [initialization] [[IN0]] : $*T
+// CHECK:   apply %{{.*}}<T>([[OUT]], [[IN]]) : $@convention(thin) <τ_0_0> (@in (τ_0_0, τ_0_0)) -> @out (τ_0_0, τ_0_0)
+// CHECK:   [[RET:%.*]] = tuple_element_addr [[OUT]] : $*(T, T), 0
+// CHECK:   [[DEAD:%.*]] = tuple_element_addr [[OUT]] : $*(T, T), 1
+// CHECK:   destroy_addr [[DEAD]] : $*T
+// CHECK:   copy_addr [take] [[RET]] to [initialization] %0 : $*T
+// CHECK-LABEL: } // end sil function 'f013_pass_tuple_arg'
+sil [ossa] @f013_pass_tuple_arg : $@convention(thin) <T> (@in T) -> @out T {
+bb0(%0 : @owned $T):
+  %copy0 = copy_value %0 : $T
+  %arg = tuple (%0 : $T, %copy0 : $T)
+  %f = function_ref @f011_identity_tuple : $@convention(thin) <T> (@in (T, T)) -> @out (T, T)
+  %call = apply %f<T>(%arg) : $@convention(thin) <T> (@in (T, T)) -> @out (T, T)
+  (%call0, %call1) = destructure_tuple %call : $(T, T)
+  destroy_value %call1 : $T
+  return %call0 : $T
+}
+
 // CHECK-LABEL: sil [ossa] @f020_multiResult : $@convention(thin) <T> (@in T) -> (@out T, @out T, @out T) {
 // CHECK: %0 "$return_value"
 // CHECK: %1 "$return_value"