[Exclusivity] Handle copy_addr+destroy_addr folding with end_access markers.

Author: atrick

lib/SIL/SILBuilder.cpp

@@ -157,19 +157,38 @@ SILBasicBlock *SILBuilder::splitBlockForFallthrough() {
   return NewBB;
 }
 
+static bool setAccessToDeinit(BeginAccessInst *beginAccess) {
+  // It's possible that AllocBoxToStack could catch some cases that
+  // AccessEnforcementSelection does not promote to [static]. Ultimately, this
+  // should be an assert, but only after we the two passes can be fixes to share
+  // a common analysis.
+  if (beginAccess->getEnforcement() == SILAccessEnforcement::Dynamic)
+    return false;
+
+  beginAccess->setAccessKind(SILAccessKind::Deinit);
+  return true;
+}
+
 PointerUnion<CopyAddrInst *, DestroyAddrInst *>
 SILBuilder::emitDestroyAddr(SILLocation Loc, SILValue Operand) {
   // Check to see if the instruction immediately before the insertion point is a
   // copy_addr from the specified operand.  If so, we can fold this into the
   // copy_addr as a take.
+  BeginAccessInst *beginAccess = nullptr;
   auto I = getInsertionPoint(), BBStart = getInsertionBB()->begin();
   while (I != BBStart) {
     auto *Inst = &*--I;
 
     if (auto CA = dyn_cast<CopyAddrInst>(Inst)) {
-      if (CA->getSrc() == Operand && !CA->isTakeOfSrc()) {
-        CA->setIsTakeOfSrc(IsTake);
-        return CA;
+      if (!CA->isTakeOfSrc()) {
+        if (CA->getSrc() == Operand && !CA->isTakeOfSrc()) {
+          CA->setIsTakeOfSrc(IsTake);
+          return CA;
+        }
+        if (CA->getSrc() == beginAccess && setAccessToDeinit(beginAccess)) {
+          CA->setIsTakeOfSrc(IsTake);
+          return CA;
+        }
       }
     }
 
@@ -178,6 +197,15 @@ SILBuilder::emitDestroyAddr(SILLocation Loc, SILValue Operand) {
     if (isa<DeallocStackInst>(Inst))
       continue;
 
+    // An end_access of the same address may be able to be rewritten as a
+    // [deinit] access.
+    if (auto endAccess = dyn_cast<EndAccessInst>(Inst)) {
+      if (endAccess->getSource() == Operand) {
+        beginAccess = endAccess->getBeginAccess();
+        continue;
+      }
+    }
+
     // This code doesn't try to prove tricky validity constraints about whether
     // it is safe to push the destroy_addr past interesting instructions.
     if (Inst->mayHaveSideEffects())

test/SILOptimizer/allocbox_to_stack_ownership.sil

@@ -1024,3 +1024,38 @@ bb3:
   unreachable
 }
 
+// Test that
+//  begin_access [read], copy_addr, end_access, destroy_addr
+// is folded into
+//  begin_access [deinit], copy_addr [take], end_access
+//
+// CHECK-LABEL: sil @deinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) {
+// CHECK: bb0(%0 : @trivial $*T, %1 : @trivial $*T, %2 : @trivial $*T):
+// CHECK: [[STK:%.*]] = alloc_stack $T, var, name "x"
+// CHECK: copy_addr %2 to [initialization] [[STK]] : $*T
+// CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*T
+// CHECK: copy_addr [[READ]] to [initialization] %0 : $*T
+// CHECK: end_access [[READ]] : $*T
+// CHECK: [[READ:%.*]] = begin_access [deinit] [static] [[STK]] : $*T
+// CHECK: copy_addr [take] [[READ]] to [initialization] %1 : $*T
+// CHECK: end_access [[READ]] : $*T
+// CHECK: dealloc_stack [[STK]] : $*T
+// CHECK: destroy_addr %2 : $*T
+// CHECK: return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function 'deinit_access'
+sil @deinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) {
+bb0(%0 : @owned $*T, %1 : @owned $*T, %2 : @owned $*T):
+  %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T>, var, name "x"
+  %5 = project_box %4 : $<τ_0_0> { var τ_0_0 } <T>, 0
+  copy_addr %2 to [initialization] %5 : $*T
+  %7 = begin_access [read] [static] %5 : $*T
+  copy_addr %7 to [initialization] %0 : $*T
+  end_access %7 : $*T
+  %10 = begin_access [read] [static] %5 : $*T
+  copy_addr %10 to [initialization] %1 : $*T
+  end_access %10 : $*T
+  destroy_value %4 : $<τ_0_0> { var τ_0_0 } <T>
+  destroy_addr %2 : $*T
+  %15 = tuple ()
+  return %15 : $()
+}