[SSADestroyHoisting] Split destroy from copy.

As was done with store [init], transform instructions like

    copy_addr %n to %m

into the sequence

    destroy_addr %m
    copy_addr %n to [initialization] %m

in order to create more opportunities for hoisting destroys.

After hoisting, if these opportunities for hoisting don't result in
hoisting actually occurring, recombine the two instructions.

Author: nate-chandler

lib/SILOptimizer/Transforms/SSADestroyHoisting.cpp

@@ -754,6 +754,7 @@ void SSADestroyHoisting::run() {
   llvm::SmallVector<AllocStackInst *, 4> asis;
   llvm::SmallVector<BeginAccessInst *, 4> bais;
   llvm::SmallVector<StoreInst *, 4> sis;
+  llvm::SmallVector<CopyAddrInst *, 4> cais;
 
   // Collect the instructions that we'll be transforming.
   for (auto &block : *getFunction()) {
@@ -768,6 +769,10 @@ void SSADestroyHoisting::run() {
         if (si->getOwnershipQualifier() == StoreOwnershipQualifier::Assign) {
           sis.push_back(si);
         }
+      } else if (auto *cai = dyn_cast<CopyAddrInst>(&inst)) {
+        if (cai->isInitializationOfDest() == IsNotInitialization) {
+          cais.push_back(cai);
+        }
       }
     }
   }
@@ -804,6 +809,32 @@ void SSADestroyHoisting::run() {
     remainingDestroyAddrs.insert(dai);
     ++splitDestroys;
   }
+  // Similarly, also expand each
+  //
+  //     copy_addr to
+  //
+  // instruction into
+  //
+  //     destroy_addr
+  //     copy_addr to [initialization]
+  //
+  // sequences to create still more destroy_addrs to hoist.
+  //
+  // As above, record the newly created destroy_addrs and copy_addrs off of
+  // which they were split.  After hoisting, we'll merge them back together when
+  // possible.
+  llvm::SmallVector<std::pair<DestroyAddrInst *, CopyAddrInst *>, 8>
+      splitDestroysAndCopies;
+  for (auto *cai : cais) {
+    auto builder = SILBuilderWithScope(cai);
+    auto *dai = builder.createDestroyAddr(
+        RegularLocation::getAutoGeneratedLocation(cai->getLoc()),
+        cai->getOperand(1));
+    cai->setIsInitializationOfDest(IsInitialization);
+    splitDestroysAndCopies.push_back({dai, cai});
+    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
@@ -852,6 +883,18 @@ void SSADestroyHoisting::run() {
     si->setOwnershipQualifier(StoreOwnershipQualifier::Assign);
     --splitDestroys;
   }
+  for (auto pair : splitDestroysAndCopies) {
+    auto *dai = pair.first;
+    if (!remainingDestroyAddrs.contains(dai))
+      continue;
+    auto *cai = pair.second;
+    if (dai->getNextInstruction() != cai)
+      continue;
+    assert(cai->isInitializationOfDest() == IsInitialization);
+    deleter.forceDelete(dai);
+    cai->setIsInitializationOfDest(IsNotInitialization);
+    --splitDestroys;
+  }
   // If there were any destroy_addrs split off of stores and not recombined
   // with them, then the function has changed.
   changed |= splitDestroys > 0;