Add a utility to check for edges into dead-end regions.

This is subtly different from just checking whether the destination of
an edge is dead-end, because edges *internal* to dead-end regions
generally still need to be treated normally. Fundamentally, such an edge
must be part of a loop.

Author: rjmccall

include/swift/SIL/BasicBlockUtils.h

@@ -14,6 +14,7 @@
 #define SWIFT_SIL_BASICBLOCKUTILS_H
 
 #include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockData.h"
 #include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/SetVector.h"
@@ -125,6 +126,213 @@ class DeadEndBlocks {
   void propagateNewlyReachableBlocks(unsigned startIdx);
 };
 
+/// A utility for detecting edges that enter a dead-end region.
+///
+/// A dead-end region is a strongly-connected component of the CFG
+/// consisting solely of dead-end blocks (i.e. from which it is not
+/// possible to reach a function exit). The strongly-connected
+/// components of a CFG form a DAG: once control flow from the entry
+/// block has entered an SCC, it cannot return to an earlier SCC
+/// (because then by definition they would have to be the same SCC).
+///
+/// Note that the interior edges of a dead-end region do not *enter*
+/// the region. Only edges from an earlier SCC count as edges into
+/// the region.
+///
+/// For example, in this CFG:
+///
+///      /-> bb1 -> bb2 -> return
+///   bb0
+///      \-> bb3 -> bb4 -> bb5 -> unreachable
+///           ^      |
+///           \------/
+///
+/// The edge from bb0 to bb3 enters a new dead-end region, as does
+/// the edge from bb4 to bb5. The edge from bb4 to bb3 does not
+/// enter a new region because it is an internal edge of its region.
+///
+/// Edges that enter dead-end regions are special in SIL because certain
+/// joint post-dominance rules are relaxed for them. For example, the
+/// stack does need not be consistent on different edges into a dead-end
+/// region.
+class DeadEndEdges {
+  enum : unsigned {
+    /// A region data value which represents that a block is unreachable
+    /// from the entry block.
+    UnreachableRegionData = 0,
+
+    /// A region data value which represents that a block is reachable
+    /// from the entry block but not in a dead-end region.
+    NonDeadEndRegionData = 1,
+
+    /// A value that must be added to a region index when storing it in
+    /// a region data.
+    ///
+    /// This should be the smallest number such that
+    ///   (IndexOffset << IndexShift)
+    /// is always greater than all of the special region-data values
+    /// above.
+    IndexOffset = 1,
+
+    /// A mask which can be applied to a region to say that it contains
+    /// a cycle. This slightly optimizes the check in isDeadEndEdge for
+    /// the common case where regions do not have cycles.
+    HasCycleMask = 0x1,
+
+    /// The amount to shift the region index by when storing it in a
+    /// region data.
+    ///
+    /// This should be the smallest number such that an arbitrary value
+    /// left-shifted by it will not have any of the mask bits set.
+    IndexShift = 1,
+  };
+
+  /// An integer representing what we know about the SCC partition that
+  /// a particular block is in. All blocks in the same region store the
+  /// same value to make comparisons faster.
+  ///
+  /// Either:
+  /// - UnreachableRegionData, representing a block that cannot be
+  ///   reached from the entry block;
+  /// - NonDeadEndRegionData, representing a block that can be reached
+  ///   from the entry block but is not in a dead-end region; or
+  /// - an encoded region index, representing a block that is in a
+  ///   dead-end region.
+  ///
+  /// A region index is a unique value in 0..<numDeadEndRegions,
+  /// selected for a specific dead-end SCC. It is encoded by adding
+  /// IndexOffset, left-shifting by IndexShift, and then or'ing
+  /// in any appropriate summary bits like HasCycleMask.
+  ///
+  /// If regionDataForBlock isn't initialized, the function contains
+  /// no dead-end blocks.
+  std::optional<BasicBlockData<unsigned>> regionDataForBlock;
+
+  /// The total number of dead-end regions in the function.
+  unsigned numDeadEndRegions;
+
+  static constexpr bool isDeadEndRegion(unsigned regionData) {
+    return regionData >= (IndexOffset << IndexShift);
+  }
+
+  static unsigned getIndexFromRegionData(unsigned regionData) {
+    assert(isDeadEndRegion(regionData));
+    return (regionData >> IndexShift) - IndexOffset;
+  }
+
+public:
+  /// Perform the analysis on the given function. An existing
+  /// DeadEndBlocks analysis can be passed in to avoid needing to
+  /// compute it anew.
+  explicit DeadEndEdges(SILFunction *F,
+                        DeadEndBlocks *deadEndBlocks = nullptr);
+
+  /// Return the number of dead-end regions in the function.
+  unsigned getNumDeadEndRegions() const {
+    return numDeadEndRegions;
+  }
+
+  /// Does the given CFG edge enter a new dead-end region?
+  ///
+  /// If so, return the index of the dead-end region it enters.
+  std::optional<unsigned>
+  entersDeadEndRegion(SILBasicBlock *srcBB, SILBasicBlock *dstBB) const {
+    // If we didn't initialize regionDataForBlock, there are no dead-end
+    // edges at all.
+    if (!regionDataForBlock)
+      return std::nullopt;
+
+    auto dstRegionData = (*regionDataForBlock)[dstBB];
+
+    // If the destination block is not in a dead-end region, this is
+    // not a dead-end edge.
+    if (!isDeadEndRegion(dstRegionData)) return std::nullopt;
+
+    unsigned dstRegionIndex = getIndexFromRegionData(dstRegionData);
+
+    // If the destination block is in a region with no cycles, every edge
+    // to it is a dead-end edge; no need to look up the source block's
+    // region.
+    if (!(dstRegionData & HasCycleMask)) return dstRegionIndex;
+
+    // Otherwise, it's a dead-end edge if the source block is in a
+    // different region. (That region may or may not be itself be a
+    // dead-end region.)
+    auto srcRegionData = (*regionDataForBlock)[srcBB];
+    if (srcRegionData != dstRegionData) {
+      return dstRegionIndex;
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  /// A helper class for tracking visits to edges into dead-end regions.
+  ///
+  /// The client is assumed to be doing a walk of the function which will
+  /// naturally visit each edge exactly once. This set allows the client
+  /// to track when they've processed every edge to a particular dead-end
+  /// region and can therefore safely enter it.
+  ///
+  /// The set does not count edges from unreachable blocks by default. This
+  /// matches the normal expectation that the client is doing a CFG search
+  /// and won't try to visit edges from unreachable blocks. If you are
+  /// walking the function in some other, e.g. by iterating the blocks,
+  /// you must pass `true` for `includeUnreachableEdges`.
+  class VisitingSet {
+    const DeadEndEdges &edges;
+
+    /// Stores the remaining number of edges for each dead-end region
+    /// in the function.
+    SmallVector<unsigned> remainingEdgesForRegion;
+
+    friend class DeadEndEdges;
+    explicit VisitingSet(const DeadEndEdges &parent,
+                         bool includeUnreachableEdges);
+
+  public:
+    /// Record that a dead-end edge to the given block was visited.
+    ///
+    /// Returns true if this was the last dead-end edge to the region
+    /// containing the block.
+    ///
+    /// Do not call this multiple times for the same edge. Do not
+    /// call this for an unreachable edge if you did not create the
+    /// set including unreachable edges.
+    bool visitEdgeTo(SILBasicBlock *destBB) {
+      assert(edges.regionDataForBlock &&
+             "visiting dead-end edge in function that has none");
+      auto destRegionData = (*edges.regionDataForBlock)[destBB];
+      assert(isDeadEndRegion(destRegionData) &&
+             "destination block is not in a dead-end region");
+
+      auto destRegionIndex = getIndexFromRegionData(destRegionData);
+      assert(remainingEdgesForRegion[destRegionIndex] > 0 &&
+             "no remaining dead-end edges for region; visited "
+             "multiple times?");
+
+      auto numRemaining = --remainingEdgesForRegion[destRegionIndex];
+      return numRemaining == 0;
+    }
+
+    /// Return true if all of the edges have been visited.
+    bool visitedAllEdges() const {
+      for (auto count : remainingEdgesForRegion) {
+        if (count) return false;
+      }
+      return true;
+    }
+  };
+
+  /// Create a counter set which can be used to count edges in the
+  /// dead-end regions.
+  ///
+  /// By default, the set does not include edges from unreachable blocks.
+  VisitingSet createVisitingSet(bool includeUnreachableEdges = false) const {
+    return VisitingSet(*this, includeUnreachableEdges);
+  }
+};
+
+
 /// Compute joint-postdominating set for \p dominatingBlock and \p
 /// dominatedBlockSet found by walking up the CFG from the latter to the
 /// former.