[SSADestroyHoisting] Recombine store [init]s.

Before hoisting destroy_addrs, we split store [assign]s into
destroy_addrs and store [init]s.  If those destroy_addrs were not able
to be hoisted, though, recombine the two back into a store [assign].
Doing so avoids introducing extra ARC traffic.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -494,6 +494,7 @@ bool DeinitBarriers::DestroyReachability::checkReachablePhiBarrier(
 class HoistDestroys {
   SILValue storageRoot;
   bool ignoreDeinitBarriers;
+  SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs;
   InstructionDeleter &deleter;
 
   // Book-keeping for the rewriting stage.
@@ -503,9 +504,11 @@ class HoistDestroys {
 
 public:
   HoistDestroys(SILValue storageRoot, bool ignoreDeinitBarriers,
+                SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs,
                 InstructionDeleter &deleter)
       : storageRoot(storageRoot), ignoreDeinitBarriers(ignoreDeinitBarriers),
-        deleter(deleter), destroyMergeBlocks(getFunction()) {}
+        remainingDestroyAddrs(remainingDestroyAddrs), deleter(deleter),
+        destroyMergeBlocks(getFunction()) {}
 
   bool perform();
 
@@ -593,6 +596,7 @@ bool HoistDestroys::rewriteDestroys(const KnownStorageUses &knownUses,
     if (reusedDestroys.contains(destroyInst))
       continue;
 
+    remainingDestroyAddrs.erase(destroyInst);
     deleter.forceDelete(destroyInst);
   }
   deleter.cleanupDeadInstructions();
@@ -697,6 +701,7 @@ void HoistDestroys::mergeDestroys(SILBasicBlock *mergeBlock) {
   createDestroy(&mergeBlock->front(), deadDestroys[0]->getDebugScope());
 
   for (auto *deadDestroy : deadDestroys) {
+    remainingDestroyAddrs.erase(deadDestroy);
     deleter.forceDelete(deadDestroy);
   }
 }
@@ -706,6 +711,7 @@ void HoistDestroys::mergeDestroys(SILBasicBlock *mergeBlock) {
 // =============================================================================
 
 bool hoistDestroys(SILValue root, bool ignoreDeinitBarriers,
+                   SmallPtrSetImpl<SILInstruction *> &remainingDestroyAddrs,
                    InstructionDeleter &deleter) {
   LLVM_DEBUG(llvm::dbgs() << "Performing destroy hoisting on " << root);
 
@@ -716,7 +722,9 @@ bool hoistDestroys(SILValue root, bool ignoreDeinitBarriers,
   // The algorithm assumes no critical edges.
   assert(function->hasOwnership() && "requires OSSA");
 
-  return HoistDestroys(root, ignoreDeinitBarriers, deleter).perform();
+  return HoistDestroys(root, ignoreDeinitBarriers, remainingDestroyAddrs,
+                       deleter)
+      .perform();
 }
 
 // =============================================================================
@@ -770,24 +778,41 @@ void SSADestroyHoisting::run() {
   //     store [init]
   //
   // sequences to create more destroy_addrs to hoist.
+  //
+  // Record the newly created destroy_addrs and the stores they were split off
+  // of.  After hoisting, if they have not been hoisted away from the store
+  // instruction, we will merge them back together.
+  llvm::SmallVector<std::pair<DestroyAddrInst *, StoreInst *>, 8>
+      splitDestroysAndStores;
+  // The destroy_addrs that were created that have not been deleted.  Items are
+  // erased from the set as the destroy_addrs are deleted.
+  SmallPtrSet<SILInstruction *, 8> remainingDestroyAddrs;
+  // The number of destroys that were split off of store [init]s and not
+  // recombined.
+  int splitDestroys = 0;
   for (auto *si : sis) {
     auto builder = SILBuilderWithScope(si);
-    builder.createDestroyAddr(
+    auto *dai = builder.createDestroyAddr(
         RegularLocation::getAutoGeneratedLocation(si->getLoc()),
         si->getOperand(1));
     si->setOwnershipQualifier(StoreOwnershipQualifier::Init);
+    splitDestroysAndStores.push_back({dai, si});
+    remainingDestroyAddrs.insert(dai);
+    ++splitDestroys;
   }
 
   // We assume that the function is in reverse post order so visiting the
   // blocks and pushing begin_access as we see them and then popping them off
   // the end will result in hoisting inner begin_access' destroy_addrs first.
   while (!bais.empty()) {
     auto *bai = bais.pop_back_val();
-    changed |= hoistDestroys(bai, /*ignoreDeinitBarriers=*/true, deleter);
+    changed |= hoistDestroys(bai, /*ignoreDeinitBarriers=*/true,
+                             remainingDestroyAddrs, deleter);
   }
   // Alloc stacks always enclose their accesses.
   for (auto *asi : asis) {
-    changed |= hoistDestroys(asi, /*ignoreDeinitBarriers=*/false, deleter);
+    changed |= hoistDestroys(asi, /*ignoreDeinitBarriers=*/false,
+                             remainingDestroyAddrs, deleter);
   }
   // Arguments enclose everything.
   for (auto *arg : getFunction()->getArguments()) {
@@ -796,9 +821,30 @@ void SSADestroyHoisting::run() {
                          ->getArgumentConvention()
                          .isInoutConvention();
       changed |= hoistDestroys(arg, /*ignoreDeinitBarriers=*/
-                               isInout, deleter);
+                               isInout, remainingDestroyAddrs, deleter);
+    }
+  }
+
+  for (auto pair : splitDestroysAndStores) {
+    auto *dai = pair.first;
+    if (!remainingDestroyAddrs.contains(dai))
+      continue;
+    auto *si = pair.second;
+    if (dai->getNextInstruction() == si) {
+      // No stores should have been rewritten during hoisting.  Their ownership
+      // qualifiers were set to [init] when splitting off the destroy_addrs.
+      assert(si->getOwnershipQualifier() == StoreOwnershipQualifier::Init);
+      // If a newly created destroy_addr has not been hoisted from its previous
+      // location, combine it back together with the store [init] which it was
+      // split off from.
+      deleter.forceDelete(dai);
+      si->setOwnershipQualifier(StoreOwnershipQualifier::Assign);
+      --splitDestroys;
     }
   }
+  // If there were any destroy_addrs split off of stores and not recombined
+  // with them, then the function has changed.
+  changed |= splitDestroys > 0;
 
   if (changed) {
     invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);