[SSADestroyHoisting] Don't fold into unrelated scopes.

If a load [copy] appears near the end of the scope protecting access to
another address and a destroy_addr of the loaded address appears
afterwards, don't fold the destroy into the scope.  The reason is that
doing so could allow a deinit which previously executed outside the
exclusivity scope to subsequently execute within it.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -634,9 +634,13 @@ bool HoistDestroys::foldBarrier(SILInstruction *barrier,
                                 const KnownStorageUses &knownUses,
                                 const DeinitBarriers &deinitBarriers) {
   if (auto *eai = dyn_cast<EndAccessInst>(barrier)) {
+    auto *bai = eai->getBeginAccess();
+    // Don't hoist a destroy into an unrelated access scope.
+    if (stripAccessMarkers(bai) != stripAccessMarkers(storageRoot))
+      return false;
     SILInstruction *instruction = eai;
     while ((instruction = instruction->getPreviousInstruction())) {
-      if (instruction == eai->getBeginAccess())
+      if (instruction == bai)
         return false;
       if (foldBarrier(instruction, storageRoot))
         return true;

test/SILOptimizer/hoist_destroy_addr.sil

@@ -398,3 +398,32 @@ entry(%instance : @owned $X):
 
   return %loaded : $X
 }
+
+// Don't fold a destroy_addr with a load [copy] that occurs within the scope of
+// an access to unrelated storage.
+//
+// CHECK-LABEL: sil [ossa] @nofold_into_unrelated_barrier_scope : {{.*}} {
+// CHECK:         load [copy]
+// CHECK-LABEL: } // end sil function 'nofold_into_unrelated_barrier_scope'
+sil [ossa] @nofold_into_unrelated_barrier_scope : $@convention(thin) (@owned X) -> (@owned X) {
+entry(%instance : @owned $X):
+  %copy = copy_value %instance : $X
+  %addr_outer = alloc_stack $X
+  %addr_inner = alloc_stack $X
+  store %copy to [init] %addr_outer : $*X
+  store %instance to [init] %addr_inner : $*X
+
+  %access = begin_access [modify] [static] %addr_outer : $*X
+  apply undef(%access) : $@convention(thin) (@inout X) -> ()
+  %unknown = function_ref @unknown : $@convention(thin) () -> ()
+  destroy_addr %access : $*X
+  apply %unknown() : $@convention(thin) () -> ()
+  %value = load [copy] %addr_inner : $*X
+  end_access %access : $*X
+  destroy_addr %addr_inner : $*X
+
+  dealloc_stack %addr_inner : $*X
+  dealloc_stack %addr_outer : $*X
+  return %value : $X
+}
+