Thread ForUnwind_t into emitCleanupsForReturn.

Some "return" edges are for unwinding due to errors and some aren't.
They'll need to be distinguished if we ever want to support throwing
cleanups.

Author: rjmccall

lib/SILGen/Cleanup.cpp

@@ -138,11 +138,12 @@ void CleanupManager::emitBranchAndCleanups(JumpDest dest, SILLocation branchLoc,
   builder.createBranch(branchLoc, dest.getBlock(), args);
 }
 
-void CleanupManager::emitCleanupsForReturn(CleanupLocation loc) {
+void CleanupManager::emitCleanupsForReturn(CleanupLocation loc,
+                                           ForUnwind_t forUnwind) {
   SILGenBuilder &builder = SGF.getBuilder();
   assert(builder.hasValidInsertionPoint() && "Emitting return in invalid spot");
   (void)builder;
-  emitCleanups(stack.stable_end(), loc, NotForUnwind, /*popCleanups=*/false);
+  emitCleanups(stack.stable_end(), loc, forUnwind, /*popCleanups=*/false);
 }
 
 /// Emit a new block that jumps to the specified location and runs necessary

lib/SILGen/Cleanup.h

@@ -173,7 +173,7 @@ class LLVM_LIBRARY_VISIBILITY CleanupManager {
 
   /// emitCleanupsForReturn - Emit the top-level cleanups needed prior to a
   /// return from the function.
-  void emitCleanupsForReturn(CleanupLocation loc);
+  void emitCleanupsForReturn(CleanupLocation loc, ForUnwind_t forUnwind);
 
   /// Emit a new block that jumps to the specified location and runs necessary
   /// cleanups based on its level.  If there are no cleanups to run, this just

lib/SILGen/SILGen.cpp

@@ -1508,7 +1508,8 @@ class SourceFileScope {
                             sgm.Types.getEmptyTupleType(), {}, {error});
 
         // Signal an abnormal exit by returning 1.
-        SGF.Cleanups.emitCleanupsForReturn(CleanupLocation::get(moduleLoc));
+        SGF.Cleanups.emitCleanupsForReturn(CleanupLocation::get(moduleLoc),
+                                           IsForUnwind);
         SGF.B.createBranch(returnLoc, returnBB, emitTopLevelReturnValue(1));
       }
 

lib/SILGen/SILGenApply.cpp

@@ -4589,7 +4589,7 @@ SILValue SILGenFunction::emitApplyWithRethrow(SILLocation loc, SILValue fn,
     B.createBuiltin(loc, SGM.getASTContext().getIdentifier("willThrow"),
                     SGM.Types.getEmptyTupleType(), {}, {error});
 
-    Cleanups.emitCleanupsForReturn(CleanupLocation::get(loc));
+    Cleanups.emitCleanupsForReturn(CleanupLocation::get(loc), IsForUnwind);
     B.createThrow(loc, error);
   }
 

lib/SILGen/SILGenConstructor.cpp

@@ -258,7 +258,7 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
     SILGenSavedInsertionPoint savedIP(*this, failureBB,
                                       FunctionSection::Postmatter);
     failureExitBB = createBasicBlock();
-    Cleanups.emitCleanupsForReturn(ctor);
+    Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
     // Return nil.
     if (F.getConventions().hasIndirectSILResults()) {
       // Inject 'nil' into the indirect return.
@@ -658,7 +658,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
     failureExitArg = failureExitBB->createPHIArgument(
         resultLowering.getLoweredType(), ValueOwnershipKind::Owned);
 
-    Cleanups.emitCleanupsForReturn(ctor);
+    Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
     SILValue nilResult =
         B.createEnum(loc, SILValue(), getASTContext().getOptionalNoneDecl(),
                      resultLowering.getLoweredType());

lib/SILGen/SILGenEpilog.cpp

@@ -186,7 +186,7 @@ SILGenFunction::emitEpilogBB(SILLocation topLevel) {
          "emitting epilog in wrong scope");
 
   auto cleanupLoc = CleanupLocation::get(topLevel);
-  Cleanups.emitCleanupsForReturn(cleanupLoc);
+  Cleanups.emitCleanupsForReturn(cleanupLoc, NotForUnwind);
 
   // Build the return value.  We don't do this if there are no direct
   // results; this can happen for void functions, but also happens when
@@ -297,7 +297,7 @@ void SILGenFunction::emitRethrowEpilog(SILLocation topLevel) {
   if (!prepareExtraEpilog(*this, ThrowDest, throwLoc, &exn))
     return;
 
-  Cleanups.emitCleanupsForReturn(ThrowDest.getCleanupLocation());
+  Cleanups.emitCleanupsForReturn(ThrowDest.getCleanupLocation(), IsForUnwind);
 
   B.createThrow(throwLoc, exn);
 
@@ -309,7 +309,8 @@ void SILGenFunction::emitCoroutineUnwindEpilog(SILLocation topLevel) {
   if (!prepareExtraEpilog(*this, CoroutineUnwindDest, unwindLoc, nullptr))
     return;
 
-  Cleanups.emitCleanupsForReturn(CoroutineUnwindDest.getCleanupLocation());
+  Cleanups.emitCleanupsForReturn(CoroutineUnwindDest.getCleanupLocation(),
+                                 IsForUnwind);
 
   B.createUnwind(unwindLoc);
 

lib/SILGen/SILGenFunction.cpp

@@ -552,7 +552,7 @@ void SILGenFunction::emitArtificialTopLevel(ClassDecl *mainClass) {
     if (r->getType() != rType)
       r = B.createStruct(mainClass, rType, r);
 
-    Cleanups.emitCleanupsForReturn(mainClass);
+    Cleanups.emitCleanupsForReturn(mainClass, NotForUnwind);
     B.createReturn(mainClass, r);
     return;
   }

lib/SILGen/SILGenMaterializeForSet.cpp

@@ -631,7 +631,7 @@ void MaterializeForSetEmitter::emit(SILGenFunction &SGF) {
 
   // Form the result and return.
   auto result = SGF.B.createTuple(loc, resultTupleTy, { address, callback });
-  SGF.Cleanups.emitCleanupsForReturn(CleanupLocation::get(loc));
+  SGF.Cleanups.emitCleanupsForReturn(CleanupLocation::get(loc), NotForUnwind);
   SGF.B.createReturn(loc, result);
 }