[Reachability] Added findBarriersBeforeInsts.

Author: nate-chandler

include/swift/SILOptimizer/Analysis/Reachability.h

@@ -888,6 +888,32 @@ void IterativeBackwardReachability<Effects>::Result::setEffectForBlock(
   }
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: findBarriersBeforeInstructions
+//===----------------------------------------------------------------------===//
+
+using llvm::ArrayRef;
+using llvm::function_ref;
+
+struct ReachableBarriers final {
+  /// Instructions which are deinit barriers.
+  llvm::SmallVector<SILInstruction *, 4> instructions;
+
+  /// Blocks one of whose phis is a deinit barrier.
+  llvm::SmallVector<SILBasicBlock *, 4> phis;
+
+  llvm::SmallVector<SILBasicBlock *, 4> blocks;
+
+  ReachableBarriers() {}
+  ReachableBarriers(ReachableBarriers const &) = delete;
+  ReachableBarriers &operator=(ReachableBarriers const &) = delete;
+};
+
+void findBarriersBeforeInstructions(
+    ArrayRef<SILInstruction *> roots, SILBasicBlock *defBlock,
+    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,117 @@
+//=----------- 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;
+
+namespace FindBarriersBeforeInstructions {
+
+struct Context final {
+  SILFunction &function;
+  SILBasicBlock *defBlock;
+  ArrayRef<SILInstruction *> roots;
+};
+
+/// 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 Dataflow final {
+  using Reachability = IterativeBackwardReachability<Dataflow>;
+  using Effect = Reachability::Effect;
+  Context const &context;
+  function_ref<bool(SILInstruction *)> isBarrier;
+  ReachableBarriers &barriers;
+  Reachability::Result result;
+  Reachability reachability;
+
+public:
+  Dataflow(Context const &context, ReachableBarriers &barriers,
+           function_ref<bool(SILInstruction *)> isBarrier)
+      : context(context), isBarrier(isBarrier), barriers(barriers),
+        result(&context.function),
+        reachability(&context.function, nullptr, *this, result) {}
+  Dataflow(Dataflow const &) = delete;
+  Dataflow &operator=(Dataflow const &) = delete;
+
+  void run();
+
+private:
+  friend Reachability;
+
+  /// IterativeBackwardReachability::Effects
+
+  auto gens() { return context.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.blocks.push_back(block);
+  }
+};
+
+Dataflow::Effect Dataflow::effectForInstruction(SILInstruction *instruction) {
+  if (llvm::is_contained(context.roots, instruction))
+    return Effect::Gen();
+  auto barrier = isBarrier(instruction);
+  return barrier ? Effect::Kill() : Effect::NoEffect();
+}
+
+Dataflow::Effect Dataflow::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 Dataflow::run() {
+  reachability.initialize();
+  reachability.solve();
+  reachability.findBarriers(*this);
+}
+
+void run(Context &context, ReachableBarriers &barriers,
+         function_ref<bool(SILInstruction *)> isBarrier) {
+  Dataflow flow(context, barriers, isBarrier);
+  flow.run();
+}
+
+} // namespace FindBarriersBeforeInstructions
+
+void swift::findBarriersBeforeInstructions(
+    ArrayRef<SILInstruction *> roots, SILBasicBlock *defBlock,
+    SILFunction &function, ReachableBarriers &barriers,
+    function_ref<bool(SILInstruction *)> isBarrier) {
+  FindBarriersBeforeInstructions::Context context = {function, defBlock, roots};
+  return run(context, barriers, isBarrier);
+}