Add PrunedLivenessBoundary mini-abstraction

Simple wrapper to compute the boundary of PrunedLiveness.

Pervasively useful utility for working with OSSA reference lifetimes
and borrow scopes.

This can also replace the implementation in
CanonicalOSSALifetime. This will greatly simplify that utility's
logic, preparing it to handle diagnostics (like move-only SILValue
checking) and other features.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -94,6 +94,8 @@
 
 namespace swift {
 
+class DeadEndBlocks;
+
 /// Discover "pruned" liveness for an arbitrary set of uses. The client builds
 /// liveness by first initializing "def" blocks, then incrementally feeding uses
 /// to updateForUse().
@@ -133,10 +135,18 @@ class PrunedLiveBlocks {
   // the value is also liveout of the block.
   llvm::SmallDenseMap<SILBasicBlock *, bool, 4> liveBlocks;
 
+  // Optional vector of live blocks for clients that deterministically iterate.
+  SmallVectorImpl<SILBasicBlock *> *discoveredBlocks;
+
   // Once the first use has been seen, no definitions can be added.
   SWIFT_ASSERT_ONLY_DECL(bool seenUse = false);
 
 public:
+  PrunedLiveBlocks(SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
+      : discoveredBlocks(discoveredBlocks) {
+    assert(!discoveredBlocks || discoveredBlocks->empty());
+  }
+
   bool empty() const { return liveBlocks.empty(); }
 
   void clear() {
@@ -146,6 +156,12 @@ class PrunedLiveBlocks {
 
   unsigned numLiveBlocks() const { return liveBlocks.size(); }
 
+  /// If the constructor was provided with a vector to populate, then this
+  /// returns the list of all live blocks with no duplicates.
+  ArrayRef<SILBasicBlock *> getDiscoveredBlocks() const {
+    return *discoveredBlocks;
+  }
+
   void initializeDefBlock(SILBasicBlock *defBB) {
     assert(!seenUse && "cannot initialize more defs with partial liveness");
     markBlockLive(defBB, LiveWithin);
@@ -165,6 +181,8 @@ class PrunedLiveBlocks {
   void markBlockLive(SILBasicBlock *bb, IsLive isLive) {
     assert(isLive != Dead && "erasing live blocks isn't implemented.");
     liveBlocks[bb] = (isLive == LiveOut);
+    if (discoveredBlocks)
+      discoveredBlocks->push_back(bb);
   }
 
   void computeUseBlockLiveness(SILBasicBlock *userBB);
@@ -173,13 +191,18 @@ class PrunedLiveBlocks {
 /// PrunedLiveness tracks PrunedLiveBlocks along with "interesting" use
 /// points. The set of interesting uses is a superset of all uses on the
 /// liveness boundary. Filtering out uses that are obviously not on the liveness
-/// boundary improves efficiency over tracking all uses. Additionally, all
-/// interesting uses that are "lifetime-ending" are flagged. These uses must be
-/// on the liveness boundary by their nature, regardless of any other uses. It
-/// is up to the client to determine which uses are lifetime-ending. In OSSA,
-/// the lifetime-ending property might be detemined by
+/// boundary improves efficiency over tracking all uses.
+///
+/// Additionally, all interesting uses that are potentially "lifetime-ending"
+/// are flagged. These instruction are included as interesting use points, even
+/// if they don't occur on the liveness boundary. Lifetime-ending uses that end
+/// up on the final liveness boundary may be used to end the lifetime. It is up
+/// to the client to determine which uses are potentially lifetime-ending. In
+/// OSSA, the lifetime-ending property might be detemined by
 /// OwnershipConstraint::isLifetimeEnding(). In non-OSSA, it might be determined
-/// by deallocation.
+/// by deallocation. If a lifetime-ending use ends up within the liveness
+/// boundary, then it is up to the client to figure out how to "extend" the
+/// lifetime beyond those uses.
 ///
 /// Note: unlike OwnershipLiveRange, this represents a lifetime in terms of the
 /// CFG boundary rather that the use set, and, because it is "pruned", it only
@@ -201,6 +224,9 @@ class PrunedLiveness {
   llvm::SmallDenseMap<SILInstruction *, bool, 8> users;
 
 public:
+  PrunedLiveness(SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
+      : liveBlocks(discoveredBlocks) {}
+
   bool empty() const {
     assert(!liveBlocks.empty() || users.empty());
     return liveBlocks.empty();
@@ -213,6 +239,12 @@ class PrunedLiveness {
 
   unsigned numLiveBlocks() const { return liveBlocks.numLiveBlocks(); }
 
+  /// If the constructor was provided with a vector to populate, then this
+  /// returns the list of all live blocks with no duplicates.
+  ArrayRef<SILBasicBlock *> getDiscoveredBlocks() const {
+    return liveBlocks.getDiscoveredBlocks();
+  }
+
   void initializeDefBlock(SILBasicBlock *defBB) {
     liveBlocks.initializeDefBlock(defBB);
   }
@@ -228,6 +260,9 @@ class PrunedLiveness {
   /// Returns false if this cannot be done.
   bool updateForBorrowingOperand(Operand *op);
 
+  /// Update this liveness to extend across the given liveness.
+  void extendAcrossLiveness(PrunedLiveness &otherLiveness);
+
   PrunedLiveBlocks::IsLive getBlockLiveness(SILBasicBlock *bb) const {
     return liveBlocks.getBlockLiveness(bb);
   }
@@ -245,7 +280,49 @@ class PrunedLiveness {
 
   /// Return true if \p inst occurs before the liveness boundary. Used when the
   /// client already knows that inst occurs after the start of liveness.
-  bool isWithinBoundary(SILInstruction *inst);
+  bool isWithinBoundary(SILInstruction *inst) const;
+
+  bool areUsesWithinBoundary(ArrayRef<Operand *> uses,
+                             DeadEndBlocks &deadEndBlocks) const;
+};
+
+/// Record the last use points and CFG edges that form the boundary of
+/// PrunedLiveness.
+struct PrunedLivenessBoundary {
+  SmallVector<SILInstruction *, 8> lastUsers;
+  SmallVector<SILBasicBlock *, 8> boundaryEdges;
+
+  /// Visit the point at which a lifetime-ending instruction must be inserted,
+  /// excluding dead-end blocks. This is only useful when it is known that none
+  /// of the lastUsers ends the lifetime, for example when creating a new borrow
+  /// scope to enclose all uses.
+  void visitInsertionPoints(
+      llvm::function_ref<void(SILBasicBlock::iterator insertPt)> visitor,
+      DeadEndBlocks *deBlocks = nullptr);
+
+  /// Compute the boundary from the blocks discovered during liveness analysis.
+  ///
+  /// Precondition: \p liveness.getDiscoveredBlocks() is a valid list of all
+  /// live blocks with no duplicates.
+  ///
+  /// The computed boundary will completely post-dominate, including dead end
+  /// paths. The client should query DeadEndBlocks to ignore those dead end
+  /// paths.
+  void compute(const PrunedLiveness &liveness);
+
+  /// 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
+  /// of live blocks during liveness analysis. It's ok if postDomBlocks has
+  /// duplicates or extraneous blocks, as long as they jointly post-dominate all
+  /// live blocks that aren't on dead-end paths.
+  ///
+  /// If the jointly post-dominating destroys do not include dead end paths,
+  /// then any uses on those paths will not be included in the boundary. The
+  /// resulting partial boundary will have holes along those paths. The dead end
+  /// successors of blocks in this live set on are not necessarilly identified
+  /// by DeadEndBlocks.
+  void compute(const PrunedLiveness &liveness,
+               ArrayRef<SILBasicBlock *> postDomBlocks);
 };
 
 } // namespace swift

lib/SIL/Utils/PrunedLiveness.cpp

@@ -11,6 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SIL/PrunedLiveness.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
+#include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 
 using namespace swift;
@@ -117,7 +119,14 @@ bool PrunedLiveness::updateForBorrowingOperand(Operand *op) {
   return true;
 }
 
-bool PrunedLiveness::isWithinBoundary(SILInstruction *inst) {
+void PrunedLiveness::extendAcrossLiveness(PrunedLiveness &otherLivesness) {
+  // update this liveness for all the interesting users in otherLivesness.
+  for (std::pair<SILInstruction *, bool> userAndEnd : otherLivesness.users) {
+    updateForUse(userAndEnd.first, userAndEnd.second);
+  }
+}
+
+bool PrunedLiveness::isWithinBoundary(SILInstruction *inst) const {
   SILBasicBlock *block = inst->getParent();
   switch (getBlockLiveness(block)) {
   case PrunedLiveBlocks::Dead:
@@ -141,3 +150,116 @@ bool PrunedLiveness::isWithinBoundary(SILInstruction *inst) {
   }
   return false;
 }
+
+bool PrunedLiveness::areUsesWithinBoundary(ArrayRef<Operand *> uses,
+                                           DeadEndBlocks &deadEndBlocks) const {
+  for (auto *use : uses) {
+    auto *user = use->getUser();
+    if (!isWithinBoundary(user) && !deadEndBlocks.isDeadEnd(user->getParent()))
+      return false;
+  }
+  return true;
+}
+
+void PrunedLivenessBoundary::visitInsertionPoints(
+    llvm::function_ref<void(SILBasicBlock::iterator insertPt)> visitor,
+    DeadEndBlocks *deBlocks) {
+  for (SILInstruction *user : lastUsers) {
+    if (!isa<TermInst>(user)) {
+      visitor(std::next(user->getIterator()));
+      continue;
+    }
+    auto *predBB = user->getParent();
+    for (SILBasicBlock *succ : predBB->getSuccessors()) {
+      if (deBlocks && deBlocks->isDeadEnd(succ))
+        continue;
+
+      assert(succ->getSinglePredecessorBlock() == predBB);
+      visitor(succ->begin());
+    }
+  }
+  for (SILBasicBlock *edge : boundaryEdges) {
+    if (deBlocks && deBlocks->isDeadEnd(edge))
+      continue;
+
+    visitor(edge->begin());
+  }
+}
+
+// Use \p liveness to find the last use in \p bb and add it to \p
+// boundary.lastUsers.
+static void findLastUserInBlock(SILBasicBlock *bb,
+                                PrunedLivenessBoundary &boundary,
+                                const PrunedLiveness &liveness) {
+  for (auto instIter = bb->rbegin(), endIter = bb->rend(); instIter != endIter;
+       ++instIter) {
+    auto *inst = &*instIter;
+    if (liveness.isInterestingUser(inst) == PrunedLiveness::NonUser)
+      continue;
+
+    boundary.lastUsers.push_back(inst);
+  }
+  llvm_unreachable("No user in LiveWithin block");
+}
+
+void PrunedLivenessBoundary::compute(const PrunedLiveness &liveness) {
+  for (SILBasicBlock *bb : liveness.getDiscoveredBlocks()) {
+    // Process each block that has not been visited and is not LiveOut.
+    switch (liveness.getBlockLiveness(bb)) {
+    case PrunedLiveBlocks::LiveOut:
+      for (SILBasicBlock *succBB : bb->getSuccessors()) {
+        if (liveness.getBlockLiveness(succBB) == PrunedLiveBlocks::Dead) {
+          boundaryEdges.push_back(succBB);
+        }
+      }
+      break;
+    case PrunedLiveBlocks::LiveWithin: {
+      // The liveness boundary is inside this block. Insert a final destroy
+      // inside the block if it doesn't already have one.
+      findLastUserInBlock(bb, *this, liveness);
+      break;
+    }
+    case PrunedLiveBlocks::Dead:
+      llvm_unreachable("All discovered blocks must be live");
+    }
+  }
+}
+
+void PrunedLivenessBoundary::compute(const PrunedLiveness &liveness,
+                                     ArrayRef<SILBasicBlock *> postDomBlocks) {
+  if (postDomBlocks.empty())
+    return; // all paths must be dead-ends or infinite loops
+
+  BasicBlockWorklist blockWorklist(postDomBlocks[0]->getParent());
+
+  // Visit each post-dominating block as the starting point for a
+  // backward CFG traversal.
+  for (auto *bb : postDomBlocks) {
+    blockWorklist.push(bb);
+  }
+  while (auto *bb = blockWorklist.pop()) {
+    // Process each block that has not been visited and is not LiveOut.
+    switch (liveness.getBlockLiveness(bb)) {
+    case PrunedLiveBlocks::LiveOut:
+      // A lifetimeEndBlock may be determined to be LiveOut after analyzing the
+      // extended liveness. It is irrelevent for finding the boundary.
+      break;
+    case PrunedLiveBlocks::LiveWithin: {
+      // The liveness boundary is inside this block. Insert a final destroy
+      // inside the block if it doesn't already have one.
+      findLastUserInBlock(bb, *this, liveness);
+      break;
+    }
+    case PrunedLiveBlocks::Dead:
+      // Continue searching upward to find the pruned liveness boundary.
+      for (auto *predBB : bb->getPredecessorBlocks()) {
+        if (liveness.getBlockLiveness(predBB) == PrunedLiveBlocks::LiveOut) {
+          boundaryEdges.push_back(bb);
+        } else {
+          blockWorklist.pushIfNotVisited(predBB);
+        }
+      }
+      break;
+    }
+  }
+}