[PrunedLiveness] Add lower detail boundary.

To enable those clients which care only about _blocks_ whose
instructions or dead-defs make up the liveness boundary to avoid
iterating instruction lists, enhance boundary computation with a second
type (`PrunedLivenessBlockBoundary`) and migrate some methods from
liveness onto the boundary types to enable dispatching on the boundary
type to do only the amount of analysis that's necessary.

Author: nate-chandler

include/swift/SIL/PrunedLiveness.h

@@ -554,6 +554,26 @@ class PrunedLiveness {
   void dump() const;
 };
 
+/// Recording liveness boundary at some level of detail; see concrete subclasses
+/// PrunedLivenessBoundary and PrunedLivenessBlockBoundary.
+struct AnyPrunedLivenessBoundary {
+  virtual ~AnyPrunedLivenessBoundary() {}
+  /// Targets whose single predecessor has at least one non-boundary successor.
+  SmallVector<SILBasicBlock *, 8> boundaryEdges;
+
+  friend class SSAPrunedLiveness;
+  friend class MultiDefPrunedLiveness;
+
+private:
+  virtual void findBoundaryInSSADefBlock(SILNode *ssaDef,
+                                         const PrunedLiveness &liveness) = 0;
+  virtual void
+  findBoundaryInMultiDefBlock(SILBasicBlock *block, bool isLiveOut,
+                              const MultiDefPrunedLiveness &liveness) = 0;
+  virtual void findBoundaryInNonDefBlock(SILBasicBlock *block,
+                                         const PrunedLiveness &liveness) = 0;
+};
+
 /// Record the last use points and CFG edges that form the boundary of
 /// PrunedLiveness.
 ///
@@ -565,9 +585,8 @@ class PrunedLiveness {
 /// Each boundary edge is identified by its target block. The source of the edge
 /// is the target block's single predecessor which must have at least one other
 /// non-boundary successor.
-struct PrunedLivenessBoundary {
+struct PrunedLivenessBoundary : AnyPrunedLivenessBoundary {
   SmallVector<SILInstruction *, 8> lastUsers;
-  SmallVector<SILBasicBlock *, 8> boundaryEdges;
   SmallVector<SILNode *, 1> deadDefs;
 
   void clear() {
@@ -586,6 +605,39 @@ struct PrunedLivenessBoundary {
 
   void print(llvm::raw_ostream &OS) const;
   void dump() const;
+
+private:
+  void findBoundaryInSSADefBlock(SILNode *ssaDef,
+                                 const PrunedLiveness &liveness) override;
+  void
+  findBoundaryInMultiDefBlock(SILBasicBlock *block, bool isLiveOut,
+                              const MultiDefPrunedLiveness &liveness) override;
+  void findBoundaryInNonDefBlock(SILBasicBlock *block,
+                                 const PrunedLiveness &liveness) override;
+};
+
+/// Record the blocks which either contain last use points or are boundary edge
+/// targets.
+///
+/// Enables clients only interested in block-level details to avoid expensive
+/// and for-them wasteful instruction list iteration.
+struct PrunedLivenessBlockBoundary : AnyPrunedLivenessBoundary {
+  /// Blocks containing last users or dead defs.
+  SmallVector<SILBasicBlock *, 8> endBlocks;
+
+  void clear() {
+    endBlocks.clear();
+    boundaryEdges.clear();
+  }
+
+private:
+  void findBoundaryInSSADefBlock(SILNode *ssaDef,
+                                 const PrunedLiveness &liveness) override;
+  void
+  findBoundaryInMultiDefBlock(SILBasicBlock *block, bool isLiveOut,
+                              const MultiDefPrunedLiveness &liveness) override;
+  void findBoundaryInNonDefBlock(SILBasicBlock *block,
+                                 const PrunedLiveness &liveness) override;
 };
 
 /// PrunedLiveness with information about defs for computing the live range
@@ -696,7 +748,7 @@ class PrunedLiveRange : public PrunedLiveness {
   /// The computed boundary will completely post-dominate, including dead end
   /// paths. The client should query DeadEndBlocks to ignore those dead end
   /// paths.
-  void computeBoundary(PrunedLivenessBoundary &boundary) const;
+  void computeBoundary(AnyPrunedLivenessBoundary &boundary) const;
 
   /// Compute the boundary from a backward CFG traversal from a known set of
   /// jointly post-dominating blocks. Avoids the need to record an ordered list
@@ -772,7 +824,7 @@ class SSAPrunedLiveness : public PrunedLiveRange<SSAPrunedLiveness> {
 
   /// SSA implementation of computeBoundary.
   void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
-                             PrunedLivenessBoundary &boundary) const;
+                             AnyPrunedLivenessBoundary &boundary) const;
 
   /// Compute liveness for a single SSA definition. The lifetime-ending uses are
   /// also recorded--destroy_value or end_borrow.
@@ -860,7 +912,7 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
 
   /// Multi-Def implementation of computeBoundary.
   void findBoundariesInBlock(SILBasicBlock *block, bool isLiveOut,
-                             PrunedLivenessBoundary &boundary) const;
+                             AnyPrunedLivenessBoundary &boundary) const;
 
   /// Compute liveness for all currently initialized definitions. The
   /// lifetime-ending uses are also recorded--destroy_value or
@@ -879,6 +931,9 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
   /// also lack scope-ending instructions, so the liveness of their nested uses
   /// may be ignored.
   LiveRangeSummary computeSimple();
+
+  friend struct PrunedLivenessBoundary;
+  friend struct PrunedLivenessBlockBoundary;
 };
 
 //===----------------------------------------------------------------------===//

lib/SIL/Utils/PrunedLiveness.cpp

@@ -822,7 +822,7 @@ bool PrunedLiveRange<LivenessWithDefs>::areUsesOutsideBoundary(
 
 template <typename LivenessWithDefs>
 void PrunedLiveRange<LivenessWithDefs>::computeBoundary(
-    PrunedLivenessBoundary &boundary) const {
+    AnyPrunedLivenessBoundary &boundary) const {
   assert(asImpl().isInitialized());
 
   for (SILBasicBlock *block : getDiscoveredBlocks()) {
@@ -896,50 +896,60 @@ template class PrunedLiveRange<MultiDefPrunedLiveness>;
 //===----------------------------------------------------------------------===//
 
 /// Given live-within (non-live-out) \p block, find the last user.
-void findBoundaryInNonDefBlock(SILBasicBlock *block,
-                               PrunedLivenessBoundary &boundary,
-                               const PrunedLiveness &liveness) {
+void PrunedLivenessBoundary::findBoundaryInNonDefBlock(
+    SILBasicBlock *block, const PrunedLiveness &liveness) {
   assert(liveness.getBlockLiveness(block) == PrunedLiveBlocks::LiveWithin);
 
   for (SILInstruction &inst : llvm::reverse(*block)) {
     if (liveness.isInterestingUser(&inst)) {
-      boundary.lastUsers.push_back(&inst);
+      lastUsers.push_back(&inst);
       return;
     }
   }
   llvm_unreachable("live-within block must contain an interesting use");
 }
 
+void PrunedLivenessBlockBoundary::findBoundaryInNonDefBlock(
+    SILBasicBlock *block, const PrunedLiveness &liveness) {
+  assert(liveness.getBlockLiveness(block) == PrunedLiveBlocks::LiveWithin);
+
+  endBlocks.push_back(block);
+}
+
 /// Given a live-within \p block that contains an SSA definition, and knowledge
 /// that all live uses are dominated by that single definition, find either the
 /// last user or a dead def.
 ///
 /// A live range with a single definition cannot have any uses above that
 /// definition in the same block. This even holds for unreachable self-loops.
-void findBoundaryInSSADefBlock(SILNode *ssaDef,
-                               PrunedLivenessBoundary &boundary,
-                               const PrunedLiveness &liveness) {
+void PrunedLivenessBoundary::findBoundaryInSSADefBlock(
+    SILNode *ssaDef, const PrunedLiveness &liveness) {
   // defInst is null for argument defs.
   SILInstruction *defInst = dyn_cast<SILInstruction>(ssaDef);
   for (SILInstruction &inst : llvm::reverse(*ssaDef->getParentBlock())) {
     if (&inst == defInst) {
-      boundary.deadDefs.push_back(cast<SILNode>(&inst));
+      deadDefs.push_back(cast<SILNode>(&inst));
       return;
     }
     if (liveness.isInterestingUser(&inst)) {
-      boundary.lastUsers.push_back(&inst);
+      lastUsers.push_back(&inst);
       return;
     }
   }
   auto *deadArg = dyn_cast<SILArgument>(ssaDef);
   assert(deadArg
          && "findBoundariesInBlock must be called on a live block");
-  boundary.deadDefs.push_back(deadArg);
+  deadDefs.push_back(deadArg);
+}
+
+void PrunedLivenessBlockBoundary::findBoundaryInSSADefBlock(
+    SILNode *ssaDef, const PrunedLiveness &liveness) {
+  endBlocks.push_back(ssaDef->getParentBlock());
 }
 
 void SSAPrunedLiveness::findBoundariesInBlock(
     SILBasicBlock *block, bool isLiveOut,
-    PrunedLivenessBoundary &boundary) const {
+    AnyPrunedLivenessBoundary &boundary) const {
   assert(isInitialized());
 
   // For SSA, a live-out block cannot have a boundary.
@@ -948,13 +958,13 @@ void SSAPrunedLiveness::findBoundariesInBlock(
 
   // Handle live-within block
   if (!isDefBlock(block)) {
-    findBoundaryInNonDefBlock(block, boundary, *this);
+    boundary.findBoundaryInNonDefBlock(block, *this);
     return;
   }
   // Find either the last user or a dead def
   auto *defInst = def->getDefiningInstruction();
   SILNode *defNode = defInst ? cast<SILNode>(defInst) : cast<SILArgument>(def);
-  findBoundaryInSSADefBlock(defNode, boundary, *this);
+  boundary.findBoundaryInSSADefBlock(defNode, *this);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1045,13 +1055,13 @@ static FunctionTest MultiDefUseLivenessTest(
 
 void MultiDefPrunedLiveness::findBoundariesInBlock(
     SILBasicBlock *block, bool isLiveOut,
-    PrunedLivenessBoundary &boundary) const {
+    AnyPrunedLivenessBoundary &boundary) const {
   assert(isInitialized());
 
   if (!isDefBlock(block)) {
     // A live-out block with no defs cannot have a boundary.
     if (!isLiveOut) {
-      findBoundaryInNonDefBlock(block, boundary, *this);
+      boundary.findBoundaryInNonDefBlock(block, *this);
     }
     return;
   }
@@ -1061,48 +1071,89 @@ void MultiDefPrunedLiveness::findBoundariesInBlock(
   if (++defs.begin() == defs.end()) {
     // For SSA, a live-out block cannot have a boundary.
     if (!isLiveOut) {
-      findBoundaryInSSADefBlock(*defs.begin(), boundary, *this);
+      boundary.findBoundaryInSSADefBlock(*defs.begin(), *this);
     }
     return;
   }
+  boundary.findBoundaryInMultiDefBlock(block, isLiveOut, *this);
+}
+
+void PrunedLivenessBoundary::findBoundaryInMultiDefBlock(
+    SILBasicBlock *block, bool isLiveOut,
+    const MultiDefPrunedLiveness &liveness) {
   // Handle a live-out or live-within block with potentially multiple defs
-  unsigned prevCount = boundary.deadDefs.size() + boundary.lastUsers.size();
+  unsigned prevCount = deadDefs.size() + lastUsers.size();
   (void)prevCount;
 
   bool isLive = isLiveOut;
   for (auto &inst : llvm::reverse(*block)) {
     // Check if the instruction is a def before checking whether it is a
     // use. The same instruction can be both a dead def and boundary use.
-    if (isDef(&inst)) {
+    if (liveness.isDef(&inst)) {
       if (!isLive) {
-        boundary.deadDefs.push_back(cast<SILNode>(&inst));
+        deadDefs.push_back(cast<SILNode>(&inst));
       }
       isLive = false;
     }
     // Note: the same instruction could potentially be both a dead def and last
     // user. The liveness boundary supports this, although it won't happen in
     // any context where we care about inserting code on the boundary.
-    if (!isLive && isInterestingUser(&inst)) {
-      boundary.lastUsers.push_back(&inst);
+    if (!isLive && liveness.isInterestingUser(&inst)) {
+      lastUsers.push_back(&inst);
       isLive = true;
     }
   }
   if (!isLive) {
     for (SILArgument *deadArg : block->getArguments()) {
-      if (defs.contains(deadArg)) {
-        boundary.deadDefs.push_back(deadArg);
+      if (liveness.defs.contains(deadArg)) {
+        deadDefs.push_back(deadArg);
       }
     }
     if (auto *predBB = block->getSinglePredecessorBlock()) {
-      if (getBlockLiveness(predBB) == PrunedLiveBlocks::LiveOut) {
-        boundary.boundaryEdges.push_back(block);
+      if (liveness.getBlockLiveness(predBB) == PrunedLiveBlocks::LiveOut) {
+        boundaryEdges.push_back(block);
       }
     }
   }
   // All live-within blocks must contain a boundary.
-  assert(isLiveOut
-         || (prevCount < boundary.deadDefs.size() + boundary.lastUsers.size())
-         && "findBoundariesInBlock must be called on a live block");
+  assert(isLiveOut ||
+         (prevCount < deadDefs.size() + lastUsers.size()) &&
+             "findBoundariesInBlock must be called on a live block");
+}
+
+void PrunedLivenessBlockBoundary::findBoundaryInMultiDefBlock(
+    SILBasicBlock *block, bool isLiveOut,
+    const MultiDefPrunedLiveness &liveness) {
+  bool isLive = isLiveOut;
+  for (auto &inst : llvm::reverse(*block)) {
+    // Check if the instruction is a def before checking whether it is a
+    // use. The same instruction can be both a dead def and boundary use.
+    if (liveness.isDef(&inst)) {
+      if (!isLive) {
+        endBlocks.push_back(block);
+        return;
+      }
+      isLive = false;
+    }
+    if (!isLive && liveness.isInterestingUser(&inst)) {
+      endBlocks.push_back(block);
+      return;
+    }
+  }
+  if (!isLive) {
+    for (SILArgument *deadArg : block->getArguments()) {
+      if (liveness.defs.contains(deadArg)) {
+        endBlocks.push_back(block);
+        return;
+      }
+    }
+    if (auto *predBB = block->getSinglePredecessorBlock()) {
+      if (liveness.getBlockLiveness(predBB) == PrunedLiveBlocks::LiveOut) {
+        boundaryEdges.push_back(block);
+        return;
+      }
+    }
+  }
 }
 
 LiveRangeSummary MultiDefPrunedLiveness::computeSimple() {