[SIL] Added SILCFGBackwardDFS.

The utility provides a standard way for backwards traversing a region of
a function constrained by a predicate (isInRegion) starting from some
root blocks.  It exposes a visit function for post-order and iterable
collections for post-order and reverse post-order.  Adding corresponding
pre-order functionality will be straightforward.

Author: nate-chandler

include/swift/SIL/BasicBlockUtils.h

@@ -13,8 +13,9 @@
 #ifndef SWIFT_SIL_BASICBLOCKUTILS_H
 #define SWIFT_SIL_BASICBLOCKUTILS_H
 
-#include "swift/SIL/SILValue.h"
 #include "swift/SIL/BasicBlockBits.h"
+#include "swift/SIL/BasicBlockDatastructures.h"
+#include "swift/SIL/SILValue.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -155,6 +156,81 @@ void findJointPostDominatingSet(
 bool checkDominates(SILBasicBlock *sourceBlock, SILBasicBlock *destBlock);
 #endif
 
+/// Walk depth-first the region backwards reachable from the provided roots
+/// constrained by \p region's \p isInRegion member function.
+///
+/// interface Region {
+///   /// Whether the indicated basic block is within the region of the graph
+///   /// that should be traversed.
+///   bool isInRegion(SILBasicBlock *)
+/// }
+template <typename Region>
+struct SILCFGBackwardDFS {
+  Region &region;
+  ArrayRef<SILBasicBlock *> roots;
+  Optional<SmallVector<SILBasicBlock *, 16>> cachedPostOrder;
+  Optional<BasicBlockSet> cachedVisited;
+
+  SILCFGBackwardDFS(Region &region, ArrayRef<SILBasicBlock *> roots)
+      : region(region), roots(roots) {}
+
+  /// Visit the blocks of the region in post-order.
+  ///
+  /// interface Visitor {
+  ///     /// Visit each block in topological order.
+  ///     void visit(SILBasicBlock *)
+  /// }
+  template <typename Visitor>
+  void visitPostOrder(Visitor &visitor) {
+    if (roots.empty())
+      return;
+    auto *function = roots.front()->getParent();
+    cachedVisited.emplace(function);
+    for (auto *root : roots) {
+      SmallVector<std::pair<SILBasicBlock *, SILBasicBlock::pred_iterator>, 32>
+          stack;
+      if (!region.isInRegion(root))
+        continue;
+      stack.push_back({root, root->pred_begin()});
+      while (!stack.empty()) {
+        while (stack.back().second != stack.back().first->pred_end()) {
+          auto predecessor = *stack.back().second;
+          stack.back().second++;
+          if (!region.isInRegion(predecessor))
+            continue;
+          if (cachedVisited->insert(predecessor))
+            stack.push_back({predecessor, predecessor->pred_begin()});
+        }
+        visitor.visit(stack.back().first);
+        stack.pop_back();
+      }
+    }
+  }
+
+  /// Visit the region in post-order and cache the visited blocks.
+  void cachePostOrder() {
+    if (cachedPostOrder)
+      return;
+    struct Visitor {
+      SILCFGBackwardDFS<Region> &dfs;
+      void visit(SILBasicBlock *block) {
+        dfs.cachedPostOrder->push_back(block);
+      }
+    };
+    cachedPostOrder.emplace();
+    Visitor visitor{*this};
+    visitPostOrder(visitor);
+  }
+
+  /// The region in post-order.
+  ArrayRef<SILBasicBlock *> postOrder() {
+    cachePostOrder();
+    return *cachedPostOrder;
+  };
+
+  /// The region in reverse post-order.
+  auto reversePostOrder() { return llvm::reverse(postOrder()); }
+};
 } // namespace swift
 
 #endif