[SSADestroyHoisting] Fold into access scopes.

If the destroy_addr's barrier is an end_access, try to fold with copies
or loads that occur inside the scope so long as there are no barriers
between the destroy_addr and the instruction it is to be fold with.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -217,6 +217,11 @@ class DeinitBarriers {
 
   void compute() { DestroyReachability(*this).solveBackward(); }
 
+  bool isBarrier(SILInstruction *instruction) const {
+    return classificationIsBarrier(classifyInstruction(
+        instruction, ignoreDeinitBarriers, storageDefInst, knownUses));
+  };
+
 private:
   DeinitBarriers(DeinitBarriers const &) = delete;
   DeinitBarriers &operator=(DeinitBarriers const &) = delete;
@@ -367,7 +372,10 @@ class HoistDestroys {
 protected:
   SILFunction *getFunction() const { return storageRoot->getFunction(); }
 
-  bool foldBarrier(SILInstruction *barrier);
+  bool foldBarrier(SILInstruction *barrier, SILValue accessScope);
+
+  bool foldBarrier(SILInstruction *barrier, const KnownStorageUses &knownUses,
+                   const DeinitBarriers &deinitBarriers);
 
   void insertDestroy(SILInstruction *barrier, SILInstruction *insertBefore,
                      const KnownStorageUses &knownUses);
@@ -408,7 +416,7 @@ bool HoistDestroys::rewriteDestroys(const KnownStorageUses &knownUses,
   for (SILInstruction *barrier : deinitBarriers.barriers) {
     auto *barrierBlock = barrier->getParent();
     if (barrier != barrierBlock->getTerminator()) {
-      if (!foldBarrier(barrier))
+      if (!foldBarrier(barrier, knownUses, deinitBarriers))
         insertDestroy(barrier, barrier->getNextInstruction(), knownUses);
       continue;
     }
@@ -455,9 +463,10 @@ bool HoistDestroys::rewriteDestroys(const KnownStorageUses &knownUses,
   return deleter.hadCallbackInvocation();
 }
 
-bool HoistDestroys::foldBarrier(SILInstruction *barrier) {
+bool HoistDestroys::foldBarrier(SILInstruction *barrier, SILValue storageRoot) {
   if (auto *load = dyn_cast<LoadInst>(barrier)) {
-    if (load->getOperand() == storageRoot) {
+    if (stripAccessMarkers(load->getOperand()) ==
+        stripAccessMarkers(storageRoot)) {
       if (load->getOwnershipQualifier() == LoadOwnershipQualifier::Copy) {
         load->setOwnershipQualifier(LoadOwnershipQualifier::Take);
         return true;
@@ -468,7 +477,7 @@ bool HoistDestroys::foldBarrier(SILInstruction *barrier) {
     }
   }
   if (auto *copy = dyn_cast<CopyAddrInst>(barrier)) {
-    if (copy->getSrc() == storageRoot) {
+    if (stripAccessMarkers(copy->getSrc()) == stripAccessMarkers(storageRoot)) {
       assert(!copy->isTakeOfSrc());
       copy->setIsTakeOfSrc(IsTake);
       return true;
@@ -477,6 +486,23 @@ bool HoistDestroys::foldBarrier(SILInstruction *barrier) {
   return false;
 }
 
+bool HoistDestroys::foldBarrier(SILInstruction *barrier,
+                                const KnownStorageUses &knownUses,
+                                const DeinitBarriers &deinitBarriers) {
+  if (auto *eai = dyn_cast<EndAccessInst>(barrier)) {
+    SILInstruction *instruction = eai;
+    while ((instruction = instruction->getPreviousInstruction())) {
+      if (instruction == eai->getBeginAccess())
+        return false;
+      if (foldBarrier(instruction, storageRoot))
+        return true;
+      if (deinitBarriers.isBarrier(instruction))
+        return false;
+    }
+  }
+  return foldBarrier(barrier, storageRoot);
+}
+
 // \p barrier may be null if the destroy is at function entry.
 void HoistDestroys::insertDestroy(SILInstruction *barrier,
                                   SILInstruction *insertBefore,

test/SILOptimizer/hoist_destroy_addr.sil

@@ -254,3 +254,147 @@ entry(%instance : @none $TrivialStruct):
     %retval = tuple ()
     return %retval : $()
 }
+
+// Fold destroy_addr and a load [copy] into a load [take] even when that
+// load [take] is guarded by an access scope.
+//
+// CHECK-LABEL: sil [ossa] @fold_scoped_load : {{.*}} {
+// CHECK: load [take]
+// CHECK-LABEL: // end sil function 'fold_scoped_load'
+sil [ossa] @fold_scoped_load : $@convention(thin) (@owned S) -> (@owned S) {
+entry(%instance : @owned $S):
+  %addr = alloc_stack $S
+  %store_scope = begin_access [modify] [static] %addr : $*S
+  store %instance to [init] %store_scope : $*S
+  end_access %store_scope : $*S
+  %load_scope = begin_access [read] [static] %addr : $*S
+  %value = load [copy] %load_scope : $*S
+  end_access %load_scope : $*S
+  destroy_addr %addr : $*S
+  dealloc_stack %addr : $*S
+  return %value : $S
+}
+
+// Don't fold when there's a deinit barrier in the way.
+//
+// CHECK-LABEL: sil [ossa] @nofold_scoped_load_barrier : {{.*}} {
+// CHECK: load [copy]
+// CHECK-LABEL: // end sil function 'nofold_scoped_load_barrier'
+sil [ossa] @nofold_scoped_load_barrier : $@convention(thin) (@owned S) -> (@owned S) {
+entry(%instance : @owned $S):
+  %addr = alloc_stack $S
+  %store_scope = begin_access [modify] [static] %addr : $*S
+  store %instance to [init] %store_scope : $*S
+  end_access %store_scope : $*S
+  %load_scope = begin_access [read] [static] %addr : $*S
+  %value = load [copy] %load_scope : $*S
+  %unknown = function_ref @unknown : $@convention(thin) () -> ()
+  apply %unknown() : $@convention(thin) () -> ()
+  end_access %load_scope : $*S
+  destroy_addr %addr : $*S
+  dealloc_stack %addr : $*S
+  return %value : $S
+}
+
+// Don't fold with a copy_addr of a struct_element_addr.
+//
+// CHECK-LABEL: sil [ossa] @nofold_scoped_copy_addr_projection : {{.*}} {
+// CHECK:         load [copy]
+// CHECK-LABEL: // end sil function 'nofold_scoped_copy_addr_projection'
+sil [ossa] @nofold_scoped_copy_addr_projection : $@convention(thin) (@owned S) -> (@owned S) {
+entry(%instance : @owned $S):
+  %addr = alloc_stack $S
+  %store_scope = begin_access [modify] [static] %addr : $*S
+  store %instance to [init] %store_scope : $*S
+  end_access %store_scope : $*S
+  %load_scope = begin_access [read] [static] %addr : $*S
+  %field_addr = struct_element_addr %load_scope : $*S, #S.x
+  %field = load [copy] %field_addr : $*X
+  end_access %load_scope : $*S
+  destroy_addr %addr : $*S
+  dealloc_stack %addr : $*S
+  %value = struct $S (%field : $X)
+  return %value : $S
+}
+
+// Don't fold destroy of outer scope with struct_element_addr of inner scope.
+//
+// CHECK-LABEL: sil [ossa] @nofold_with_copy_addr_projection : {{.*}} {
+// CHECK:         copy_addr {{%[^,]+}}
+// CHECK-LABEL: // end sil function 'nofold_with_copy_addr_projection'
+sil [ossa] @nofold_with_copy_addr_projection : $@convention(thin) (@owned S) -> (@owned S) {
+entry(%instance : @owned $S):
+  %addr = alloc_stack $S
+  %addr_2 = alloc_stack $S
+  %store_scope = begin_access [modify] [static] %addr : $*S
+  store %instance to [init] %store_scope : $*S
+  end_access %store_scope : $*S
+  %outer = begin_access [read] [static] %addr : $*S
+  apply undef(%outer) : $@convention(thin) (@inout S) -> ()
+  %inner = begin_access [read] [static] %outer : $*S
+  %field_addr = struct_element_addr %inner : $*S, #S.x
+  %field_addr_2 =  struct_element_addr %addr_2 : $*S, #S.x
+  copy_addr %field_addr to [initialization] %field_addr_2 : $*X
+  end_access %inner : $*S
+  destroy_addr %outer : $*S
+  end_access %outer : $*S
+  %value = load [take] %addr_2 : $*S
+  dealloc_stack %addr_2 : $*S
+  dealloc_stack %addr : $*S
+  return %value : $S
+}
+
+// Don't fold destroy of outer scope with struct_element_addr of inner scope.
+//
+// CHECK-LABEL: sil [ossa] @fold_scoped_destroy_with_scoped_copy_addr : {{.*}} {
+// CHECK:         copy_addr [take] {{%[^,]+}}
+// CHECK-LABEL: // end sil function 'fold_scoped_destroy_with_scoped_copy_addr'
+sil [ossa] @fold_scoped_destroy_with_scoped_copy_addr : $@convention(thin) (@owned S) -> (@owned S) {
+entry(%instance : @owned $S):
+  %addr = alloc_stack $S
+  %addr_2 = alloc_stack $S
+  %store_scope = begin_access [modify] [static] %addr : $*S
+  store %instance to [init] %store_scope : $*S
+  end_access %store_scope : $*S
+  %outer = begin_access [read] [static] %addr : $*S
+  apply undef(%outer) : $@convention(thin) (@inout S) -> ()
+  %inner = begin_access [read] [static] %outer : $*S
+  copy_addr %inner to [initialization] %addr_2 : $*S
+  end_access %inner : $*S
+  destroy_addr %outer : $*S
+  end_access %outer : $*S
+  %value = load [take] %addr_2 : $*S
+  dealloc_stack %addr_2 : $*S
+  dealloc_stack %addr : $*S
+  return %value : $S
+}
+
+// Don't fold with an unrelated load [copy].
+// CHECK-LABEL: sil [ossa] @nofold_unrelated_scoped_load_copy : {{.*}} {
+// CHECK:         load [copy] 
+// CHECK:         destroy_addr
+// CHECK:         destroy_addr
+// CHECK-LABEL: // end sil function 'nofold_unrelated_scoped_load_copy'
+sil [ossa] @nofold_unrelated_scoped_load_copy : $@convention(thin) (@owned X) -> (@owned X) {
+entry(%instance : @owned $X):
+  %copy = copy_value %instance : $X
+  %addr_1 = alloc_stack $X
+  %addr_2 = alloc_stack $X
+  store %instance to [init] %addr_1 : $*X
+  store %copy to [init] %addr_2 : $*X
+
+  %access = begin_access [read] [static] %addr_1 : $*X
+  %loaded = load [copy] %access : $*X
+  end_access %access : $*X
+  destroy_addr %addr_2 : $*X
+  
+  %barrier = function_ref @unknown : $@convention(thin) () -> ()
+  apply %barrier() : $@convention(thin) () -> ()
+
+  destroy_addr %addr_1 : $*X
+
+  dealloc_stack %addr_2 : $*X
+  dealloc_stack %addr_1 : $*X
+
+  return %loaded : $X
+}