[Reachability] NFC: Allow more initial blocks.

Allow clients to specify any number (an array) of blocks beyond which
dataflow won't propagate rather than 1 or 0 (a pointer).

Author: nate-chandler

include/swift/SILOptimizer/Analysis/Reachability.h

@@ -243,7 +243,7 @@ class IterativeBackwardReachability final {
     BasicBlockSet unknownEndBlocks;
 
   public:
-    /// The blocks found between the gens and the defBlock into which
+    /// The blocks found between the gens and the initialBlocks into which
     /// reachability may extend.
     BasicBlockSetVector discoveredBlocks;
     /// The sublist of gens which are killed within the blocks where they occur.
@@ -296,15 +296,32 @@ class IterativeBackwardReachability final {
   };
 
   /// Construct a dataflow for the specified function to run from the gens
-  /// provided by \p effects to the specified def block.  So that the result
-  /// structure can be owned by the caller, it is taken by reference here.
+  /// provided by \p effects to the specified \p initialBlocks.  So that the
+  /// result structure can be owned by the caller, it is taken by reference
+  /// here.
   ///
-  /// If a nullptr defBlock is specified, the dataflow may run up to the begin
-  /// of the function.
-  IterativeBackwardReachability(SILFunction *function, SILBasicBlock *defBlock,
+  /// If \p initialBlocks is empty, the dataflow may run up to the begin of the
+  /// function.
+  IterativeBackwardReachability(SILFunction *function,
+                                ArrayRef<SILBasicBlock *> initialBlocks,
                                 Effects &effects, Result &result)
-      : function(function), defBlock(defBlock), effects(effects),
-        result(result), dataflowWorklist(function) {}
+      : function(function), initialBlocks(function), effects(effects),
+        result(result), dataflowWorklist(function) {
+    for (auto *block : initialBlocks) {
+      this->initialBlocks.insert(block);
+    }
+  }
+
+  /// Convenience constructor to pass a single initial block.
+  static IterativeBackwardReachability
+  untilInitialBlock(SILFunction *function, SILBasicBlock *initialBlock,
+                    Effects &effects, Result &result) {
+    using InitialBlocks = ArrayRef<SILBasicBlock *>;
+    InitialBlocks initialBlocks =
+        initialBlock ? InitialBlocks(initialBlock) : InitialBlocks();
+    return IterativeBackwardReachability(function, initialBlocks, effects,
+                                         result);
+  }
 
   /// Step 1: Prepare to run the global dataflow: discover and summarize the
   /// blocks in the relevant region.
@@ -358,9 +375,8 @@ class IterativeBackwardReachability final {
 
   /// The function in which the dataflow will run.
   SILFunction *function;
-  /// The block containing the def for the value--the dataflow will not
-  /// propagate beyond this block.
-  SILBasicBlock *defBlock;
+  /// The blocks beyond which the dataflow will not propagate.
+  BasicBlockSet initialBlocks;
 
   /// Input to the dataflow.
   Effects &effects;
@@ -375,9 +391,9 @@ class IterativeBackwardReachability final {
   /// Current activity of the dataflow.
   Stage stage = Stage::Unstarted;
 
-  /// Whether the def effectively occurs within the specified block.
-  bool isEffectiveDefBlock(SILBasicBlock *block) {
-    return defBlock ? block == defBlock : block == &*function->begin();
+  /// Whether dataflow continues beyond this block.
+  bool stopAtBlock(SILBasicBlock *block) {
+    return initialBlocks.contains(block) || &*function->begin() == block;
   }
 
   /// Form the meet of the end state of the provided predecessor with the begin
@@ -424,8 +440,8 @@ class IterativeBackwardReachability final {
 /// effect of each block for use by the dataflow.
 ///
 /// Starting from the gens, find all blocks which might be reached up to and
-/// including the defBlock.  Summarize the effects of these blocks along the
-/// way.
+/// including the initialBlocks.  Summarize the effects of these blocks along
+/// the way.
 template <typename Effects>
 void IterativeBackwardReachability<Effects>::initialize() {
   assert(stage == Stage::Unstarted);
@@ -454,9 +470,9 @@ void IterativeBackwardReachability<Effects>::initialize() {
       // adjacent successors.
       continue;
     }
-    if (isEffectiveDefBlock(block)) {
-      // If this block is the effective def block, dataflow mustn't propagate
-      // a reachable state through this block to its predecessors.
+    if (stopAtBlock(block)) {
+      // If dataflow is to stop at this block, it mustn't propagate a reachable
+      // state through this block to its predecessors.
       continue;
     }
     for (auto *predecessor : block->getPredecessorBlocks())
@@ -631,9 +647,9 @@ void IterativeBackwardReachability<Effects>::solve() {
 template <typename Effects>
 void IterativeBackwardReachability<Effects>::propagateIntoPredecessors(
     SILBasicBlock *successor) {
-  // State isn't tracked above the def block.  Don't propagate state changes
-  // into its predecessors.
-  if (isEffectiveDefBlock(successor))
+  // State isn't tracked above the blocks dataflow stops at.  Don't propagate
+  // state changes into its predecessors.
+  if (stopAtBlock(successor))
     return;
   assert(result.getBeginStateForBlock(successor) == State::Unreachable() &&
          "propagating unreachability into predecessors of block whose begin is "
@@ -776,7 +792,7 @@ bool IterativeBackwardReachability<Effects>::findBarrier(SILInstruction *from,
     }
   }
   assert(result.getEffectForBlock(block) != Effect::Kill());
-  if (isEffectiveDefBlock(block)) {
+  if (stopAtBlock(block)) {
     visitor.visitBarrierBlock(block);
     return true;
   }

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -275,10 +275,11 @@ class DeinitBarriers final {
   public:
     DestroyReachability(DeinitBarriers &result)
         : result(result), reachability(result.knownUses.getFunction()),
-          dataflow(result.knownUses.getFunction(),
-                   result.storageDefInst ? result.storageDefInst->getParent()
-                                         : nullptr,
-                   *this, reachability) {}
+          dataflow(Dataflow::untilInitialBlock(
+              result.knownUses.getFunction(),
+              result.storageDefInst ? result.storageDefInst->getParent()
+                                    : nullptr,
+              *this, reachability)) {}
 
     void solve();
 

lib/SILOptimizer/Utils/LexicalDestroyHoisting.cpp

@@ -141,7 +141,8 @@ class Dataflow final {
   Dataflow(Context const &context, Usage const &uses, DeinitBarriers &barriers)
       : context(context), uses(uses), barriers(barriers),
         result(&context.function),
-        reachability(&context.function, context.defBlock, *this, result) {}
+        reachability(Reachability::untilInitialBlock(
+            &context.function, context.defBlock, *this, result)) {}
   Dataflow(Dataflow const &) = delete;
   Dataflow &operator=(Dataflow const &) = delete;
 

lib/SILOptimizer/Utils/ShrinkBorrowScope.cpp

@@ -167,7 +167,8 @@ class Dataflow final {
   Dataflow(Context const &context, Usage const &uses, DeinitBarriers &barriers)
       : context(context), uses(uses), barriers(barriers),
         result(&context.function),
-        reachability(&context.function, context.defBlock, *this, result) {}
+        reachability(Reachability::untilInitialBlock(
+            &context.function, context.defBlock, *this, result)) {}
   Dataflow(Dataflow const &) = delete;
   Dataflow &operator=(Dataflow const &) = delete;