[SILOptimizer] Added findDeinitBarriers.

Author: nate-chandler

include/swift/SILOptimizer/Utils/DeinitBarrierFinding.h

@@ -0,0 +1,53 @@
+//===- DeinitBarrierFinding.h - Find deinit barriers from roots -*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// Given a set of roots, find the deinit barriers that exist between it and the
+// those instructions which the client says are already barriers (think users).
+//===----------------------------------------------------------------------===//
+#include "llvm/ADT/STLFunctionalExtras.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+
+class SILBasicBlock;
+class SILFunction;
+class SILInstruction;
+class BasicCalleeAnalysis;
+
+using llvm::ArrayRef;
+using llvm::function_ref;
+
+namespace DeinitBarrierFinding {
+/// How destroy_value hoisting is obstructed.
+struct Barriers 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;
+
+  Barriers() {}
+  Barriers(Barriers const &) = delete;
+  Barriers &operator=(Barriers const &) = delete;
+};
+
+} // namespace DeinitBarrierFinding
+
+void findDeinitBarriersAboveInstructions(
+    ArrayRef<SILInstruction *> roots, SILBasicBlock *defBlock,
+    SILFunction &function, BasicCalleeAnalysis *calleeAnalysis,
+    DeinitBarrierFinding::Barriers &barriers,
+    function_ref<bool(SILInstruction *)> isBarrier);
+} // namespace swift

lib/SILOptimizer/Utils/DeinitBarrierFinding.cpp

@@ -0,0 +1,153 @@
+//=-- DeinitBarrierFinding.cpp - Find deinit barriers above instructions. ---=//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+/// Given a list of instructions, find the deinit barriers that are above them.
+//===----------------------------------------------------------------------===//
+
+#include "swift/SILOptimizer/Utils/DeinitBarrierFinding.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
+#include "swift/SILOptimizer/Analysis/Reachability.h"
+
+using namespace swift;
+using namespace DeinitBarrierFinding;
+
+namespace {
+
+struct Context final {
+  SILFunction &function;
+  BasicCalleeAnalysis *calleeAnalysis;
+  SILBasicBlock *defBlock;
+  ArrayRef<SILInstruction *> roots;
+};
+
+/// Works backwards from the current location of destroy_values to the earliest
+/// place they can be hoisted to.
+///
+/// Implements IterativeBackwardReachability::Effects
+/// Implements IterativeBackwardReachability::bindBarriers::Visitor
+class Dataflow final {
+  using Reachability = IterativeBackwardReachability<Dataflow>;
+  using Effect = Reachability::Effect;
+  Context const &context;
+  function_ref<bool(SILInstruction *)> isBarrier;
+  Barriers &barriers;
+  Reachability::Result result;
+  Reachability reachability;
+
+  enum class Classification { Barrier, Other };
+
+public:
+  Dataflow(Context const &context, Barriers &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;
+
+  Classification classifyInstruction(SILInstruction *);
+
+  bool classificationIsBarrier(Classification);
+
+  /// 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::bindBarriers::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::Classification
+Dataflow::classifyInstruction(SILInstruction *instruction) {
+  if (isBarrier(instruction)) {
+    return Classification::Barrier;
+  }
+  if (isDeinitBarrier(instruction, context.calleeAnalysis)) {
+    return Classification::Barrier;
+  }
+  return Classification::Other;
+}
+
+bool Dataflow::classificationIsBarrier(Classification classification) {
+  switch (classification) {
+  case Classification::Barrier:
+    return true;
+  case Classification::Other:
+    return false;
+  }
+  llvm_unreachable("exhaustive switch not exhaustive?!");
+}
+
+Dataflow::Effect Dataflow::effectForInstruction(SILInstruction *instruction) {
+  if (llvm::is_contained(context.roots, instruction))
+    return Effect::Gen();
+  auto classification = classifyInstruction(instruction);
+  return classificationIsBarrier(classification) ? Effect::Kill()
+                                                 : Effect::NoEffect();
+}
+
+Dataflow::Effect Dataflow::effectForPhi(SILBasicBlock *block) {
+  assert(llvm::all_of(block->getArguments(),
+                      [&](auto argument) { return PhiValue(argument); }));
+
+  bool isBarrier =
+      llvm::any_of(block->getPredecessorBlocks(), [&](auto *predecessor) {
+        return classificationIsBarrier(
+            classifyInstruction(predecessor->getTerminator()));
+      });
+  return isBarrier ? Effect::Kill() : Effect::NoEffect();
+}
+
+void Dataflow::run() {
+  reachability.initialize();
+  reachability.solve();
+  reachability.findBarriers(*this);
+}
+
+void run(Context &context, Barriers &barriers,
+         function_ref<bool(SILInstruction *)> isBarrier) {
+  Dataflow flow(context, barriers, isBarrier);
+  flow.run();
+}
+
+} // namespace
+
+void swift::findDeinitBarriersAboveInstructions(
+    ArrayRef<SILInstruction *> roots, SILBasicBlock *defBlock,
+    SILFunction &function, BasicCalleeAnalysis *calleeAnalysis,
+    DeinitBarrierFinding::Barriers &barriers,
+    function_ref<bool(SILInstruction *)> isBarrier) {
+  Context context = {function, calleeAnalysis, defBlock, roots};
+  return run(context, barriers, isBarrier);
+}