BasicBlockCloner: support for updating DeadEndBlocks.

DeadEndBlocks is used by low-level OSSA utilities. It needs to be
valid whenever OSSA transformations is being done.

Author: atrick

include/swift/SIL/BasicBlockUtils.h

@@ -87,6 +87,10 @@ class DeadEndBlocks {
   /// Used to determine if we need to verify a DeadEndBlocks.
   bool isComputed() const { return didComputeValue; }
 
+  /// Add any (new) blocks that are backward-reachable from \p reachableBB to
+  /// the set of reachable blocks.
+  void updateForReachableBlock(SILBasicBlock *reachableBB);
+
   const SILFunction *getFunction() const { return f; }
 
   /// Performs a simple check if \p block (or its single successor) ends in an
@@ -95,6 +99,9 @@ class DeadEndBlocks {
   /// This handles the common case of failure-handling blocks, which e.g.
   /// contain a call to fatalError().
   static bool triviallyEndsInUnreachable(SILBasicBlock *block);
+
+protected:
+  void propagateNewlyReachableBlocks(unsigned startIdx);
 };
 
 /// Compute joint-postdominating set for \p dominatingBlock and \p

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -170,6 +170,9 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   /// state is reset each time analyzeAddressProjections is called.
   SinkAddressProjections sinkProj;
 
+  // If available, the current DeadEndBlocks for incremental update.
+  DeadEndBlocks *deBlocks;
+
 public:
   /// An ordered list of old to new available value pairs.
   ///
@@ -178,8 +181,8 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   SmallVector<std::pair<SILValue, SILValue>, 16> availVals;
 
   // Clone blocks starting at `origBB`, within the same function.
-  BasicBlockCloner(SILBasicBlock *origBB)
-      : SILCloner(*origBB->getParent()), origBB(origBB) {}
+  BasicBlockCloner(SILBasicBlock *origBB, DeadEndBlocks *deBlocks = nullptr)
+      : SILCloner(*origBB->getParent()), origBB(origBB), deBlocks(deBlocks) {}
 
   bool canCloneBlock() {
     for (auto &inst : *origBB) {
@@ -218,6 +221,12 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
     successorBBs.reserve(origBB->getSuccessors().size());
     llvm::copy(origBB->getSuccessors(), std::back_inserter(successorBBs));
     cloneReachableBlocks(origBB, successorBBs, insertAfterBB);
+
+    if (deBlocks) {
+      for (auto *succBB : successorBBs) {
+        deBlocks->updateForReachableBlock(succBB);
+      }
+    }
   }
 
   /// Clone the given branch instruction's destination block, splitting

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -34,6 +34,7 @@
 namespace swift {
 
 class DominanceInfo;
+class DeadEndBlocks;
 template <class T> class NullablePtr;
 
 /// Transform a Use Range (Operand*) into a User Range (SILInstruction *)
@@ -202,7 +203,7 @@ SILLinkage getSpecializedLinkage(SILFunction *f, SILLinkage linkage);
 /// Tries to perform jump-threading on all checked_cast_br instruction in
 /// function \p Fn.
 bool tryCheckedCastBrJumpThreading(
-    SILFunction *fn, DominanceInfo *dt,
+    SILFunction *fn, DominanceInfo *dt, DeadEndBlocks *deBlocks,
     SmallVectorImpl<SILBasicBlock *> &blocksForWorklist,
     bool EnableOSSARewriteTerminator);
 

lib/SIL/Utils/BasicBlockUtils.cpp

@@ -368,6 +368,15 @@ void swift::mergeBasicBlockWithSingleSuccessor(SILBasicBlock *BB,
 //                              DeadEndBlocks
 //===----------------------------------------------------------------------===//
 
+// Propagate the reachability up the control flow graph.
+void DeadEndBlocks::propagateNewlyReachableBlocks(unsigned startIdx) {
+  for (unsigned idx = startIdx; idx < reachableBlocks.size(); ++idx) {
+    const SILBasicBlock *bb = reachableBlocks[idx];
+    for (SILBasicBlock *predBB : bb->getPredecessorBlocks())
+      reachableBlocks.insert(predBB);
+  }
+}
+
 void DeadEndBlocks::compute() {
   assert(reachableBlocks.empty() && "Computed twice");
 
@@ -379,13 +388,19 @@ void DeadEndBlocks::compute() {
     if (TI->isFunctionExiting())
       reachableBlocks.insert(&BB);
   }
-  // Propagate the reachability up the control flow graph.
-  unsigned Idx = 0;
-  while (Idx < reachableBlocks.size()) {
-    const SILBasicBlock *BB = reachableBlocks[Idx++];
-    for (SILBasicBlock *Pred : BB->getPredecessorBlocks())
-      reachableBlocks.insert(Pred);
+  propagateNewlyReachableBlocks(0);
+}
+
+void DeadEndBlocks::updateForReachableBlock(SILBasicBlock *reachableBB) {
+  if (!didComputeValue)
+    return;
+
+  assert(reachableBlocks.count(reachableBB));
+  unsigned numReachable = reachableBlocks.size();
+  for (SILBasicBlock *predBB : reachableBB->getPredecessorBlocks()) {
+    reachableBlocks.insert(predBB);
   }
+  propagateNewlyReachableBlocks(numReachable);
 }
 
 bool DeadEndBlocks::triviallyEndsInUnreachable(SILBasicBlock *block) {