WIP: [CanOSSALifetime] Fwding consume -> borrow.

When none of the uses are consuming.

Author: nate-chandler

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -133,17 +133,38 @@ void diagnoseRequiredCopyOfMoveOnly(Operand *use,
 /// This result remains valid during copy rewriting. The only instructions
 /// referenced it contains are consumes that cannot be deleted.
 class CanonicalOSSAConsumeInfo final {
+public:
+  struct ForwardRewriteInfo {
+    CopyValueInst *def = nullptr;
+    SmallVector<Operand *, 4> borrowedOperands;
+    SmallVector<SILInstruction *, 4> users;
+    SmallPtrSetVector<Operand *, 4> operands;
+    SmallVector<DestroyValueInst *, 4> destroys;
+  };
+
+private:
   /// Map blocks on the lifetime boundary to the last consuming instruction.
   llvm::SmallDenseMap<SILBasicBlock *, SILInstruction *, 4> finalBlockConsumes;
 
   /// The instructions on the availability boundary of the dead-end region where
   /// this value is not consumed.
   SmallPtrSet<SILInstruction *, 4> unreachableLifetimeEnds;
 
+  SmallVector<ForwardRewriteInfo, 4> forwards;
+
 public:
-  void clear() { finalBlockConsumes.clear(); }
+  void clear() {
+    finalBlockConsumes.clear();
+    unreachableLifetimeEnds.clear();
+    forwards.clear();
+  }
 
-  bool empty() { return finalBlockConsumes.empty(); }
+  // FIXME: FIXME_NOW: Avoid this copy.
+  void recordForward(ForwardRewriteInfo forward) {
+    forwards.push_back(forward);
+  }
+
+  ArrayRef<ForwardRewriteInfo> getForwards() { return forwards; }
 
   bool hasUnclaimedConsumes() const { return !finalBlockConsumes.empty(); }
 
@@ -279,6 +300,8 @@ class CanonicalizeOSSALifetime final {
   /// repeatedly do use-def walks from destroys).
   SmallPtrSetVector<SILInstruction *, 8> destroys;
 
+  llvm::SmallSetVector<Operand *, 8> forwardingConsumes;
+
   /// Information about consuming instructions discovered in this canonical OSSA
   /// lifetime.
   CanonicalOSSAConsumeInfo consumes;
@@ -331,19 +354,22 @@ class CanonicalizeOSSALifetime final {
     accessBlocks = nullptr;
     consumes.clear();
     destroys.clear();
+    forwardingConsumes.clear();
+    discoveredBlocks.clear();
 
     currentDef = def;
 
-    if (maximizeLifetime || respectsDeinitBarriers()) {
-      liveness->initializeDiscoveredBlocks(&discoveredBlocks);
-    }
+    // if (maximizeLifetime || respectsDeinitBarriers()) {
+    liveness->initializeDiscoveredBlocks(&discoveredBlocks);
+    //}
     liveness->initializeDef(getCurrentDef());
   }
 
   void clear() {
     consumingBlocks.clear();
     debugValues.clear();
     discoveredBlocks.clear();
+    forwardingConsumes.clear();
   }
 
   /// Top-Level API: rewrites copies and destroys within \p def's extended
@@ -420,6 +446,8 @@ class CanonicalizeOSSALifetime final {
 
   void recordDebugValue(DebugValueInst *dvi) { debugValues.insert(dvi); }
 
+  void recordForwardingConsume(Operand *use) { forwardingConsumes.insert(use); }
+
   void recordConsumingUse(Operand *use) { recordConsumingUser(use->getUser()); }
   /// Record that the value is consumed at `user`.
   ///
@@ -450,6 +478,13 @@ class CanonicalizeOSSALifetime final {
   void insertDestroysOnBoundary(PrunedLivenessBoundary const &boundary);
 
   void rewriteCopies();
+  void addForwardingConsumesToLiveness();
+  bool addForwardingConsumeToLiveness(
+      CopyValueInst *cvi, CanonicalOSSAConsumeInfo::ForwardRewriteInfo &info);
+
+  void rewriteForwardingConsumes();
+  void rewriteForwardingConsume(
+      CanonicalOSSAConsumeInfo::ForwardRewriteInfo const &info);
 };
 
 } // end namespace swift

lib/SIL/Utils/OwnershipUtils.cpp

@@ -1432,8 +1432,8 @@ void ForwardingOperand::setForwardingOwnershipKind(
           continue;
 
         for (auto *succArg : succBlock->getSILPhiArguments()) {
-          // If we have an any value, just continue.
-          if (!succArg->getType().isTrivial(*ofti->getFunction()))
+          // If we have any trivial value, just continue.
+          if (succArg->getType().isTrivial(*ofti->getFunction()))
             continue;
           succArg->setOwnershipKind(newKind);
         }

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -454,7 +454,12 @@ bool SILValueOwnershipChecker::gatherUsers(
       auto *succArg = succBlock->getArgument(0);
 
       auto succArgOwnershipKind = succArg->getOwnershipKind();
-      assert(succArgOwnershipKind.isCompatibleWith(OwnershipKind::Guaranteed));
+      if (!succArgOwnershipKind.isCompatibleWith(OwnershipKind::Guaranteed)) {
+        llvm::errs() << "OwnershipKind incompatible with ::Guaranteed!\n"
+                     << "Argument: " << *succArg << '\n'
+                     << "Ownership:" << succArgOwnershipKind.asString() << '\n';
+        assert(false);
+      }
 
       // If we have an any value, just continue.
       if (succArgOwnershipKind == OwnershipKind::None)