[NFC] Port isDeinitBarrier to Swift.

Added new C++-to-Swift callback for isDeinitBarrier.

And pass it CalleeAnalysis so it can depend on function effects.  For
now, the argument is ignored.  And, all callers just pass nullptr.

Promoted to API the mayAccessPointer component predicate of
isDeinitBarrier which needs to remain in C++.  That predicate will also
depends on function effects.  For that reason, it too is now passed a
BasicCalleeAnalysis and is moved into SILOptimizer.

Also, added more conservative versions of isDeinitBarrier and
maySynchronize which will never consider side-effects.

Author: nate-chandler

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -16,6 +16,15 @@ import SIL
 public struct CalleeAnalysis {
   let bridged: BridgedCalleeAnalysis
 
+  static func register() {
+    CalleeAnalysis_register(
+      // isDeinitBarrierFn:
+      { (inst : BridgedInstruction, bca: BridgedCalleeAnalysis) -> Bool in
+        return inst.instruction.isDeinitBarrier(bca.analysis)
+      }
+    )
+  }
+
   public func getCallees(callee: Value) -> FunctionArray? {
     let bridgedFuncs = CalleeAnalysis_getCallees(bridged, callee.bridged)
     if bridgedFuncs.incomplete != 0 {
@@ -45,6 +54,24 @@ public struct CalleeAnalysis {
   }
 }
 
+extension Instruction {
+  public final func maySynchronize(_ analysis: CalleeAnalysis) -> Bool {
+    if let site = self as? FullApplySite {
+      return true
+    }
+    return maySynchronizeNotConsideringSideEffects
+  }
+
+  /// Whether lifetime ends of lexical values may safely be hoisted over this
+  /// instruction.
+  ///
+  /// Deinitialization barriers constrain variable lifetimes. Lexical
+  /// end_borrow, destroy_value, and destroy_addr cannot be hoisted above them.
+  public final func isDeinitBarrier(_ analysis: CalleeAnalysis) -> Bool {
+    return mayAccessPointer || mayLoadWeakOrUnowned || maySynchronize(analysis)
+  }
+}
+
 public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let bridged: BridgedCalleeList
 
@@ -55,3 +82,9 @@ public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
     return BridgedFunctionArray_get(bridged, index).function
   }
 }
+// Bridging utilities
+
+extension BridgedCalleeAnalysis {
+  public var analysis: CalleeAnalysis { .init(bridged: self) }
+}
+

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -17,6 +17,7 @@ import Parse
 @_cdecl("initializeSwiftModules")
 public func initializeSwiftModules() {
   registerSILClasses()
+  registerSwiftAnalyses()
   registerSwiftPasses()
   initializeSwiftParseModules()
 }
@@ -75,3 +76,7 @@ private func registerSwiftPasses() {
   registerPass(rangeDumper, { rangeDumper.run($0) })
   registerPass(runUnitTests, { runUnitTests.run($0) })
 }
+
+private func registerSwiftAnalyses() {
+  CalleeAnalysis.register()
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -108,6 +108,41 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
     return SILInstruction_hasUnspecifiedSideEffects(bridged)
   }
 
+  public final var mayAccessPointer: Bool {
+    return swift_mayAccessPointer(bridged)
+  }
+
+  /// Whether this instruction loads or copies a value whose storage does not
+  /// increment the stored value's reference count.
+  public final var mayLoadWeakOrUnowned: Bool {
+    switch self {
+    case is LoadWeakInst, is LoadUnownedInst, is StrongCopyUnownedValueInst, is StrongCopyUnmanagedValueInst:
+      return true
+    default:
+      return false
+    }
+  }
+
+  /// Conservatively, whether this instruction could involve a synchronization
+  /// point like a memory barrier, lock or syscall.
+  public final var maySynchronizeNotConsideringSideEffects: Bool {
+    switch self {
+    case is FullApplySite, is EndApplyInst, is AbortApplyInst:
+      return true
+    default:
+      return false
+    }
+  }
+
+  /// Conservatively, whether this instruction could be a barrier to hoisting
+  /// destroys.
+  ///
+  /// Does not consider function so effects, so every apply is treated as a
+  /// barrier.
+  public final var mayBeDeinitBarrierNotConsideringSideEffects: Bool {
+    return mayAccessPointer || mayLoadWeakOrUnowned || maySynchronizeNotConsideringSideEffects
+  }
+
   public func visitReferencedFunctions(_ cl: (Function) -> ()) {
   }
 
@@ -618,6 +653,10 @@ final public class ProjectBoxInst : SingleValueInstruction, UnaryInstruction {
 
 final public class CopyValueInst : SingleValueInstruction, UnaryInstruction {}
 
+final public class StrongCopyUnownedValueInst : SingleValueInstruction, UnaryInstruction {}
+
+final public class StrongCopyUnmanagedValueInst : SingleValueInstruction, UnaryInstruction  {}
+
 final public class EndCOWMutationInst : SingleValueInstruction, UnaryInstruction {}
 
 final public

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -60,6 +60,8 @@ public func registerSILClasses() {
   register(ReleaseValueInst.self)
   register(DestroyValueInst.self)
   register(DestroyAddrInst.self)
+  register(StrongCopyUnownedValueInst.self)
+  register(StrongCopyUnmanagedValueInst.self)
   register(InjectEnumAddrInst.self)
   register(LoadInst.self)
   register(LoadWeakInst.self)

docs/SIL.rst

@@ -2444,10 +2444,10 @@ required.
 Deinit Barriers
 ```````````````
 
-Deinit barriers (see swift::isDeinitBarrier) are instructions which would be
-affected by the side effects of deinitializers.  To maintain the order of
-effects that is visible to the programmer, destroys of lexical values cannot be
-reordered with respect to them.  There are three kinds:
+Deinit barriers (see Instruction.isDeinitBarrier(_:)) are instructions which
+would be affected by the side effects of deinitializers.  To maintain the order
+of effects that is visible to the programmer, destroys of lexical values cannot
+be reordered with respect to them.  There are three kinds:
 
 1. synchronization points (locks, memory barriers, syscalls, etc.)
 2. loads of weak or unowned values

include/swift/SIL/MemAccessUtils.h

@@ -232,11 +232,9 @@ inline bool accessKindMayConflict(SILAccessKind a, SILAccessKind b) {
   return !(a == SILAccessKind::Read && b == SILAccessKind::Read);
 }
 
-/// Return true if \p instruction is a deinitialization barrier.
-///
-/// Deinitialization barriers constrain variable lifetimes. Lexical end_borrow,
-/// destroy_value, and destroy_addr cannot be hoisted above them.
-bool isDeinitBarrier(SILInstruction *instruction);
+/// Whether \p instruction accesses storage whose representation is unidentified
+/// such as by reading a pointer.
+bool mayAccessPointer(SILInstruction *instruction);
 
 } // end namespace swift
 

include/swift/SIL/SILBridging.h

@@ -364,6 +364,7 @@ swift::SILDebugLocation SILInstruction_getLocation(BridgedInstruction inst);
 BridgedMemoryBehavior SILInstruction_getMemBehavior(BridgedInstruction inst);
 bool SILInstruction_mayRelease(BridgedInstruction inst);
 bool SILInstruction_hasUnspecifiedSideEffects(BridgedInstruction inst);
+bool swift_mayAccessPointer(BridgedInstruction inst);
 
 BridgedInstruction MultiValueInstResult_getParent(BridgedMultiValueResult result);
 SwiftInt MultiValueInstResult_getIndex(BridgedMultiValueResult result);

include/swift/SIL/SILInstruction.h

@@ -649,12 +649,6 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Can this instruction abort the program in some manner?
   bool mayTrap() const;
 
-  /// Involves a synchronization point like a memory barrier, lock or syscall.
-  ///
-  /// TODO: We need side-effect analysis and library annotation for this to be
-  ///       a reasonable API.  For now, this is just a placeholder.
-  bool maySynchronize() const;
-
   /// Returns true if the given instruction is completely identical to RHS.
   bool isIdenticalTo(const SILInstruction *RHS) const {
     return isIdenticalTo(RHS,

include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h

@@ -230,6 +230,9 @@ class BasicCalleeAnalysis : public SILAnalysis {
   }
 };
 
+bool isDeinitBarrier(SILInstruction *const instruction,
+                     BasicCalleeAnalysis *bca);
+
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/OptimizerBridging.h

@@ -40,6 +40,10 @@ typedef struct {
   void * _Nullable bca;
 } BridgedCalleeAnalysis;
 
+typedef bool (* _Nonnull InstructionIsDeinitBarrierFn)(BridgedInstruction, BridgedCalleeAnalysis bca);
+
+void CalleeAnalysis_register(InstructionIsDeinitBarrierFn isDeinitBarrierFn);
+
 typedef struct {
   void * _Nullable dea;
 } BridgedDeadEndBlocksAnalysis;

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -34,6 +34,7 @@ namespace swift {
 
 class DominanceInfo;
 class DeadEndBlocks;
+class BasicCalleeAnalysis;
 template <class T> class NullablePtr;
 
 /// Transform a Use Range (Operand*) into a User Range (SILInstruction *)

lib/SIL/IR/SILInstruction.cpp

@@ -1358,13 +1358,6 @@ bool SILInstruction::mayTrap() const {
   }
 }
 
-bool SILInstruction::maySynchronize() const {
-  // TODO: We need side-effect analysis and library annotation for this to be
-  //       a reasonable API.  For now, this is just a placeholder.
-  return isa<FullApplySite>(this) || isa<EndApplyInst>(this) ||
-         isa<AbortApplyInst>(this);
-}
-
 bool SILInstruction::isMetaInstruction() const {
   // Every instruction that implements getVarInfo() should be in this list.
   switch (getKind()) {

lib/SIL/Utils/MemAccessUtils.cpp

@@ -16,6 +16,8 @@
 #include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/SIL/Consumption.h"
 #include "swift/SIL/DynamicCasts.h"
+#include "swift/SIL/SILBridging.h"
+#include "swift/SIL/SILBridgingUtils.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILUndef.h"
@@ -400,12 +402,7 @@ bool swift::isLetAddress(SILValue address) {
 //                      MARK: Deinitialization barriers.
 //===----------------------------------------------------------------------===//
 
-static bool isBarrierApply(FullApplySite) {
-  // TODO: check side effect analysis
-  return true;
-}
-
-static bool mayAccessPointer(SILInstruction *instruction) {
+bool swift::mayAccessPointer(SILInstruction *instruction) {
   if (!instruction->mayReadOrWriteMemory())
     return false;
   bool isUnidentified = false;
@@ -417,22 +414,8 @@ static bool mayAccessPointer(SILInstruction *instruction) {
   return isUnidentified;
 }
 
-static bool mayLoadWeakOrUnowned(SILInstruction *instruction) {
-  // TODO: It is possible to do better here by looking at the address that is
-  //       being loaded.
-  return isa<LoadWeakInst>(instruction) || isa<LoadUnownedInst>(instruction)
-    || isa<StrongCopyUnownedValueInst>(instruction)
-    || isa<StrongCopyUnmanagedValueInst>(instruction);
-}
-
-bool swift::isDeinitBarrier(SILInstruction *instruction) {
-  if (instruction->maySynchronize()) {
-    if (auto apply = FullApplySite::isa(instruction)) {
-      return isBarrierApply(apply);
-    }
-    return true;
-  }
-  return mayLoadWeakOrUnowned(instruction) || mayAccessPointer(instruction);
+bool swift_mayAccessPointer(BridgedInstruction inst) {
+  return mayAccessPointer(castToInst(inst));
 }
 
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Analysis/BasicCalleeAnalysis.cpp

@@ -15,8 +15,10 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/Statistic.h"
-#include "swift/SIL/SILModule.h"
+#include "swift/SIL/MemAccessUtils.h"
+#include "swift/SIL/SILBridging.h"
 #include "swift/SIL/SILBridgingUtils.h"
+#include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/OptimizerBridging.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "llvm/Support/Compiler.h"
@@ -363,3 +365,41 @@ BridgedFunction BridgedFunctionArray_get(BridgedCalleeList callees,
   assert(index >= 0 && iter < cl.end());
   return {*iter};
 }
+
+static InstructionIsDeinitBarrierFn instructionIsDeinitBarrierFunction;
+
+void CalleeAnalysis_register(
+    InstructionIsDeinitBarrierFn instructionIsDeinitBarrierFn) {
+  instructionIsDeinitBarrierFunction = instructionIsDeinitBarrierFn;
+}
+
+/// Implementation of mayBeDeinitBarrierNotConsideringSideEffects for use only
+/// during bootstrapping or in compilers that lack Swift sources.
+///
+/// TODO: Remove.
+static bool
+isDeinitBarrierWithoutEffectsCpp(SILInstruction *const instruction) {
+  auto mayLoadWeakOrUnowned = [](SILInstruction *const instruction) {
+    return isa<LoadWeakInst>(instruction) ||
+           isa<LoadUnownedInst>(instruction) ||
+           isa<StrongCopyUnownedValueInst>(instruction) ||
+           isa<StrongCopyUnmanagedValueInst>(instruction);
+  };
+  auto maySynchronize = [](SILInstruction *const instruction) {
+    return isa<FullApplySite>(instruction) || isa<EndApplyInst>(instruction) ||
+           isa<AbortApplyInst>(instruction);
+  };
+  return mayAccessPointer(instruction) || mayLoadWeakOrUnowned(instruction) ||
+         maySynchronize(instruction);
+}
+
+bool swift::isDeinitBarrier(SILInstruction *const instruction,
+                            BasicCalleeAnalysis *bca) {
+  if (!instructionIsDeinitBarrierFunction) {
+    return isDeinitBarrierWithoutEffectsCpp(instruction);
+  }
+  BridgedInstruction inst = {
+      cast<SILNode>(const_cast<SILInstruction *>(instruction))};
+  BridgedCalleeAnalysis analysis = {bca};
+  return instructionIsDeinitBarrierFunction(inst, analysis);
+}

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -97,9 +97,11 @@
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Reachability.h"
 #include "swift/SILOptimizer/Analysis/VisitBarrierAccessScopes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "swift/SILOptimizer/Utils/InstructionDeleter.h"
 
 using namespace swift;
@@ -339,7 +341,7 @@ DeinitBarriers::classifyInstruction(SILInstruction *inst) const {
   if (knownUses.storageUsers.contains(inst)) {
     return Classification::Barrier;
   }
-  if (!ignoreDeinitBarriers && isDeinitBarrier(inst)) {
+  if (!ignoreDeinitBarriers && isDeinitBarrier(inst, nullptr)) {
     return Classification::Barrier;
   }
   if (auto *eai = dyn_cast<EndAccessInst>(inst)) {

lib/SILOptimizer/Utils/LexicalDestroyHoisting.cpp

@@ -19,6 +19,7 @@
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Reachability.h"
 #include "swift/SILOptimizer/Analysis/VisitBarrierAccessScopes.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h"
@@ -194,7 +195,7 @@ Dataflow::classifyInstruction(SILInstruction *instruction) {
                ? Classification::Barrier
                : Classification::Other;
   }
-  if (isDeinitBarrier(instruction)) {
+  if (isDeinitBarrier(instruction, nullptr)) {
     return Classification::Barrier;
   }
   return Classification::Other;

lib/SILOptimizer/Utils/ShrinkBorrowScope.cpp

@@ -20,6 +20,7 @@
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/Reachability.h"
 #include "swift/SILOptimizer/Analysis/VisitBarrierAccessScopes.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h"
@@ -244,7 +245,7 @@ Dataflow::classifyInstruction(SILInstruction *instruction) {
                ? Classification::Barrier
                : Classification::Other;
   }
-  if (isDeinitBarrier(instruction)) {
+  if (isDeinitBarrier(instruction, nullptr)) {
     return Classification::Barrier;
   }
   return Classification::Other;