[SSADestroyHoisting] Aliasable addr args respect deinit barriers.

Previously, all arguments using the inout convention were hoisted
ignoring deinit barriers.  That was incorrect because @inout_aliasable
addresses are modifications but aren't exclusive.  Here, that's fixed by
only allowing arguments with the @inout convention to be hoisted.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -821,11 +821,17 @@ void SSADestroyHoisting::run() {
   // Arguments enclose everything.
   for (auto *arg : getFunction()->getArguments()) {
     if (arg->getType().isAddress()) {
-      bool isInout = cast<SILFunctionArgument>(arg)
-                         ->getArgumentConvention()
-                         .isInoutConvention();
-      changed |= hoistDestroys(arg, /*ignoreDeinitBarriers=*/
-                               isInout, remainingDestroyAddrs, deleter);
+      auto convention = cast<SILFunctionArgument>(arg)->getArgumentConvention();
+      // This is equivalent to writing
+      //
+      //     convention == SILArgumentConvention::Indirect_Inout
+      //
+      // but communicates the rationale: in order to ignore deinit barriers, the
+      // address must be exclusively accessed and be a modification.
+      bool ignoreDeinitBarriers = convention.isInoutConvention() &&
+                                  convention.isExclusiveIndirectParameter();
+      changed |= hoistDestroys(arg, ignoreDeinitBarriers, remainingDestroyAddrs,
+                               deleter);
     }
   }
 

test/SILOptimizer/hoist_destroy_addr.sil

@@ -255,6 +255,21 @@ entry(%instance : @none $TrivialStruct):
     return %retval : $()
 }
 
+// CHECK-LABEL: sil [ossa] @nohoist_inout_aliasable : {{.*}} {
+// CHECK:         apply
+// CHECK:         destroy_addr
+// CHECK-LABEL: } // end sil function 'nohoist_inout_aliasable'
+sil [ossa] @nohoist_inout_aliasable : $@convention(thin) (@inout_aliasable X) -> () {
+entry(%addr : $*X):
+  %value = load [copy] %addr : $*X
+  %unknown = function_ref @unknown : $@convention(thin) () -> ()
+  apply %unknown() : $@convention(thin) () -> ()
+  destroy_addr %addr : $*X
+  store %value to [init] %addr : $*X
+  %tuple = tuple ()
+  return %tuple : $()
+}
+
 // Fold destroy_addr and a load [copy] into a load [take] even when that
 // load [take] is guarded by an access scope.
 //
@@ -426,4 +441,3 @@ entry(%instance : @owned $X):
   dealloc_stack %addr_outer : $*X
   return %value : $X
 }
-