[NFC] Add support for a mandatory-copy-propagation pass.

It is currently disabled so this commit is NFC.

MandatoryCopyPropagation canonicalizes all all OSSA lifetimes with
either CopyValue or DestroyValue operations. While regular
CopyPropagation only canonicalizes lifetimes with copies. This ensures
that more lifetime program bugs are found in debug builds. Eventually,
regular CopyPropagation will also canonicalize all lifetimes, but for
now, we don't want to expose optimized code to more behavior change
than necessary.

Add frontend flags for developers to easily control copy propagation:

-enable-copy-propagation: enables whatever form of copy propagation
 the current pipeline runs (mandatory-copy-propagation at -Onone,
 regular copy-propation at -O).

-disable-copy-propagation: similarly disables any form of copy
 propagation in the current pipelien.

To control a specific variant of the passes, use
   -Xllvm -disable-pass=mandatory-copy-propagation
or -Xllvm -disable-pass=copy-propagation instead.

The meaning of these flags will stay the same as we adjust the
defaults. Soon mandatory-copy-propagation will be enabled by
default. There are two reasons to do this, both related to predictable
behavior across Debug and Release builds.

1. Shortening object lifetimes can cause observable changes in program
   behavior in the presense of weak/unowned reference and
   deinitializer side effects.

2. Programmers need to know reliably whether a given code pattern will
   copy the storage for copy-on-write types (Array, Set). Eliminating
   the "unexpected" copies the same way at -Onone and -O both makes
   debugging tractable and provides assurance that the code isn't
   relying on the luck of the optimizer in a particular compiler
   release.

Author: atrick

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -187,7 +187,7 @@ class CanonicalizeOSSALifetime {
 private:
   /// If true, then debug_value instructions outside of non-debug
   /// liveness may be pruned during canonicalization.
-  bool pruneDebug;
+  bool pruneDebugMode;
 
   NonLocalAccessBlockAnalysis *accessBlockAnalysis;
   // Lazily initialize accessBlocks only when
@@ -237,12 +237,13 @@ class CanonicalizeOSSALifetime {
   CanonicalOSSAConsumeInfo consumes;
 
 public:
-  CanonicalizeOSSALifetime(bool pruneDebug,
+  CanonicalizeOSSALifetime(bool pruneDebugMode,
                            NonLocalAccessBlockAnalysis *accessBlockAnalysis,
                            DominanceAnalysis *dominanceAnalysis,
                            DeadEndBlocks *deBlocks)
-    : pruneDebug(pruneDebug), accessBlockAnalysis(accessBlockAnalysis),
-      dominanceAnalysis(dominanceAnalysis), deBlocks(deBlocks) {}
+      : pruneDebugMode(pruneDebugMode),
+        accessBlockAnalysis(accessBlockAnalysis),
+        dominanceAnalysis(dominanceAnalysis), deBlocks(deBlocks) {}
 
   SILValue getCurrentDef() const { return currentDef; }
 

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -835,6 +835,10 @@ SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   P.startPipeline("non-Diagnostic Enabling Mandatory Optimizations");
   P.addForEachLoopUnroll();
   P.addMandatoryCombine();
+  // MandatoryCopyPropagation should only be run at -Onone, not -O.
+  P.addMandatoryCopyPropagation();
+  // TODO: GuaranteedARCOpts should be subsumed by CopyPropagation. There should
+  // be no need to run another analysis of copies at -Onone.
   P.addGuaranteedARCOpts();
 
   // First serialize the SIL if we are asked to.

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -42,9 +42,12 @@ namespace {
 class CopyPropagation : public SILFunctionTransform {
   /// True if debug_value instructions should be pruned.
   bool pruneDebug;
+  /// True of all values should be canonicalized.
+  bool canonicalizeAll;
 
 public:
-  CopyPropagation(bool pruneDebug): pruneDebug(pruneDebug) {}
+  CopyPropagation(bool pruneDebug, bool canonicalizeAll)
+      : pruneDebug(pruneDebug), canonicalizeAll(canonicalizeAll) {}
 
   /// The entry point to this function transformation.
   void run() override;
@@ -83,9 +86,15 @@ void CopyPropagation::run() {
   llvm::SmallSetVector<SILValue, 16> copiedDefs;
   for (auto &bb : *f) {
     for (auto &i : bb) {
-      if (auto *copy = dyn_cast<CopyValueInst>(&i))
+      if (auto *copy = dyn_cast<CopyValueInst>(&i)) {
         copiedDefs.insert(
             CanonicalizeOSSALifetime::getCanonicalCopiedDef(copy));
+      } else if (canonicalizeAll) {
+        if (auto *destroy = dyn_cast<DestroyValueInst>(&i)) {
+          copiedDefs.insert(CanonicalizeOSSALifetime::getCanonicalCopiedDef(
+              destroy->getOperand()));
+        }
+      }
     }
   }
   // Perform copy propgation for each copied value.

lib/SILOptimizer/Utils/CanonicalOSSALifetime.cpp

@@ -369,7 +369,7 @@ bool CanonicalizeOSSALifetime::computeCanonicalLiveness() {
         continue;
       }
       // Handle debug_value instructions separately.
-      if (pruneDebug) {
+      if (pruneDebugMode) {
         if (auto *dvi = dyn_cast<DebugValueInst>(user)) {
           // Only instructions potentially outside current pruned liveness are
           // interesting.
@@ -647,7 +647,7 @@ void CanonicalizeOSSALifetime::findOrInsertDestroyInBlock(SILBasicBlock *bb) {
   while (true) {
     auto *inst = &*instIter;
 
-    if (pruneDebug) {
+    if (pruneDebugMode) {
       if (auto *dvi = dyn_cast<DebugValueInst>(inst)) {
         if (debugValues.erase(dvi))
           consumes.recordDebugAfterConsume(dvi);
@@ -675,7 +675,8 @@ void CanonicalizeOSSALifetime::findOrInsertDestroyInBlock(SILBasicBlock *bb) {
       return;
     }
     // This is not a potential last user. Keep scanning.
-    // Allow lifetimes to be artificially extended up to the next call.
+    // Allow lifetimes to be artificially extended up to the next call. The goal
+    // is to prevent repeated destroy rewriting without inhibiting optimization.
     if (ApplySite::isa(inst)) {
       existingDestroy = nullptr;
     } else if (!existingDestroy) {
@@ -842,9 +843,10 @@ void CanonicalizeOSSALifetime::rewriteCopies() {
       if (reusedCopyOp) {
         reusedCopyOp->set(srcCopy);
       } else {
-        instsToDelete.insert(srcCopy);
-        LLVM_DEBUG(llvm::dbgs() << "  Removing " << *srcCopy);
-        ++NumCopiesEliminated;
+        if (instsToDelete.insert(srcCopy)) {
+          LLVM_DEBUG(llvm::dbgs() << "  Removing " << *srcCopy);
+          ++NumCopiesEliminated;
+        }
       }
     }
   }