[SSADestroyHoisting] Barriers use callee analysis.

Pass a BasicCalleeAnalysis instance to isDeinitBarrier.  This will
enable SSADestroyHoisting to hoist destroy_addrs over applies of
functions that are not themselves deinit barriers.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -194,6 +194,8 @@ class DestroyReachability;
 /// Step #2: Perform backward dataflow from KnownStorageUses.originalDestroys to
 /// KnownStorageUses.storageUsers to find deinitialization barriers.
 class DeinitBarriers final {
+  BasicCalleeAnalysis *calleeAnalysis;
+
 public:
   // Instructions beyond which a destroy_addr cannot be hoisted, reachable from
   // a destroy_addr.  Deinit barriers or storage uses.
@@ -219,8 +221,10 @@ class DeinitBarriers final {
 
   explicit DeinitBarriers(bool ignoreDeinitBarriers,
                           const KnownStorageUses &knownUses,
-                          SILFunction *function)
-      : ignoreDeinitBarriers(ignoreDeinitBarriers), knownUses(knownUses) {
+                          SILFunction *function,
+                          BasicCalleeAnalysis *calleeAnalysis)
+      : calleeAnalysis(calleeAnalysis),
+        ignoreDeinitBarriers(ignoreDeinitBarriers), knownUses(knownUses) {
     auto rootValue = knownUses.getStorage().getRoot();
     assert(rootValue && "HoistDestroys requires a single storage root");
     // null for function args
@@ -341,7 +345,7 @@ DeinitBarriers::classifyInstruction(SILInstruction *inst) const {
   if (knownUses.storageUsers.contains(inst)) {
     return Classification::Barrier;
   }
-  if (!ignoreDeinitBarriers && isDeinitBarrier(inst, nullptr)) {
+  if (!ignoreDeinitBarriers && isDeinitBarrier(inst, calleeAnalysis)) {
     return Classification::Barrier;
   }
   if (auto *eai = dyn_cast<EndAccessInst>(inst)) {
@@ -403,6 +407,7 @@ class HoistDestroys {
   bool ignoreDeinitBarriers;
   SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs;
   InstructionDeleter &deleter;
+  BasicCalleeAnalysis *calleeAnalysis;
 
   // Book-keeping for the rewriting stage.
   SmallPtrSet<SILInstruction *, 4> reusedDestroys;
@@ -412,12 +417,13 @@ class HoistDestroys {
 public:
   HoistDestroys(SILValue storageRoot, bool ignoreDeinitBarriers,
                 SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs,
-                InstructionDeleter &deleter)
+                InstructionDeleter &deleter,
+                BasicCalleeAnalysis *calleeAnalysis)
       : storageRoot(storageRoot), function(storageRoot->getFunction()),
         module(function->getModule()), typeExpansionContext(*function),
         ignoreDeinitBarriers(ignoreDeinitBarriers),
         remainingDestroyAddrs(remainingDestroyAddrs), deleter(deleter),
-        destroyMergeBlocks(getFunction()) {}
+        calleeAnalysis(calleeAnalysis), destroyMergeBlocks(getFunction()) {}
 
   bool perform();
 
@@ -465,7 +471,8 @@ bool HoistDestroys::perform() {
   if (!knownUses.findUses())
     return false;
 
-  DeinitBarriers deinitBarriers(ignoreDeinitBarriers, knownUses, getFunction());
+  DeinitBarriers deinitBarriers(ignoreDeinitBarriers, knownUses, getFunction(),
+                                calleeAnalysis);
   deinitBarriers.compute();
 
   // No SIL changes happen before rewriting.
@@ -829,7 +836,8 @@ void HoistDestroys::mergeDestroys(SILBasicBlock *mergeBlock) {
 
 bool hoistDestroys(SILValue root, bool ignoreDeinitBarriers,
                    SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs,
-                   InstructionDeleter &deleter) {
+                   InstructionDeleter &deleter,
+                   BasicCalleeAnalysis *calleeAnalysis) {
   LLVM_DEBUG(llvm::dbgs() << "Performing destroy hoisting on " << root);
 
   SILFunction *function = root->getFunction();
@@ -846,7 +854,7 @@ bool hoistDestroys(SILValue root, bool ignoreDeinitBarriers,
   ignoreDeinitBarriers = ignoreDeinitBarriers || !enableLexicalLifetimes;
 
   return HoistDestroys(root, ignoreDeinitBarriers, remainingDestroyAddrs,
-                       deleter)
+                       deleter, calleeAnalysis)
       .perform();
 }
 
@@ -955,17 +963,20 @@ void SSADestroyHoisting::run() {
     ++splitDestroys;
   }
 
+  auto *calleeAnalysis = getAnalysis<BasicCalleeAnalysis>();
+
   // We assume that the function is in reverse post order so visiting the
   // blocks and pushing begin_access as we see them and then popping them off
   // the end will result in hoisting inner begin_access' destroy_addrs first.
   for (auto *bai : llvm::reverse(bais)) {
     changed |= hoistDestroys(bai, /*ignoreDeinitBarriers=*/true,
-                             remainingDestroyAddrs, deleter);
+                             remainingDestroyAddrs, deleter, calleeAnalysis);
   }
   // Alloc stacks always enclose their accesses.
   for (auto *asi : asis) {
-    changed |= hoistDestroys(asi, /*ignoreDeinitBarriers=*/!asi->isLexical(),
-                             remainingDestroyAddrs, deleter);
+    changed |= hoistDestroys(asi,
+                             /*ignoreDeinitBarriers=*/!asi->isLexical(),
+                             remainingDestroyAddrs, deleter, calleeAnalysis);
   }
   // Arguments enclose everything.
   for (auto *uncastArg : getFunction()->getArguments()) {
@@ -983,7 +994,7 @@ void SSADestroyHoisting::run() {
       auto lifetime = arg->getLifetime();
       bool ignoreDeinitBarriers = ignoredByConvention || lifetime.isEagerMove();
       changed |= hoistDestroys(arg, ignoreDeinitBarriers, remainingDestroyAddrs,
-                               deleter);
+                               deleter, calleeAnalysis);
     }
   }
 

test/SILOptimizer/hoist_destroy_addr.sil

@@ -1,8 +1,10 @@
-// RUN: %target-sil-opt -opt-mode=none  -enable-sil-verify-all %s -ssa-destroy-hoisting | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECKDEB --check-prefix=CHECK-DEB
-// RUN: %target-sil-opt -opt-mode=speed -enable-sil-verify-all %s -ssa-destroy-hoisting | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECKOPT --check-prefix=CHECK-OPT
+// RUN: %target-sil-opt -opt-mode=none  -enable-sil-verify-all %s -compute-side-effects -ssa-destroy-hoisting | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECKDEB --check-prefix=CHECK-DEB
+// RUN: %target-sil-opt -opt-mode=speed -enable-sil-verify-all %s -compute-side-effects -ssa-destroy-hoisting | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECKOPT --check-prefix=CHECK-OPT
 //
 // TODO: migrate the remaining tests from destroy_hoisting.sil.
 
+// REQUIRES: swift_in_compiler
+
 sil_stage canonical
 
 import Builtin
@@ -75,6 +77,12 @@ struct STXXITXXII {
 sil @unknown : $@convention(thin) () -> ()
 sil @use_S : $@convention(thin) (@in_guaranteed S) -> ()
 
+// This function is not a synchronization point.
+sil @empty : $@convention(thin) () -> () {
+  %retval = tuple ()
+  return %retval : $()
+}
+
 sil @f_out : $@convention(thin) <T> () -> @out T
 sil @f_bool : $@convention(thin) () -> Builtin.Int1
 sil [ossa] @take_trivial_struct : $@convention(thin) (TrivialStruct) -> ()
@@ -1064,3 +1072,16 @@ entry(%instance : @owned $AnyObject):
     dealloc_stack %addr : $*AnyObject
     return %cast : $X
 }
+
+// CHECK-LABEL: sil [ossa] @hoist_over_apply_of_non_barrier_fn : {{.*}} {
+// CHECK:         destroy_addr
+// CHECK:         apply
+// CHECK-LABEL: } // end sil function 'hoist_over_apply_of_non_barrier_fn'
+sil [ossa] @hoist_over_apply_of_non_barrier_fn : $@convention(thin) (@in X) -> () {
+entry(%addr : $*X):
+  %empty = function_ref @empty : $@convention(thin) () -> ()
+  apply %empty() : $@convention(thin) () -> ()
+  destroy_addr %addr : $*X
+  %retval = tuple ()
+  return %retval : $()
+}