[feedback]: move logic to caller & add utilities

Author: jamieQ

include/swift/SIL/BasicBlockUtils.h

@@ -85,6 +85,14 @@ class DeadEndBlocks {
     return reachableBlocks.count(block) == 0;
   }
 
+  /// Returns true iff none of the function's blocks is a dead-end.
+  /// Note: This value is not cached, and may visit all the function's blocks
+  /// to produce its return value.
+  bool isEmpty() {
+    return llvm::none_of(
+        *f, [this](const SILBasicBlock &BB) { return isDeadEnd(&BB); });
+  }
+
   /// Return true if this dead end blocks has computed its internal cache yet.
   ///
   /// Used to determine if we need to verify a DeadEndBlocks.

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -237,6 +237,11 @@ class CanonicalizeOSSALifetime final {
   /// copies.
   const MaximizeLifetime_t maximizeLifetime;
 
+  /// When non-null, indicates whether dead-end blocks are assumed to be present
+  /// in the current function.
+  /// Set in `::canonicalizeValueLifetime`, and reset in `::clear`.
+  std::optional<bool> hasDeadEnd = std::nullopt;
+
   SILFunction *function;
 
   // If present, will be used to ensure that the lifetime is not shortened to
@@ -375,6 +380,8 @@ class CanonicalizeOSSALifetime final {
   }
 
   void clear() {
+    hasDeadEnd.reset();
+
     // Clear the access blocks analysis pointer in case the client invalidates
     // the analysis.  If the client did, the analysis will be recomputed in
     // extendLivenessThroughOverlappingAccess; if it didn't, the analysis
@@ -411,8 +418,10 @@ class CanonicalizeOSSALifetime final {
   /// This only deletes instructions within \p def's extended lifetime. Use
   /// InstructionDeleter::cleanUpDeadInstructions() to recursively delete dead
   /// operands.
-  bool canonicalizeValueLifetime(
-      SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds = {});
+  bool
+  canonicalizeValueLifetime(SILValue def,
+                            ArrayRef<SILInstruction *> lexicalLifetimeEnds = {},
+                            bool assumeDeadEnds = true);
 
   /// Compute the liveness information for \p def. But do not do any rewriting
   /// or computation of boundaries.
@@ -475,6 +484,13 @@ class CanonicalizeOSSALifetime final {
     return !endingLifetimeAtExplicitEnds();
   }
 
+  bool hasAnyDeadEnds() const {
+    if (hasDeadEnd)
+      return *hasDeadEnd;
+
+    return !deadEndBlocksAnalysis->get(function)->isEmpty();
+  }
+
   bool respectsDeinitBarriers() const {
     if (!currentDef->isLexical())
       return false;

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -489,6 +489,18 @@ void CopyPropagation::propagateCopies(
       pruneDebug, MaximizeLifetime_t(!getFunction()->shouldOptimize()),
       getFunction(), accessBlockAnalysis, deadEndBlocksAnalysis, domTree,
       calleeAnalysis, deleter);
+
+  // Utility to canonicalize a value lifetime that lazily checks if dead
+  // end blocks are present
+  std::optional<bool> hasDeadEndBlocks = std::nullopt;
+  auto canonicalizeValueLifetime = [&](SILValue def) -> bool {
+    if (!hasDeadEndBlocks.has_value())
+      hasDeadEndBlocks = !deadEndBlocksAnalysis->get(getFunction())->isEmpty();
+
+    return canonicalizer.canonicalizeValueLifetime(
+        def, /*lexicalLifetimeEnd*/ {}, hasDeadEndBlocks.value());
+  };
+
   // NOTE: We assume that the function is in reverse post order so visiting the
   //       blocks and pushing begin_borrows as we see them and then popping them
   //       off the end will result in shrinking inner borrow scopes first.
@@ -520,7 +532,7 @@ void CopyPropagation::propagateCopies(
 
       if (!continueWithNextSubpassRun(borrowee))
         return;
-      auto canonicalized = canonicalizer.canonicalizeValueLifetime(borrowee);
+      auto canonicalized = canonicalizeValueLifetime(borrowee);
       if (!canonicalized && !firstRun)
         break;
 
@@ -529,7 +541,7 @@ void CopyPropagation::propagateCopies(
       auto folded = foldDestroysOfCopiedLexicalBorrow(bbi, *domTree, deleter);
       if (!folded)
         break;
-      auto hoisted = canonicalizer.canonicalizeValueLifetime(folded);
+      auto hoisted = canonicalizeValueLifetime(folded);
       // Keep running even if the new move's destroys can't be hoisted.
       (void)hoisted;
       if (!continueWithNextSubpassRun(folded))
@@ -547,7 +559,7 @@ void CopyPropagation::propagateCopies(
     if (argument->getOwnershipKind() == OwnershipKind::Owned) {
       if (!continueWithNextSubpassRun(argument))
         return;
-      canonicalizer.canonicalizeValueLifetime(argument);
+      canonicalizeValueLifetime(argument);
     }
   }
   deleter.cleanupDeadInstructions();
@@ -586,7 +598,7 @@ void CopyPropagation::propagateCopies(
       for (auto result : ownedForward->getResults()) {
         if (!continueWithNextSubpassRun(result))
           return;
-        canonicalizer.canonicalizeValueLifetime(result);
+        canonicalizeValueLifetime(result);
       }
       if (!continueWithNextSubpassRun(ownedForward))
         return;
@@ -631,7 +643,7 @@ void CopyPropagation::propagateCopies(
     SILValue def = defWorklist.ownedValues.pop_back_val();
     if (!continueWithNextSubpassRun(def))
       return;
-    auto canonicalized = canonicalizer.canonicalizeValueLifetime(def);
+    auto canonicalized = canonicalizeValueLifetime(def);
     if (!canonicalized)
       continue;
     // Copies of borrowed values may be dead.

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -125,19 +125,6 @@ static bool isDestroyOfCopyOf(SILInstruction *instruction, SILValue def) {
   return false;
 }
 
-static bool
-functionHasAnyDeadEnds(SILFunction *function,
-                       DeadEndBlocksAnalysis *deadEndBlocksAnalysis) {
-  bool hasAnyDeadEnds = false;
-  auto *deadEnds = deadEndBlocksAnalysis->get(function);
-  for (auto &bb : *function) {
-    hasAnyDeadEnds = deadEnds->isDeadEnd(&bb);
-    if (hasAnyDeadEnds)
-      break;
-  }
-  return hasAnyDeadEnds;
-}
-
 //===----------------------------------------------------------------------===//
 // MARK: Step 1. Compute pruned liveness
 //===----------------------------------------------------------------------===//
@@ -314,9 +301,6 @@ void CanonicalizeOSSALifetime::extendLexicalLivenessToDeadEnds() {
   directLiveness.initializeDef(getCurrentDef());
   directLiveness.computeSimple();
 
-  if (!functionHasAnyDeadEnds(function, deadEndBlocksAnalysis))
-    return;
-
   OSSALifetimeCompletion::visitAvailabilityBoundary(
       getCurrentDef(), directLiveness, [&](auto *unreachable, auto end) {
         if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {
@@ -390,9 +374,6 @@ void CanonicalizeOSSALifetime::extendLivenessToDeadEnds() {
     completeLiveness.updateForUse(pair.first, /*lifetimeEnding=*/false);
   }
 
-  if (!functionHasAnyDeadEnds(function, deadEndBlocksAnalysis))
-    return;
-
   OSSALifetimeCompletion::visitAvailabilityBoundary(
       getCurrentDef(), completeLiveness, [&](auto *unreachable, auto end) {
         if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {
@@ -1426,7 +1407,7 @@ bool CanonicalizeOSSALifetime::computeLiveness() {
     clear();
     return false;
   }
-  if (respectsDeadEnds()) {
+  if (respectsDeadEnds() && hasAnyDeadEnds()) {
     if (respectsDeinitBarriers()) {
       extendLexicalLivenessToDeadEnds();
     }
@@ -1472,8 +1453,10 @@ void CanonicalizeOSSALifetime::rewriteLifetimes() {
 
 /// Canonicalize a single extended owned lifetime.
 bool CanonicalizeOSSALifetime::canonicalizeValueLifetime(
-    SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds) {
+    SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds,
+    bool assumeDeadEnds) {
   LivenessState livenessState(*this, def, lexicalLifetimeEnds);
+  hasDeadEnd = assumeDeadEnds;
 
   // Don't canonicalize the lifetimes of values of move-only type.  According to
   // language rules, they are fixed.