[SGC] Complete unreachable-reachable lifetimes.

For a function to have complete lifetimes, the lifetime of every def in
the function which is reachable by walking backwards from an unreachable
instruction 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.  Here, even
defs in "unreachable blocks"--i.e. those which can't be reached by a
forwards walk from function entry--are be completed.  Such blocks are
discovered by backwards non-repeating backwards walks from unreachable
instructions.

rdar://141197164

Author: nate-chandler

lib/SILOptimizer/Mandatory/SILGenCleanup.cpp

@@ -18,6 +18,7 @@
 
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/Defer.h"
+#include "swift/SIL/BasicBlockBits.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OSSALifetimeCompletion.h"
 #include "swift/SIL/PrettyStackTrace.h"
@@ -26,8 +27,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 +109,163 @@ struct SILGenCleanup : SILModuleTransform {
   bool completeOSSALifetimes(SILFunction *function);
   template <typename Range>
   bool completeLifetimesInRange(Range const &range,
-                                OSSALifetimeCompletion &completion);
+                                OSSALifetimeCompletion &completion,
+                                BasicBlockSet &completed);
 };
 
+/// Progress made so far on a walk beginning at an unreachable-terminated block.
+struct Walk {
+  SILBasicBlock *current;
+  SmallPtrSet<SILBasicBlock *, 16> seen;
+};
+
+/// Populate `roots` with the last blocks that are discovered via backwards
+/// walks along any non-repeating paths starting at the ends in `walks`.
+void collectReachableRoots(SILFunction *function, SmallVectorImpl<Walk> &walks,
+                           StackList<SILBasicBlock *> &roots) {
+  assert(!walks.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());
+
+  StackList<SILBasicBlock *> backedges(function);
+
+  BasicBlockSet visited(function);
+  while (!walks.empty()) {
+    auto walk = walks.pop_back_val();
+
+    SILBasicBlock *current = walk.current;
+
+    while (auto *block = current) {
+      current = nullptr;
+      bool previouslyVisited = visited.insert(block);
+
+      if (!walk.seen.insert(block).second) {
+        // This block was seen on _this_ path.
+        backedges.push_back(block);
+        continue;
+      }
+
+      if (!previouslyVisited) {
+        // This block was seen on another path.  Stop walking.
+        continue;
+      }
+
+      // No predecessors?  Found a root.
+      if (block->pred_empty()) {
+        if (block == function->getEntryBlock()) {
+          // TODO: [fix_silgen_destroy_unreachable] Remove this condition.
+          continue;
+        }
+        roots.push_back(block);
+        continue;
+      }
+
+      // At least one predecessor.  Continue walking this path from the first
+      // predecessor and add all the others to "ends" for subsequent walking.
+
+      for (auto pair : llvm::enumerate(block->getPredecessorBlocks())) {
+        auto *predecessor = pair.value();
+        if (pair.index() == 0) {
+          // Continue this walk from `predecessor`.
+          current = predecessor;
+        } else {
+          // Clone this walk to another that continues from `predecessor`.
+          walks.push_back({predecessor, walk.seen});
+        }
+      }
+    }
+  }
+
+  // Only complete starting from backedges after completing starting from all
+  // nodes without predecessors.  This ensures that completion is done with
+  // respect to the post-order based at a node without predecessors rather than
+  // one based at a backedge when both a node without predecessor and a
+  // backedge are discovered from the same end.
+  for (auto *backedge : backedges) {
+    roots.push_back(backedge);
+  }
+}
+
 bool SILGenCleanup::completeOSSALifetimes(SILFunction *function) {
   if (!getModule()->getOptions().OSSACompleteLifetimes)
     return false;
 
   LLVM_DEBUG(llvm::dbgs() << "Completing lifetimes in " << function->getName()
                           << "\n");
 
-  bool changed = false;
+  // First, collect all blocks terminated in unreachable.  Enables bailing out
+  // if there are none.
+  SmallVector<Walk, 32> walks;
+  function->visitUnreachableTerminatedBlocks([&walks](auto &block) {
+    walks.push_back({&block, {}});
+  });
+
+  if (walks.empty()) {
+    // There are no unreachable-terminated 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 unreachable instructions.  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, walks, roots);
+  }
 
-  // Lifetimes must be completed inside out (bottom-up in the CFG).
-  PostOrderFunctionInfo *postOrder =
-      getAnalysis<PostOrderAnalysis>()->get(function);
+  bool changed = false;
   DeadEndBlocks *deb = getAnalysis<DeadEndBlocksAnalysis>()->get(function);
   OSSALifetimeCompletion completion(function, /*DomInfo*/ nullptr, *deb);
-  changed |= completeLifetimesInRange(postOrder->getPostOrder(), completion);
+  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)) {

test/SILOptimizer/silgen_cleanup_complete_ossa.sil

@@ -141,3 +141,87 @@ exit:
 die:
   unreachable
 }
+
+// CHECK-LABEL: sil [ossa] @unreachable_def : {{.*}} {
+// CHECK:       bb2:
+// CHECK-NEXT:    [[DEF:%[^,]+]] = apply
+// CHECK-NEXT:    br bb3
+// CHECK:       bb3:
+// CHECK-NEXT:    destroy_value [dead_end] [[DEF]]
+// CHECK:         unreachable
+// CHECK-LABEL: } // end sil function 'unreachable_def'
+sil [ossa] @unreachable_def : $@convention(thin) () -> () {
+entry:
+  br exit
+
+exit:
+  %retval = tuple ()
+  return %retval : $()
+
+nowhere:
+  %def = apply undef() : $@convention(thin) () -> (@owned C)
+  br die
+
+die:
+  unreachable
+}
+
+// CHECK-LABEL: sil [ossa] @unreachable_def_2 : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[C:%[^,]+]] :
+// CHECK:         cond_br undef, [[LEFT:bb[0-9]+]], [[RIGHT:bb[0-9]+]]
+// CHECK:       [[LEFT]]:
+// CHECK-NEXT:    destroy_value [dead_end] [[C]]
+// CHECK-NEXT:    unreachable
+// CHECK:       [[RIGHT]]:
+// CHECK-NEXT:    destroy_value [dead_end] [[C]]
+// CHECK:         unreachable
+// CHECK-LABEL: } // end sil function 'unreachable_def_2'
+sil [ossa] @unreachable_def_2 : $@convention(thin) () -> () {
+entry:
+  %t = tuple ()
+  return %t : $()
+
+not(%c : @owned $C):
+  cond_br undef, left, right
+
+left:
+  unreachable
+
+right:
+  unreachable
+}
+
+// CHECK-LABEL: sil [ossa] @unreachable_def_3 : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[C:%[^,]+]] :
+// CHECK:         cond_br
+// CHECK:         cond_br undef, [[LEFT:bb[0-9]+]], [[RIGHT:bb[0-9]+]]
+// CHECK:       [[LEFT]]:
+// CHECK-NEXT:    destroy_value [dead_end] [[C]]
+// CHECK-NEXT:    unreachable
+// CHECK:       [[RIGHT]]:
+// CHECK-NEXT:    destroy_value [dead_end] [[C]]
+// CHECK:         unreachable
+// CHECK-LABEL: } // end sil function 'unreachable_def_3'
+sil [ossa] @unreachable_def_3 : $@convention(thin) () -> () {
+entry:
+  %t = tuple ()
+  return %t : $()
+
+header(%c : @owned $C):
+  br body
+
+body:
+  cond_br undef, die, backedge
+
+backedge:
+  br header(%c)
+
+die:
+  cond_br undef, left, right
+
+left:
+  unreachable
+
+right:
+  unreachable
+}