Merge pull request swiftlang#71998 from gottesmm/pr-ca981c22b983cdfc472ae9c1d737c76dae955aed

[region-isolation] Refactor out the stubify dead function if no longer used functionality from move only checker into its own pass and put it before region based isolation.

Author: gottesmm

include/swift/AST/SemanticAttrs.def

@@ -137,15 +137,25 @@ SEMANTICS_ATTR(NO_PERFORMANCE_ANALYSIS, "no_performance_analysis")
 // errors that may cause the user to think there is a bug in the compiler.
 SEMANTICS_ATTR(NO_MOVEONLY_DIAGNOSTICS, "sil.optimizer.moveonly.diagnostic.ignore")
 
-// Tell the move-only checker to delete this function body instead of performing
+// Tell the compiler that it can delete this function body instead of performing
 // diagnostics if the function is not used at the time of checking.
+//
+// This is currently used by allocbox to stack and capture promotion.
+//
+// MoveOnlyChecker and TransferNonSendable both potentially delete functions.
+//
+// DISCUSSION: We want to make sure that in cases where we may emit diagnostics
+// twice, we just delete the original function. When running alloc box to stack
+// and capture promotion, we may not have eliminated all of the relevant uses so
+// we may not know to eliminate them.
+//
 // When allocbox to stack specializes a function, we do not want to emit move
-// errors twice, once on the specialized and once on the original
-// function. The semantics of the closure with regards to move-only values may
-// also be dependent on stack promotion. Therefore, we mark the original with
-// this attribute, so that after it's promoted, the original function gets deleted
+// errors twice, once on the specialized and once on the original function. The
+// semantics of the closure with regards to move-only values may also be
+// dependent on stack promotion. Therefore, we mark the original with this
+// attribute, so that after it's promoted, the original function gets deleted
 // instead of raising spurious diagnostics.
-SEMANTICS_ATTR(MOVEONLY_DELETE_IF_UNUSED, "sil.optimizer.moveonly.delete_if_unused")
+SEMANTICS_ATTR(DELETE_IF_UNUSED, "sil.optimizer.delete_if_unused")
 
 // Force the use of the frame pointer for the specified function
 SEMANTICS_ATTR(USE_FRAME_POINTER, "use_frame_pointer")

include/swift/SILOptimizer/PassManager/Passes.def

@@ -497,6 +497,8 @@ PASS(MoveOnlyBorrowToDestructureTransform,
      "any move only errors with respect to non-borrow+projection uses")
 PASS(ReferenceBindingTransform, "sil-reference-binding-transform",
      "Check/transform reference bindings")
+PASS(DiagnosticDeadFunctionElimination, "sil-diagnostic-dead-function-elim",
+     "Eliminate dead functions from early specialization optimizations before we run later diagnostics")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

lib/SILOptimizer/Mandatory/CMakeLists.txt

@@ -49,4 +49,5 @@ target_sources(swiftSILOptimizer PRIVATE
   OSLogOptimization.cpp
   MoveOnlyWrappedTypeEliminator.cpp
   RegionAnalysisInvalidationTransform.cpp
+  DiagnosticDeadFunctionElimination.cpp
   OwnershipModelEliminator.cpp)

lib/SILOptimizer/Mandatory/CapturePromotion.cpp

@@ -46,6 +46,7 @@
 
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/SemanticAttrs.h"
 #include "swift/Basic/FrozenMultiMap.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILCloner.h"
@@ -1473,6 +1474,10 @@ processPartialApplyInst(SILOptFunctionBuilder &funcBuilder,
       funcBuilder, pai, fri, promotableIndices, f->getResilienceExpansion());
   worklist.push_back(clonedFn);
 
+  // Mark the original partial apply function as deletable if it doesn't have
+  // uses later.
+  fri->getReferencedFunction()->addSemanticsAttr(semantics::DELETE_IF_UNUSED);
+
   // Initialize a SILBuilder and create a function_ref referencing the cloned
   // closure.
   SILBuilderWithScope builder(pai);

lib/SILOptimizer/Mandatory/DiagnosticDeadFunctionElimination.cpp

@@ -0,0 +1,86 @@
+//===--- DiagnosticDeadFunctionElimination.cpp ----------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// Delete functions that early diagnostic specialization passes mark as being
+/// able to be DCE-ed if there are no further uses. This prevents later
+/// diagnostic passes from emitting diagnostics both on the original function
+/// and the diagnostic function.
+///
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "sil-diagnostic-dead-function-eliminator"
+
+#include "swift/AST/SemanticAttrs.h"
+#include "swift/SIL/SILBuilder.h"
+#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/Debug.h"
+
+using namespace swift;
+
+//===----------------------------------------------------------------------===//
+//                         MARK: Top Level Entrypoint
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+struct DiagnosticDeadFunctionEliminator : SILFunctionTransform {
+  void run() override {
+    auto *fn = getFunction();
+
+    // If an earlier pass asked us to eliminate the function body if it's
+    // unused, and the function is in fact unused, do that now.
+    if (!fn->hasSemanticsAttr(semantics::DELETE_IF_UNUSED) ||
+        fn->getRefCount() != 0 ||
+        isPossiblyUsedExternally(fn->getLinkage(),
+                                 fn->getModule().isWholeModule())) {
+      return;
+    }
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "===> Stubbifying unused function " << fn->getName()
+               << "'s body that was marked for deletion\n");
+    // Remove all non-entry blocks.
+    auto entryBB = fn->begin();
+    auto nextBB = std::next(entryBB);
+
+    while (nextBB != fn->end()) {
+      auto thisBB = nextBB;
+      ++nextBB;
+      thisBB->eraseFromParent();
+    }
+
+    // Rewrite the entry block to only contain an unreachable.
+    auto loc = entryBB->begin()->getLoc();
+    entryBB->eraseAllInstructions(fn->getModule());
+    {
+      SILBuilder b(&*entryBB);
+      b.createUnreachable(loc);
+    }
+
+    // If the function has shared linkage, reduce this version to private
+    // linkage, because we don't want the deleted-body form to win in any
+    // ODR shootouts.
+    if (fn->getLinkage() == SILLinkage::Shared) {
+      fn->setLinkage(SILLinkage::Private);
+      fn->setSerialized(IsNotSerialized);
+    }
+
+    invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);
+  }
+};
+
+} // namespace
+
+SILTransform *swift::createDiagnosticDeadFunctionElimination() {
+  return new DiagnosticDeadFunctionEliminator();
+}

lib/SILOptimizer/Mandatory/MoveOnlyChecker.cpp

@@ -222,55 +222,6 @@ class MoveOnlyCheckerPass : public SILFunctionTransform {
     assert(fn->getModule().getStage() == SILStage::Raw &&
            "Should only run on Raw SIL");
 
-    // If an earlier pass asked us to eliminate the function body if it's
-    // unused, and the function is in fact unused, do that now.
-    if (fn->hasSemanticsAttr(semantics::MOVEONLY_DELETE_IF_UNUSED)) {
-      if (fn->getRefCount() == 0
-          && !isPossiblyUsedExternally(fn->getLinkage(),
-                                       fn->getModule().isWholeModule())) {
-        LLVM_DEBUG(llvm::dbgs() << "===> Deleting unused function " << fn->getName() << "'s body that was marked for deletion\n");
-        // Remove all non-entry blocks.
-        auto entryBB = fn->begin();
-        auto nextBB = std::next(entryBB);
-        
-        while (nextBB != fn->end()) {
-          auto thisBB = nextBB;
-          ++nextBB;
-          thisBB->eraseFromParent();
-        }
-        
-        // Rewrite the entry block to only contain an unreachable.
-        auto loc = entryBB->begin()->getLoc();
-        entryBB->eraseAllInstructions(fn->getModule());
-        {
-          SILBuilder b(&*entryBB);
-          b.createUnreachable(loc);
-        }
-        
-        // If the function has shared linkage, reduce this version to private
-        // linkage, because we don't want the deleted-body form to win in any
-        // ODR shootouts.
-        if (fn->getLinkage() == SILLinkage::Shared) {
-          fn->setLinkage(SILLinkage::Private);
-        }
-        
-        invalidateAnalysis(SILAnalysis::InvalidationKind::FunctionBody);
-        return;
-      }
-      // If the function wasn't unused, let it continue into diagnostics.
-      // This would come up if a closure function somehow was used in different
-      // functions with different escape analysis results. This shouldn't really
-      // be possible, and we should try harder to make it impossible, but if
-      // it does happen now, the least bad thing to do is to proceed with
-      // move checking. This will either succeed and make sure the original
-      // function contains valid SIL, or raise errors relating to the use
-      // of the captures in an escaping way, which is the right thing to do
-      // if they are in fact escapable.
-      LLVM_DEBUG(llvm::dbgs() << "===> Function " << fn->getName()
-                              << " was marked to be deleted, but has uses. Continuing with move checking\n");
-      
-    }
-
     // If an earlier pass told use to not emit diagnostics for this function,
     // clean up any copies, invalidate the analysis, and return early.
     if (fn->hasSemanticsAttr(semantics::NO_MOVEONLY_DIAGNOSTICS)) {

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -139,6 +139,10 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
 
   P.addAddressLowering();
 
+  // Before we run later semantic optimizations, eliminate simple functions that
+  // we specialized to ensure that we do not emit diagnostics twice.
+  P.addDiagnosticDeadFunctionElimination();
+
   P.addFlowIsolation();
 
   //===---

lib/SILOptimizer/Transforms/AllocBoxToStack.cpp

@@ -1057,7 +1057,7 @@ specializeApplySite(SILOptFunctionBuilder &FuncBuilder, ApplySite Apply,
 
     // Set the moveonly delete-if-unused flag so we do not emit an error on the
     // original once we promote all its current uses.
-    F->addSemanticsAttr(semantics::MOVEONLY_DELETE_IF_UNUSED);
+    F->addSemanticsAttr(semantics::DELETE_IF_UNUSED);
 
     // If any of our promoted callee arg indices were originally noncopyable let
     // boxes, convert them from having escaping to having non-escaping

test/SILOptimizer/allocbox_to_stack.sil

@@ -398,7 +398,7 @@ bb0(%0 : $Int):
 }
 
 // CHECK-LABEL: sil private @$s6struct8useStack1tySi_tFSiycfU_Tf0s_n
-// CHECK-LABEL: sil private [_semantics "sil.optimizer.moveonly.delete_if_unused"] @$s6struct8useStack1tySi_tFSiycfU_
+// CHECK-LABEL: sil private [_semantics "sil.optimizer.delete_if_unused"] @$s6struct8useStack1tySi_tFSiycfU_
 // struct.(useStack (t : Swift.Int) -> ()).(closure #1)
 sil private @$s6struct8useStack1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int {
 bb0(%0 : $<τ_0_0> { var τ_0_0 } <Int>):
@@ -651,7 +651,7 @@ bb0(%0 : $Int, %1 : $*S<T>):
   return %9 : $Bool
 }
 
-// CHECK-LABEL: sil shared [_semantics "sil.optimizer.moveonly.delete_if_unused"] @closure1
+// CHECK-LABEL: sil shared [_semantics "sil.optimizer.delete_if_unused"] @closure1
 sil shared @closure1 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool {
 // CHECK: bb0
 bb0(%0 : $Int, %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>):
@@ -673,7 +673,7 @@ bb0(%0 : $Int, %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>):
 // CHECK: return
 // CHECK-NOT: bb1
 
-// CHECK-LABEL: sil shared [_semantics "sil.optimizer.moveonly.delete_if_unused"] @closure2
+// CHECK-LABEL: sil shared [_semantics "sil.optimizer.delete_if_unused"] @closure2
 sil shared @closure2 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool {
 // CHECK: bb0
 bb0(%0 : $Int, %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>):

test/SILOptimizer/allocbox_to_stack_ownership.sil

@@ -394,7 +394,7 @@ bb0(%0 : $Int):
 }
 
 // CHECK-LABEL: sil private [transparent] [ossa] @$s6struct8useStack1tySi_tFSiycfU_Tf0s_n
-// CHECK-LABEL: sil private [transparent] [_semantics "sil.optimizer.moveonly.delete_if_unused"] [ossa] @$s6struct8useStack1tySi_tFSiycfU_
+// CHECK-LABEL: sil private [transparent] [_semantics "sil.optimizer.delete_if_unused"] [ossa] @$s6struct8useStack1tySi_tFSiycfU_
 // struct.(useStack (t : Swift.Int) -> ()).(closure #1)
 sil private [transparent] [ossa] @$s6struct8useStack1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int {
 bb0(%0 : @owned $<τ_0_0> { var τ_0_0 } <Int>):
@@ -751,7 +751,7 @@ bb0(%0 : $Int, %1 : $*S<T>):
   return %9 : $Bool
 }
 
-// CHECK-LABEL: sil shared [_semantics "sil.optimizer.moveonly.delete_if_unused"] [ossa] @closure1
+// CHECK-LABEL: sil shared [_semantics "sil.optimizer.delete_if_unused"] [ossa] @closure1
 sil shared [ossa] @closure1 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool {
 // CHECK: bb0
 bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>):
@@ -773,7 +773,7 @@ bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>)
 // CHECK: return
 // CHECK-NOT: bb1
 
-// CHECK-LABEL: sil shared [_semantics "sil.optimizer.moveonly.delete_if_unused"] [ossa] @closure2
+// CHECK-LABEL: sil shared [_semantics "sil.optimizer.delete_if_unused"] [ossa] @closure2
 sil shared [ossa] @closure2 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool {
 // CHECK: bb0
 bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>):