SIL Optimizer: handle begin_dealloc_ref and end_init_let_ref in various optimizations

Author: eeckstein

lib/SIL/Utils/MemAccessUtils.cpp

@@ -778,6 +778,7 @@ bool swift::isIdentityPreservingRefCast(SingleValueInstruction *svi) {
   return isa<CopyValueInst>(svi) || isa<BeginBorrowInst>(svi)
          || isa<EndInitLetRefInst>(svi)
          || isa<BeginDeallocRefInst>(svi)
+         || isa<EndCOWMutationInst>(svi)
          || isIdentityAndOwnershipPreservingRefCast(svi);
 }
 

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -176,6 +176,8 @@ bool swift::canUseObject(SILInstruction *Inst) {
   case SILInstructionKind::RawPointerToRefInst:
   case SILInstructionKind::UnconditionalCheckedCastInst:
   case SILInstructionKind::UncheckedBitwiseCastInst:
+  case SILInstructionKind::EndInitLetRefInst:
+  case SILInstructionKind::BeginDeallocRefInst:
     return false;
 
   // If we have a trivial bit cast between trivial types, it is not something

lib/SILOptimizer/Transforms/DeadObjectElimination.cpp

@@ -263,8 +263,9 @@ static bool canZapInstruction(SILInstruction *Inst, bool acceptRefCountInsts,
       isa<MoveValueInst>(Inst)) {
     return true;
   }
-  if (isa<BeginDeallocRefInst>(Inst) || isa<FixLifetimeInst>(Inst) ||
-      isa<EndBorrowInst>(Inst))
+  if (isa<EndInitLetRefInst>(Inst) || isa<BeginDeallocRefInst>(Inst) ||
+      isa<FixLifetimeInst>(Inst) || isa<EndBorrowInst>(Inst) ||
+      isa<UpcastInst>(Inst) || isa<UncheckedRefCastInst>(Inst))
     return true;
 
   // It is ok to eliminate various retains/releases. We are either removing
@@ -336,6 +337,14 @@ static bool onlyStoresToTailObjects(BuiltinInst *destroyArray,
 
   // Check if the destroyArray destroys the tail elements of allocRef.
   auto destroyPath = AccessPath::compute(destroyArray->getArguments()[1]);
+  AccessStorage storage = destroyPath.getStorage();
+  if (auto *beginDealloc = dyn_cast<BeginDeallocRefInst>(storage.getRoot())) {
+    destroyPath = AccessPath(
+                   storage.transformReference(beginDealloc->getAllocation()),
+                   destroyPath.getPathNode(),
+                   destroyPath.getOffset());
+  }
+
   if (destroyPath != AccessPath::forTailStorage(allocRef))
     return false;
 

lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -497,6 +497,8 @@ bool SILPerformanceInliner::isProfitableToInline(
         }
       } else if (auto ri = dyn_cast<ReturnInst>(&I)) {
         SILValue retVal = ri->getOperand();
+        if (auto *eir = dyn_cast<EndInitLetRefInst>(retVal))
+          retVal = eir->getOperand();
         if (auto *uci = dyn_cast<UpcastInst>(retVal))
           retVal = uci->getOperand();
 

test/SILOptimizer/retain_release_code_motion.sil

@@ -1106,3 +1106,20 @@ bb0(%0 : $Y, %1 : $Act):
   strong_release %3 : $C2
   return %7 : $A
 }
+
+// CHECK-RELEASE-HOISTING-LABEL: sil @hoist_release_over_end_init_let_ref :
+// CHECK-RELEASE-HOISTING:         alloc_ref
+// CHECK-RELEASE-HOISTING-NEXT:    strong_release
+// CHECK-RELEASE-HOISTING-NEXT:    br bb1
+// CHECK-RELEASE-HOISTING:       } // end sil function 'hoist_release_over_end_init_let_ref'
+sil @hoist_release_over_end_init_let_ref : $@convention(thin) (@guaranteed B) -> () {
+bb0(%0 : $B):
+  %1 = alloc_ref $C
+  br bb1
+bb1:
+  %3 = end_init_let_ref %0 : $B
+  strong_release %1 : $C
+  %5 = tuple()
+  return %5 : $()
+}
+