SILGen: Support for 'throw' and 'try_apply' with indirect error result

Author: slavapestov

lib/SILGen/JumpDest.h

@@ -27,18 +27,31 @@ namespace swift {
 
 namespace Lowering {
 
+struct LLVM_LIBRARY_VISIBILITY ThrownErrorInfo {
+  SILValue IndirectErrorResult;
+
+  explicit ThrownErrorInfo(SILValue IndirectErrorResult)
+    : IndirectErrorResult(IndirectErrorResult) {}
+};
+
 /// The destination of a direct jump.  Swift currently does not
 /// support indirect branches or goto, so the jump mechanism only
 /// needs to worry about branches out of scopes, not into them.
 class LLVM_LIBRARY_VISIBILITY JumpDest {
   SILBasicBlock *Block = nullptr;
   CleanupsDepth Depth = CleanupsDepth::invalid();
   CleanupLocation CleanupLoc;
+  llvm::Optional<ThrownErrorInfo> ThrownError;
+
 public:
   JumpDest(CleanupLocation L) : CleanupLoc(L) {}
 
-  JumpDest(SILBasicBlock *block, CleanupsDepth depth, CleanupLocation l)
-    : Block(block), Depth(depth), CleanupLoc(l) {}
+  JumpDest(SILBasicBlock *block,
+           CleanupsDepth depth,
+           CleanupLocation l,
+           llvm::Optional<ThrownErrorInfo> ThrownError = llvm::None)
+    : Block(block), Depth(depth), CleanupLoc(l),
+      ThrownError(ThrownError) {}
 
   SILBasicBlock *getBlock() const { return Block; }
   SILBasicBlock *takeBlock() {
@@ -49,7 +62,14 @@ class LLVM_LIBRARY_VISIBILITY JumpDest {
   CleanupsDepth getDepth() const { return Depth; }
   CleanupLocation getCleanupLocation() const { return CleanupLoc; }
 
+  ThrownErrorInfo getThrownError() const {
+    assert(ThrownError);
+    return *ThrownError;
+  }
+
   JumpDest translate(CleanupsDepth NewDepth) && {
+    assert(!ThrownError);
+
     JumpDest NewValue(Block, NewDepth, CleanupLoc);
     Block = nullptr;
     Depth = CleanupsDepth::invalid();

lib/SILGen/SILGenApply.cpp

@@ -1856,6 +1856,7 @@ static void emitRawApply(SILGenFunction &SGF,
                          CanSILFunctionType substFnType,
                          ApplyOptions options,
                          ArrayRef<SILValue> indirectResultAddrs,
+                         SILValue indirectErrorAddr,
                          SmallVectorImpl<SILValue> &rawResults,
                          ExecutorBreadcrumb prevExecutor) {
   SILFunctionConventions substFnConv(substFnType, SGF.SGM.M);
@@ -1880,6 +1881,10 @@ static void emitRawApply(SILGenFunction &SGF,
 #endif
   argValues.append(indirectResultAddrs.begin(), indirectResultAddrs.end());
 
+  assert(!!indirectErrorAddr == substFnConv.hasIndirectSILErrorResults());
+  if (indirectErrorAddr)
+    argValues.push_back(indirectErrorAddr);
+
   auto inputParams = substFnType->getParameters();
   assert(inputParams.size() == args.size());
 
@@ -1978,6 +1983,7 @@ static void emitRawApply(SILGenFunction &SGF,
     SILBasicBlock *errorBB =
       SGF.getTryApplyErrorDest(loc, substFnType, prevExecutor,
                                substFnType->getErrorResult(),
+                               indirectErrorAddr,
                                options.contains(ApplyFlags::DoesNotThrow));
 
     options -= ApplyFlags::DoesNotThrow;
@@ -4876,7 +4882,8 @@ SILGenFunction::emitBeginApply(SILLocation loc, ManagedValue fn,
   // Emit the call.
   SmallVector<SILValue, 4> rawResults;
   emitRawApply(*this, loc, fn, subs, args, substFnType, options,
-               /*indirect results*/ {}, rawResults, ExecutorBreadcrumb());
+               /*indirect results*/ {}, /*indirect errors*/ {},
+               rawResults, ExecutorBreadcrumb());
 
   auto token = rawResults.pop_back_val();
   auto yieldValues = llvm::makeArrayRef(rawResults);
@@ -5411,6 +5418,16 @@ RValue SILGenFunction::emitApply(
   SmallVector<SILValue, 4> indirectResultAddrs;
   resultPlan->gatherIndirectResultAddrs(*this, loc, indirectResultAddrs);
 
+  SILValue indirectErrorAddr;
+  if (substFnType->hasErrorResult()) {
+    auto errorResult = substFnType->getErrorResult();
+    if (errorResult.getConvention() == ResultConvention::Indirect) {
+      auto loweredErrorResultType = getSILType(errorResult, substFnType);
+      indirectErrorAddr = B.createAllocStack(loc, loweredErrorResultType);
+      enterDeallocStackCleanup(indirectErrorAddr);
+    }
+  }
+
   // If the function returns an inner pointer, we'll need to lifetime-extend
   // the 'self' parameter.
   SILValue lifetimeExtendedSelf;
@@ -5540,7 +5557,8 @@ RValue SILGenFunction::emitApply(
   {
     SmallVector<SILValue, 1> rawDirectResults;
     emitRawApply(*this, loc, fn, subs, args, substFnType, options,
-                 indirectResultAddrs, rawDirectResults, breadcrumb);
+                 indirectResultAddrs, indirectErrorAddr,
+                 rawDirectResults, breadcrumb);
     assert(rawDirectResults.size() == 1);
     rawDirectResult = rawDirectResults[0];
   }
@@ -5709,12 +5727,22 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
   // Emit the rethrow logic.
   {
     B.emitBlock(errorBB);
-    SILValue error = errorBB->createPhiArgument(
-        fnConv.getSILErrorType(getTypeExpansionContext()),
-        OwnershipKind::Owned);
+
+    SILValue error;
+    bool indirectError = fnConv.hasIndirectSILErrorResults();
+
+    if (!indirectError) {
+      error = errorBB->createPhiArgument(
+          fnConv.getSILErrorType(getTypeExpansionContext()),
+          OwnershipKind::Owned);
+    }
 
     Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
-    B.createThrow(loc, error);
+
+    if (!indirectError)
+      B.createThrow(loc, error);
+    else
+      B.createThrowAddr(loc);
   }
 
   // Enter the normal path.

lib/SILGen/SILGenDistributed.cpp

@@ -479,6 +479,8 @@ void SILGenFunction::emitDistributedActorFactory(FuncDecl *fd) { // TODO(distrib
         OwnershipKind::Owned);
 
     Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
+
+    // FIXME: typed throws
     B.createThrow(loc, error);
   }
 }

lib/SILGen/SILGenEpilog.cpp

@@ -90,7 +90,8 @@ void SILGenFunction::prepareRethrowEpilog(
     rethrowBB->createPhiArgument(loweredErrorType, OwnershipKind::Owned);
   }
 
-  ThrowDest = JumpDest(rethrowBB, getCleanupsDepth(), cleanupLoc);
+  ThrowDest = JumpDest(rethrowBB, getCleanupsDepth(), cleanupLoc,
+                       ThrownErrorInfo(IndirectErrorResult));
 }
 
 void SILGenFunction::prepareCoroutineUnwindEpilog(CleanupLocation cleanupLoc) {
@@ -403,12 +404,21 @@ static bool prepareExtraEpilog(SILGenFunction &SGF, JumpDest &dest,
 void SILGenFunction::emitRethrowEpilog(SILLocation topLevel) {
   SILValue exn;
   SILLocation throwLoc = topLevel;
-  if (!prepareExtraEpilog(*this, ThrowDest, throwLoc, &exn))
+
+  if (!prepareExtraEpilog(*this, ThrowDest, throwLoc,
+                          !IndirectErrorResult ? &exn : nullptr)) {
     return;
+  }
 
   Cleanups.emitCleanupsForReturn(ThrowDest.getCleanupLocation(), IsForUnwind);
 
-  B.createThrow(CleanupLocation(throwLoc), exn);
+  // FIXME: opaque values
+  if (!IndirectErrorResult) {
+    B.createThrow(CleanupLocation(throwLoc), exn);
+  } else {
+    assert(IndirectErrorResult);
+    B.createThrowAddr(CleanupLocation(throwLoc));
+  }
 
   ThrowDest = JumpDest::invalid();
 }

lib/SILGen/SILGenExpr.cpp

@@ -1147,8 +1147,15 @@ SILGenFunction::ForceTryEmission::ForceTryEmission(SILGenFunction &SGF,
 
   // Set up a "catch" block for when an error occurs.
   SILBasicBlock *catchBB = SGF.createBasicBlock(FunctionSection::Postmatter);
+
+  // FIXME: typed throws
+  ASTContext &ctx = SGF.getASTContext();
+  (void) catchBB->createPhiArgument(SILType::getExceptionType(ctx),
+                                    OwnershipKind::Owned);
+
   SGF.ThrowDest = JumpDest(catchBB, SGF.Cleanups.getCleanupsDepth(),
-                           CleanupLocation(loc));
+                           CleanupLocation(loc),
+                           ThrownErrorInfo(/*indirectErrorAddr=*/nullptr));
 }
 
 void SILGenFunction::ForceTryEmission::finish() {
@@ -1164,10 +1171,11 @@ void SILGenFunction::ForceTryEmission::finish() {
     // Otherwise, we need to emit it.
     SILGenSavedInsertionPoint scope(SGF, catchBB, FunctionSection::Postmatter);
 
-    if (auto diagnoseError = SGF.getASTContext().getDiagnoseUnexpectedError()) {
-      ASTContext &ctx = SGF.getASTContext();
-      auto error = SGF.B.createTermResult(SILType::getExceptionType(ctx),
-                                          OwnershipKind::Owned);
+    // FIXME: typed throws
+    auto error = ManagedValue::forForwardedRValue(SGF, catchBB->getArgument(0));
+
+    ASTContext &ctx = SGF.getASTContext();
+    if (auto diagnoseError = ctx.getDiagnoseUnexpectedError()) {
       auto args = SGF.emitSourceLocationArgs(Loc->getExclaimLoc(), Loc);
 
       SGF.emitApplyOfLibraryIntrinsic(
@@ -1237,9 +1245,15 @@ RValue RValueEmitter::visitOptionalTryExpr(OptionalTryExpr *E, SGFContext C) {
 
   // Set up a "catch" block for when an error occurs.
   SILBasicBlock *catchBB = SGF.createBasicBlock(FunctionSection::Postmatter);
+
+  // FIXME: typed throws
+  auto *errorArg = catchBB->createPhiArgument(
+      SILType::getExceptionType(SGF.getASTContext()), OwnershipKind::Owned);
+
   llvm::SaveAndRestore<JumpDest> throwDest{
     SGF.ThrowDest,
-    JumpDest(catchBB, SGF.Cleanups.getCleanupsDepth(), E)};
+    JumpDest(catchBB, SGF.Cleanups.getCleanupsDepth(), E,
+             ThrownErrorInfo(/*indirectErrorAddr=*/nullptr))};
 
   SILValue branchArg;
   if (shouldWrapInOptional) {
@@ -1298,8 +1312,6 @@ RValue RValueEmitter::visitOptionalTryExpr(OptionalTryExpr *E, SGFContext C) {
   // result type.
   SGF.B.emitBlock(catchBB);
   FullExpr catchCleanups(SGF.Cleanups, E);
-  auto *errorArg = catchBB->createPhiArgument(
-      SILType::getExceptionType(SGF.getASTContext()), OwnershipKind::Owned);
   (void) SGF.emitManagedRValueWithCleanup(errorArg);
   catchCleanups.pop();
 

lib/SILGen/SILGenFunction.h

@@ -389,7 +389,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   JumpDest FailDest = JumpDest::invalid();
 
   /// The destination for throws.  The block will always be in the
-  /// postmatter and takes a BB argument of the exception type.
+  /// postmatter. For a direct error return, it takes a BB argument
+  /// of the exception type.
   JumpDest ThrowDest = JumpDest::invalid();
 
   /// Support for typed throws.
@@ -1989,7 +1990,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   SILBasicBlock *getTryApplyErrorDest(SILLocation loc,
                                       CanSILFunctionType fnTy,
                                       ExecutorBreadcrumb prevExecutor,
-                                      SILResultInfo exnResult,
+                                      SILResultInfo errorResult,
+                                      SILValue indirectErrorAddr,
                                       bool isSuppressed);
 
   /// Emit a dynamic member reference.