[ownership] Add a simple helper wrapper called canonicalizeOSSALifetimes around CanonicalizeOSSALifetime that clean up extra copies inserted when RAUWing or promoting loads.

Based on code in CopyPropagation. It is assumed that the passed in set of defs
is unique and that all such defs were found by using
CanonicalizeOSSALifetime::getCanonicalCopiedDef(copy).

Author: gottesmm

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -398,6 +398,10 @@ class CanonicalizeOSSALifetime {
   /// lifetime, call this API again on the value defined by the new copy.
   bool canonicalizeValueLifetime(SILValue def);
 
+  /// Return the inst mod callbacks struct used by this CanonicalizeOSSALifetime
+  /// to pass to other APIs that need to compose with CanonicalizeOSSALifetime.
+  InstModCallbacks getInstModCallbacks() const { return instModCallbacks; }
+
 protected:
   void recordDebugValue(DebugValueInst *dvi) {
     debugValues.insert(dvi);
@@ -438,6 +442,29 @@ class CanonicalizeOSSALifetime {
   void injectPoison();
 };
 
+/// Canonicalize the passed in set of defs, eliminating in one batch any that
+/// are not needed given the canonical lifetime of the various underlying owned
+/// value introducers.
+///
+/// On success, returns the invalidation kind that the caller must use to
+/// invalidate analyses. Currently it will only ever return
+/// SILAnalysis::InvalidationKind::Instructions or None.
+///
+/// NOTE: This routine is guaranteed to not invalidate
+/// NonLocalAccessBlockAnalysis, so callers should lock it before invalidating
+/// instructions. E.x.:
+///
+///    accessBlockAnalysis->lockInvalidation();
+///    pass->invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
+///    accessBlockAnalysis->unlockInvalidation();
+///
+/// NOTE: We assume that all \p inputDefs is a set (that is it has no duplicate
+/// elements) and that all values have been generated by running a copy through
+/// CanonicalizeOSSALifetime::getCanonicalCopiedDef(copy)).
+SILAnalysis::InvalidationKind
+canonicalizeOSSALifetimes(CanonicalizeOSSALifetime &canonicalizeLifetime,
+                          ArrayRef<SILValue> inputDefs);
+
 } // end namespace swift
 
 #endif

lib/SILOptimizer/Utils/CanonicalOSSALifetime.cpp

@@ -1221,3 +1221,64 @@ SWIFT_ASSERT_ONLY_DECL(
       llvm::dbgs() << "  " << *blockAndInst.getSecond();
     }
   })
+
+//===----------------------------------------------------------------------===//
+//                    MARK: Canonicalize Lifetimes Utility
+//===----------------------------------------------------------------------===//
+
+SILAnalysis::InvalidationKind
+swift::canonicalizeOSSALifetimes(CanonicalizeOSSALifetime &canonicalizer,
+                                 ArrayRef<SILValue> copiedDefs) {
+  auto isCopyDead = [](CopyValueInst *copy, bool pruneDebug) -> bool {
+    for (Operand *use : copy->getUses()) {
+      auto *user = use->getUser();
+      if (isa<DestroyValueInst>(user)) {
+        continue;
+      }
+      if (pruneDebug && isa<DebugValueInst>(user)) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  };
+
+  // Cleanup dead copies. If getCanonicalCopiedDef returns a copy (because the
+  // copy's source operand is unrecgonized), then the copy is itself treated
+  // like a def and may be dead after canonicalization.
+  SmallVector<SILInstruction *, 4> deadCopies;
+  for (auto def : copiedDefs) {
+    // Canonicalized this def. If we did not perform any canonicalization, just
+    // continue.
+    if (!canonicalizer.canonicalizeValueLifetime(def))
+      continue;
+
+    // Otherwise, see if we have a dead copy.
+    if (auto *copy = dyn_cast<CopyValueInst>(def)) {
+      if (isCopyDead(copy, false /*prune debug*/)) {
+        deadCopies.push_back(copy);
+      }
+    }
+
+    // Canonicalize any new outer copy.
+    if (SILValue outerCopy = canonicalizer.createdOuterCopy()) {
+      SILValue outerDef = canonicalizer.getCanonicalCopiedDef(outerCopy);
+      canonicalizer.canonicalizeValueLifetime(outerDef);
+    }
+
+    // TODO: also canonicalize any lifetime.persistentCopies like separate owned
+    // live ranges.
+  }
+
+  if (!canonicalizer.hasChanged() && deadCopies.empty()) {
+    return SILAnalysis::InvalidationKind::Nothing;
+  }
+
+  // We use our canonicalizers inst mod callbacks.
+  InstructionDeleter deleter(canonicalizer.getInstModCallbacks());
+  for (auto *copy : deadCopies) {
+    deleter.recursivelyDeleteUsersIfDead(copy);
+  }
+
+  return SILAnalysis::InvalidationKind::Instructions;
+}