[refactor]: simplify to just cache info in DeadEndBlocks

Author: jamieQ

include/swift/SIL/BasicBlockUtils.h

@@ -68,6 +68,10 @@ class DeadEndBlocks {
   const SILFunction *f;
   bool didComputeValue = false;
 
+  /// When non-null, indicates whether dead-end blocks are present
+  /// in the current function.
+  std::optional<bool> hasAnyDeadEnds = std::nullopt;
+
   void compute();
 
 public:
@@ -86,11 +90,14 @@ class DeadEndBlocks {
   }
 
   /// 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.
+  /// Note: The underlying value is lazily computed & cached.
   bool isEmpty() {
-    return llvm::none_of(
-        *f, [this](const SILBasicBlock &BB) { return isDeadEnd(&BB); });
+    if (!hasAnyDeadEnds.has_value()) {
+      hasAnyDeadEnds = llvm::any_of(
+          *f, [this](const SILBasicBlock &BB) { return isDeadEnd(&BB); });
+    }
+
+    return !hasAnyDeadEnds.value();
   }
 
   /// Return true if this dead end blocks has computed its internal cache yet.

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -237,11 +237,6 @@ 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
@@ -380,8 +375,6 @@ 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
@@ -418,10 +411,8 @@ 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 assumeDeadEnds = true);
+  bool canonicalizeValueLifetime(
+      SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds = {});
 
   /// Compute the liveness information for \p def. But do not do any rewriting
   /// or computation of boundaries.
@@ -485,9 +476,6 @@ class CanonicalizeOSSALifetime final {
   }
 
   bool hasAnyDeadEnds() const {
-    if (hasDeadEnd)
-      return *hasDeadEnd;
-
     return !deadEndBlocksAnalysis->get(function)->isEmpty();
   }
 

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -489,18 +489,6 @@ 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.
@@ -532,7 +520,7 @@ void CopyPropagation::propagateCopies(
 
       if (!continueWithNextSubpassRun(borrowee))
         return;
-      auto canonicalized = canonicalizeValueLifetime(borrowee);
+      auto canonicalized = canonicalizer.canonicalizeValueLifetime(borrowee);
       if (!canonicalized && !firstRun)
         break;
 
@@ -541,7 +529,7 @@ void CopyPropagation::propagateCopies(
       auto folded = foldDestroysOfCopiedLexicalBorrow(bbi, *domTree, deleter);
       if (!folded)
         break;
-      auto hoisted = canonicalizeValueLifetime(folded);
+      auto hoisted = canonicalizer.canonicalizeValueLifetime(folded);
       // Keep running even if the new move's destroys can't be hoisted.
       (void)hoisted;
       if (!continueWithNextSubpassRun(folded))
@@ -559,7 +547,7 @@ void CopyPropagation::propagateCopies(
     if (argument->getOwnershipKind() == OwnershipKind::Owned) {
       if (!continueWithNextSubpassRun(argument))
         return;
-      canonicalizeValueLifetime(argument);
+      canonicalizer.canonicalizeValueLifetime(argument);
     }
   }
   deleter.cleanupDeadInstructions();
@@ -598,7 +586,7 @@ void CopyPropagation::propagateCopies(
       for (auto result : ownedForward->getResults()) {
         if (!continueWithNextSubpassRun(result))
           return;
-        canonicalizeValueLifetime(result);
+        canonicalizer.canonicalizeValueLifetime(result);
       }
       if (!continueWithNextSubpassRun(ownedForward))
         return;
@@ -643,7 +631,7 @@ void CopyPropagation::propagateCopies(
     SILValue def = defWorklist.ownedValues.pop_back_val();
     if (!continueWithNextSubpassRun(def))
       return;
-    auto canonicalized = canonicalizeValueLifetime(def);
+    auto canonicalized = canonicalizer.canonicalizeValueLifetime(def);
     if (!canonicalized)
       continue;
     // Copies of borrowed values may be dead.

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -300,7 +300,6 @@ void CanonicalizeOSSALifetime::extendLexicalLivenessToDeadEnds() {
   SSAPrunedLiveness directLiveness(function, &directDiscoverdBlocks);
   directLiveness.initializeDef(getCurrentDef());
   directLiveness.computeSimple();
-
   OSSALifetimeCompletion::visitAvailabilityBoundary(
       getCurrentDef(), directLiveness, [&](auto *unreachable, auto end) {
         if (end == OSSALifetimeCompletion::LifetimeEnd::Boundary) {
@@ -1453,10 +1452,8 @@ void CanonicalizeOSSALifetime::rewriteLifetimes() {
 
 /// Canonicalize a single extended owned lifetime.
 bool CanonicalizeOSSALifetime::canonicalizeValueLifetime(
-    SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds,
-    bool assumeDeadEnds) {
+    SILValue def, ArrayRef<SILInstruction *> lexicalLifetimeEnds) {
   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.