[LVA] Update ignore instructions RLE and DSE.

RLE can ignore end_access, set_deallocating, dealloc_ref, begin_access,
and strong_release instructions.

DSE can ignore end_access, set_deallocating, begin_access, and sometimes
strong_Release.

Author: zoecarver

lib/SILOptimizer/Transforms/DeadStoreElimination.cpp

@@ -161,6 +161,8 @@ static bool isDeadStoreInertInstruction(SILInstruction *Inst) {
   case SILInstructionKind::DeallocRefInst:
   case SILInstructionKind::CondFailInst:
   case SILInstructionKind::FixLifetimeInst:
+  case SILInstructionKind::EndAccessInst:
+  case SILInstructionKind::SetDeallocatingInst:
     return true;
   default:
     return false;
@@ -1140,6 +1142,28 @@ void DSEContext::processInstruction(SILInstruction *I, DSEKind Kind) {
     processStoreInst(I, Kind);
   } else if (isa<DebugValueAddrInst>(I)) {
     processDebugValueAddrInst(I, Kind);
+  } else if (isa<BeginAccessInst>(I)) {
+    // Do the same thing here as in RLE. Begin access writes/reads memory only
+    // if one of its users writes/reads memory. We will look at all of its users
+    // and we can project to the source memory location so, if there are any
+    // actual writes/reads of memory we will catch them there so, we can ignore
+    // begin_access here.
+    return;
+  } else if (auto *release = dyn_cast<StrongReleaseInst>(I)) {
+    // If the strong release operand type can't have a custom destructor it's
+    // OK.
+    if (release->getOperand()->getType().getClassOrBoundGenericClass() ==
+        nullptr)
+      return;
+    // For strong releases, we have to prove that the strong release won't
+    // envoke the destructor. For now, we just try to find a set_deallocating
+    // instruction that indicates the life-ending strong_release has been
+    // devirtualized. TODO: there should be a better way to do this.
+    for (auto *use : release->getOperand()->getUses()) {
+      if (isa<SetDeallocatingInst>(use->getUser()))
+        return;
+    }
+    processUnknownReadInst(I, Kind);
   } else if (I->mayReadFromMemory()) {
     processUnknownReadInst(I, Kind);
   }  

lib/SILOptimizer/Transforms/RedundantLoadElimination.cpp

@@ -160,6 +160,9 @@ static bool isRLEInertInstruction(SILInstruction *Inst) {
   case SILInstructionKind::IsEscapingClosureInst:
   case SILInstructionKind::IsUniqueInst:
   case SILInstructionKind::FixLifetimeInst:
+  case SILInstructionKind::EndAccessInst:
+  case SILInstructionKind::SetDeallocatingInst:
+  case SILInstructionKind::DeallocRefInst:
     return true;
   default:
     return false;
@@ -1089,6 +1092,18 @@ void BlockState::processInstructionWithKind(RLEContext &Ctx,
     return;
   }
 
+  // Begin access writes to memory only if one of its users writes to memory.
+  // We will look at all of its users and we can project to the source memory
+  // location so, if there are any actual writes to memory we will catch them
+  // there so, we can ignore begin_access here.
+  if (isa<BeginAccessInst>(Inst))
+    return;
+
+  // If the load is valid, then this strong release won't invoke the destructor.
+  // So we can ignore it.
+  if (isa<StrongReleaseInst>(Inst))
+    return;
+
   // If this instruction has side effects, but is inert from a load store
   // perspective, skip it.
   if (isRLEInertInstruction(Inst))

test/SILOptimizer/dead_store_elim.sil

@@ -1501,3 +1501,25 @@ bb0(%0 : $*foo):
   %20 = tuple()
   return %20 : $()
 }
+
+// Check that begin_access, end_access, strong_release, set_deallocating, and dealloc_ref don't prevent optimization.
+// CHECK-LABEL: ignore_read_write
+// CHECK: bb0
+// CHECK-NOT: store
+// CHECK-LABEL: end sil function 'ignore_read_write'
+sil @ignore_read_write : $@convention(thin) () -> Int {
+bb0:
+  %1 = alloc_ref [stack] $foo
+  strong_retain %1 : $foo
+  %2 = integer_literal $Builtin.Int64, 0
+  %3 = struct $Int (%2 : $Builtin.Int64)
+  %4 = ref_element_addr %1 : $foo, #foo.a
+  %5 = begin_access [modify] [dynamic] [no_nested_conflict] %4 : $*Int
+  store %3 to %5 : $*Int
+  end_access %5 : $*Int
+  strong_release %1 : $foo
+  set_deallocating %1 : $foo
+  dealloc_ref %1 : $foo
+  dealloc_ref [stack] %1 : $foo
+  return %3 : $Int
+}