[SGC] Complete deadend-reachable lifetimes.

For a function to have complete lifetimes, the lifetime of every def in
the function which is backwards-reachable from a dead-end block must be
completed.

Previously, every def in every block which appears in the post-order of
the function's blocks is completed.  This was not enough: defs in
"unreachable blocks" (i.e. those which aren't forwards-reachable from
the function entry) must be completed too, and such blocks do not appear
in the function's post-order.

Here, defs in unreachable blocks are be completed too.  Such defs must
also be completed in relative post-order.  To do this, roots for the
non-entry post-orders must be found.

rdar://141197164

Author: nate-chandler

lib/SILOptimizer/Mandatory/SILGenCleanup.cpp

@@ -18,6 +18,8 @@
 
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/Defer.h"
+#include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OSSALifetimeCompletion.h"
 #include "swift/SIL/PrettyStackTrace.h"
@@ -26,8 +28,10 @@
 #include "swift/SILOptimizer/Analysis/DeadEndBlocksAnalysis.h"
 #include "swift/SILOptimizer/Analysis/PostOrderAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/BasicBlockOptUtils.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeInstruction.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
+#include "llvm/ADT/PostOrderIterator.h"
 
 using namespace swift;
 
@@ -106,33 +110,196 @@ struct SILGenCleanup : SILModuleTransform {
   bool completeOSSALifetimes(SILFunction *function);
   template <typename Range>
   bool completeLifetimesInRange(Range const &range,
-                                OSSALifetimeCompletion &completion);
+                                OSSALifetimeCompletion &completion,
+                                BasicBlockSet &completed);
 };
 
+// Iterate over `iterator` until finding a block in `include` and not in
+// `exclude`.
+SILBasicBlock *
+findFirstBlock(SILFunction *function, SILFunction::iterator &iterator,
+               llvm::function_ref<bool(SILBasicBlock *)> include,
+               llvm::function_ref<bool(SILBasicBlock *)> exclude) {
+  while (iterator != function->end()) {
+    auto *block = &*iterator;
+    iterator = std::next(iterator);
+    if (!include(block))
+      continue;
+    if (exclude(block))
+      continue;
+    return block;
+  }
+  return nullptr;
+}
+
+// Walk backward from `from` following first predecessors until finding the
+// first already-reached block.
+SILBasicBlock *findFirstLoop(SILFunction *function, SILBasicBlock *from) {
+  BasicBlockSet path(function);
+  auto *current = from;
+  while (auto *block = current) {
+    current = nullptr;
+    if (!path.insert(block)) {
+      return block;
+    }
+    if (block->pred_empty()) {
+      return nullptr;
+    }
+    current = *block->getPredecessorBlocks().begin();
+  }
+  llvm_unreachable("finished function-exiting loop!?");
+}
+
+/// Populate `roots` with the last blocks that are discovered via backwards
+/// walks along any non-repeating paths starting at the ends in `backward`.
+void collectReachableRoots(SILFunction *function, BasicBlockWorklist &backward,
+                           StackList<SILBasicBlock *> &roots) {
+  assert(!backward.empty());
+  assert(roots.empty());
+
+  // Always include the entry block as a root.  Currently SILGen will emit
+  // consumes in unreachable blocks of values defined in reachable blocks (e.g.
+  // test/SILGen/unreachable_code.swift:testUnreachableCatchClause).
+  // TODO: [fix_silgen_destroy_unreachable] Fix SILGen not to emit such
+  //                                        destroys and don't add the entry
+  //                                        block to roots here.
+  roots.push_back(function->getEntryBlock());
+
+  // First, find all blocks backwards-reachable from dead-end blocks.
+  while (auto *block = backward.pop()) {
+    for (auto *predecessor : block->getPredecessorBlocks()) {
+      backward.pushIfNotVisited(predecessor);
+    }
+  }
+
+  // Simple case: unpredecessored blocks.
+  //
+  // Every unpredecessored block reachable from some dead-end block is a root.
+  for (auto &block : *function) {
+    if (&block == function->getEntryBlock()) {
+      // TODO: [fix_silgen_destroy_unreachable] Remove this condition.
+      continue;
+    }
+    if (!block.pred_empty())
+      continue;
+    if (!backward.isVisited(&block))
+      continue;
+    roots.push_back(&block);
+  }
+
+  // Complex case: unreachable loops.
+  //
+  // Iteratively (the first time, these are the roots discovered in "Simple
+  // case" above), determine which blocks are forward-reachable from roots.
+  // Then, look for a block that is backwards-reachable from dead-end blocks
+  // but not forwards-reachable from roots so far discovered.  If one is found,
+  // it is forwards-reachable from an unreachable loop.  Walk backwards from
+  // that block to find a representative block in the loop.  Add that
+  // representative block to roots and iterate.  If no such block is found, all
+  // roots have been found.
+  BasicBlockWorklist forward(function);
+  for (auto *root : roots) {
+    forward.push(root);
+  }
+  bool changed = false;
+  auto iterator = function->begin();
+  do {
+    changed = false;
+
+    // Propagate forward-reachability from roots discovered so far.
+    while (auto *block = forward.pop()) {
+      for (auto *successor : block->getSuccessorBlocks()) {
+        forward.pushIfNotVisited(successor);
+      }
+    }
+    // Any block in `backward` but not in `forward` is forward-reachable from an
+    // unreachable loop.
+    if (auto *target = findFirstBlock(
+            function, iterator, /*include=*/
+            [&backward](auto *block) { return backward.isVisited(block); },
+            /*exclude=*/
+            [&forward](auto *block) { return forward.isVisited(block); })) {
+      // Find the first unreachable loop it's forwards-reachable from.
+      auto *loop = findFirstLoop(function, target);
+      ASSERT(loop);
+      forward.push(loop);
+      roots.push_back(loop);
+      changed = true;
+    }
+  } while (changed);
+}
+
 bool SILGenCleanup::completeOSSALifetimes(SILFunction *function) {
   if (!getModule()->getOptions().OSSACompleteLifetimes)
     return false;
 
   LLVM_DEBUG(llvm::dbgs() << "Completing lifetimes in " << function->getName()
                           << "\n");
 
-  bool changed = false;
+  BasicBlockWorklist deadends(function);
+  DeadEndBlocks *deba = getAnalysis<DeadEndBlocksAnalysis>()->get(function);
+  for (auto &block : *function) {
+    if (deba->isDeadEnd(&block))
+      deadends.push(&block);
+  }
 
-  // Lifetimes must be completed inside out (bottom-up in the CFG).
-  PostOrderFunctionInfo *postOrder =
-      getAnalysis<PostOrderAnalysis>()->get(function);
-  DeadEndBlocks *deb = getAnalysis<DeadEndBlocksAnalysis>()->get(function);
-  OSSALifetimeCompletion completion(function, /*DomInfo*/ nullptr, *deb);
-  changed |= completeLifetimesInRange(postOrder->getPostOrder(), completion);
+  if (deadends.empty()) {
+    // There are no dead-end blocks, so there are no lifetimes to complete.
+    // (SILGen may emit incomplete lifetimes, but not underconsumed lifetimes.)
+    return false;
+  }
+
+  // Lifetimes must be completed in unreachable blocks that are reachable via
+  // backwards walk from dead-end blocks.  First, check whether there are any
+  // unreachable blocks.
+  ReachableBlocks reachableBlocks(function);
+  reachableBlocks.compute();
+  StackList<SILBasicBlock *> roots(function);
+  if (!reachableBlocks.hasUnreachableBlocks()) {
+    // There are no blocks that are unreachable from the entry block.  Thus
+    // every block will be completed when completing the post-order of the
+    // entry block.
+    roots.push_back(function->getEntryBlock());
+  } else {
+    // There are unreachable blocks.  Determine the roots that can be reached
+    // when walking from the unreachable blocks.
+    collectReachableRoots(function, deadends, roots);
+  }
+
+  bool changed = false;
+  OSSALifetimeCompletion completion(function, /*DomInfo*/ nullptr, *deba);
+  BasicBlockSet completed(function);
+  for (auto *root : roots) {
+    if (root == function->getEntryBlock()) {
+      assert(!completed.contains(root));
+      // When completing from the entry block, prefer the PostOrderAnalysis so
+      // the result is cached.
+      PostOrderFunctionInfo *postOrder =
+          getAnalysis<PostOrderAnalysis>()->get(function);
+      changed |= completeLifetimesInRange(postOrder->getPostOrder(), completion,
+                                          completed);
+    }
+    if (completed.contains(root)) {
+      // This block has already been completed in some other post-order
+      // traversal.  Thus the entire post-order rooted at it has already been
+      // completed.
+      continue;
+    }
+    changed |= completeLifetimesInRange(
+        make_range(po_begin(root), po_end(root)), completion, completed);
+  }
   function->verifyOwnership(/*deadEndBlocks=*/nullptr);
   return changed;
 }
 
 template <typename Range>
-bool SILGenCleanup::completeLifetimesInRange(
-    Range const &range, OSSALifetimeCompletion &completion) {
+bool SILGenCleanup::completeLifetimesInRange(Range const &range,
+                                             OSSALifetimeCompletion &completion,
+                                             BasicBlockSet &completed) {
   bool changed = false;
   for (auto *block : range) {
+    if (!completed.insert(block))
+      continue;
     LLVM_DEBUG(llvm::dbgs()
                << "Completing lifetimes in bb" << block->getDebugID() << "\n");
     for (SILInstruction &inst : reverse(*block)) {