[SSADestroyHoisting] Used iterative dataflow.

Previously, SSADestroyHoisting used two pessimistic BackwardReachability
dataflows.  Here, it is made to use IterativeBackwardReachability
including a call to the optionally-used method solvePessimistic to do a
pessimistic dataflow (to find barrier access scopes) and an optimistic
dataflow (to find all barriers).

Author: nate-chandler

include/swift/SIL/CFG.h

@@ -217,10 +217,64 @@ class SILCfgTraits : public CfgTraits<SILCfgTraitsBase, SILCfgTraits> {
 template <> struct CfgTraitsFor<swift::SILBasicBlock> {
   using CfgTraits = SILCfgTraits;
 };
-
 #endif
 
 } // end llvm namespace
 
+#include "swift/SIL/BasicBlockDatastructures.h"
+
+namespace swift {
+// interface Visitor {
+//     bool isInRegion(SILBasicBlock *)
+//     void visit(SILBasicBlock *)
+// }
+template <typename Visitor>
+void visitPostOrderBackwards(SILFunction *function, SILBasicBlock *root,
+                             Visitor visitor) {
+  SmallVector<std::pair<SILBasicBlock *, SILBasicBlock::pred_iterator>, 32>
+      stack;
+  BasicBlockSet visited(function);
+  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 (!visitor.isInRegion(predecessor))
+        continue;
+      if (visited.insert(predecessor))
+        stack.push_back({predecessor, predecessor->pred_begin()});
+    }
+    visitor.visit(stack.back().first);
+    stack.pop_back();
+  }
+}
+
+// interface Visitor {
+//     bool isInRegion(SILBasicBlock *)
+//     void visit(SILBasicBlock *)
+// }
+template <typename Visitor>
+void visitSortedTopologicallyBackwards(SILFunction *function,
+                                       ArrayRef<SILBasicBlock *> roots,
+                                       Visitor &visitor) {
+  BasicBlockSet visited(function);
+  for (auto *root : roots) {
+    struct Inner {
+      Visitor &outer;
+      BasicBlockSet &visited;
+      int offset = 0;
+      Inner(Visitor &outer, BasicBlockSet &visited)
+          : outer(outer), visited(visited) {}
+      bool isInRegion(SILBasicBlock *block) {
+        return !visited.contains(block) && outer.isInRegion(block);
+      }
+      void visit(SILBasicBlock *block) { outer.visit(block); }
+    };
+    Inner inner(visitor, visited);
+    visitPostOrderBackwards(function, root, inner);
+  }
+}
+} // namespace swift
+
 #endif