[Reachability] Added findBarriersBackward.

Author: nate-chandler

include/swift/SILOptimizer/Analysis/Reachability.h

@@ -903,6 +903,41 @@ void IterativeBackwardReachability<Effects>::Result::setEffectForBlock(
   }
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: findBarriersBackward
+//===----------------------------------------------------------------------===//
+
+using llvm::ArrayRef;
+using llvm::function_ref;
+
+struct ReachableBarriers final {
+  /// Instructions which are barriers.
+  llvm::SmallVector<SILInstruction *, 4> instructions;
+
+  /// Blocks one of whose phis is a barrier.
+  llvm::SmallVector<SILBasicBlock *, 4> phis;
+
+  /// Boundary edges; edges such that
+  /// (1) the target block is reachable-at-begin
+  /// (2) at least one adjacent edge's target is not reachable-at-begin.
+  llvm::SmallVector<SILBasicBlock *, 4> edges;
+
+  ReachableBarriers() {}
+  ReachableBarriers(ReachableBarriers const &) = delete;
+  ReachableBarriers &operator=(ReachableBarriers const &) = delete;
+};
+
+/// Walk backwards from the specified \p roots through at the earliest \p
+/// initialBlocks to populate \p barriers by querying \p isBarrier along the
+/// way.
+///
+/// If \p initialBlocks is empty, dataflow continues to the begin of the
+/// function.
+void findBarriersBackward(ArrayRef<SILInstruction *> roots,
+                          ArrayRef<SILBasicBlock *> initialBlocks,
+                          SILFunction &function, ReachableBarriers &barriers,
+                          function_ref<bool(SILInstruction *)> isBarrier);
+
 } // end namespace swift
 
 #endif

lib/SILOptimizer/Analysis/CMakeLists.txt

@@ -22,6 +22,7 @@ target_sources(swiftSILOptimizer PRIVATE
   NonLocalAccessBlockAnalysis.cpp
   PassManagerVerifierAnalysis.cpp
   ProtocolConformanceAnalysis.cpp
+  Reachability.cpp
   RCIdentityAnalysis.cpp
   SimplifyInstruction.cpp
   TypeExpansionAnalysis.cpp

lib/SILOptimizer/Analysis/Reachability.cpp

@@ -0,0 +1,109 @@
+//=----------- Reachability.cpp - Walking from roots to barriers. -----------=//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILOptimizer/Analysis/Reachability.h"
+
+using namespace swift;
+
+/// Walks backwards from the specified roots to find barrier instructions, phis,
+/// and blocks via the isBarrier predicate.
+///
+/// Implements IterativeBackwardReachability::Effects
+/// Implements IterativeBackwardReachability::findBarriers::Visitor
+class FindBarriersBackwardDataflow final {
+  using Reachability =
+      IterativeBackwardReachability<FindBarriersBackwardDataflow>;
+  using Effect = Reachability::Effect;
+  ArrayRef<SILInstruction *> const roots;
+  function_ref<bool(SILInstruction *)> isBarrier;
+  ReachableBarriers &barriers;
+  Reachability::Result result;
+  Reachability reachability;
+
+public:
+  FindBarriersBackwardDataflow(SILFunction &function,
+                               ArrayRef<SILInstruction *> roots,
+                               ArrayRef<SILBasicBlock *> stopBlocks,
+                               ReachableBarriers &barriers,
+                               function_ref<bool(SILInstruction *)> isBarrier)
+      : roots(roots), isBarrier(isBarrier), barriers(barriers),
+        result(&function), reachability(&function, stopBlocks, *this, result) {}
+  FindBarriersBackwardDataflow(FindBarriersBackwardDataflow const &) = delete;
+  FindBarriersBackwardDataflow &
+  operator=(FindBarriersBackwardDataflow const &) = delete;
+
+  void run();
+
+private:
+  friend Reachability;
+
+  /// IterativeBackwardReachability::Effects
+
+  auto gens() { return roots; }
+
+  Effect effectForInstruction(SILInstruction *);
+  Effect effectForPhi(SILBasicBlock *);
+
+  auto localGens() { return result.localGens; }
+
+  bool isLocalGen(SILInstruction *instruction) {
+    return result.localGens.contains(instruction);
+  }
+
+  /// IterativeBackwardReachability::findBarriers::Visitor
+
+  void visitBarrierInstruction(SILInstruction *instruction) {
+    barriers.instructions.push_back(instruction);
+  }
+
+  void visitBarrierPhi(SILBasicBlock *block) { barriers.phis.push_back(block); }
+
+  void visitBarrierBlock(SILBasicBlock *block) {
+    barriers.edges.push_back(block);
+  }
+};
+
+FindBarriersBackwardDataflow::Effect
+FindBarriersBackwardDataflow::effectForInstruction(
+    SILInstruction *instruction) {
+  if (llvm::is_contained(roots, instruction))
+    return Effect::Gen();
+  auto barrier = isBarrier(instruction);
+  return barrier ? Effect::Kill() : Effect::NoEffect();
+}
+
+FindBarriersBackwardDataflow::Effect
+FindBarriersBackwardDataflow::effectForPhi(SILBasicBlock *block) {
+  assert(llvm::all_of(block->getArguments(),
+                      [&](auto argument) { return PhiValue(argument); }));
+
+  bool barrier =
+      llvm::any_of(block->getPredecessorBlocks(), [&](auto *predecessor) {
+        return isBarrier(predecessor->getTerminator());
+      });
+  return barrier ? Effect::Kill() : Effect::NoEffect();
+}
+
+void FindBarriersBackwardDataflow::run() {
+  reachability.initialize();
+  reachability.solve();
+  reachability.findBarriers(*this);
+}
+
+void swift::findBarriersBackward(
+    ArrayRef<SILInstruction *> roots, ArrayRef<SILBasicBlock *> initialBlocks,
+    SILFunction &function, ReachableBarriers &barriers,
+    function_ref<bool(SILInstruction *)> isBarrier) {
+  FindBarriersBackwardDataflow flow(function, roots, initialBlocks, barriers,
+                                    isBarrier);
+  flow.run();
+}