Merge pull request swiftlang#30243 from gottesmm/pr-79ceec70022725264b06f2d626c8793a8d917737

Author: swift-ci

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -292,12 +292,32 @@ struct InstModCallbacks {
       [](SILValue oldValue, SILValue newValue) {
         oldValue->replaceAllUsesWith(newValue);
       };
+  std::function<void(SingleValueInstruction *, SILValue)>
+      eraseAndRAUWSingleValueInst =
+          [](SingleValueInstruction *i, SILValue newValue) {
+            i->replaceAllUsesWith(newValue);
+            i->eraseFromParent();
+          };
 
   InstModCallbacks(decltype(deleteInst) deleteInst,
                    decltype(createdNewInst) createdNewInst,
                    decltype(replaceValueUsesWith) replaceValueUsesWith)
       : deleteInst(deleteInst), createdNewInst(createdNewInst),
-        replaceValueUsesWith(replaceValueUsesWith) {}
+        replaceValueUsesWith(replaceValueUsesWith),
+        eraseAndRAUWSingleValueInst(
+            [](SingleValueInstruction *i, SILValue newValue) {
+              i->replaceAllUsesWith(newValue);
+              i->eraseFromParent();
+            }) {}
+
+  InstModCallbacks(
+      decltype(deleteInst) deleteInst, decltype(createdNewInst) createdNewInst,
+      decltype(replaceValueUsesWith) replaceValueUsesWith,
+      decltype(eraseAndRAUWSingleValueInst) eraseAndRAUWSingleValueInst)
+      : deleteInst(deleteInst), createdNewInst(createdNewInst),
+        replaceValueUsesWith(replaceValueUsesWith),
+        eraseAndRAUWSingleValueInst(eraseAndRAUWSingleValueInst) {}
+
   InstModCallbacks() = default;
   ~InstModCallbacks() = default;
   InstModCallbacks(const InstModCallbacks &) = default;

lib/SILOptimizer/Transforms/SemanticARCOpts.cpp

@@ -46,6 +46,9 @@ STATISTIC(NumLoadCopyConvertedToLoadBorrow,
 namespace {
 
 class LiveRange {
+  /// The parent value that introduces the live range.
+  SILValue value;
+
   /// A list of destroy_values of the live range.
   SmallVector<Operand *, 2> destroyingUses;
 
@@ -83,6 +86,32 @@ class LiveRange {
   ArrayRef<Operand *> getNonConsumingForwardingUses() const {
     return generalForwardingUses;
   }
+
+  /// A consuming operation that:
+  ///
+  /// 1. If \p insertEndBorrows is true inserts end borrows at all
+  ///    destroying insts locations.
+  ///
+  /// 2. Deletes all destroy_values.
+  ///
+  /// 3. RAUW value with newGuaranteedValue.
+  ///
+  /// 4. Convert all of the general forwarding instructions from
+  ///    @owned -> @guaranteed. "Like Dominoes".
+  ///
+  /// 5. Leaves all of the unknown consuming users alone. It is up to
+  ///    the caller to handle converting their ownership.
+  void convertToGuaranteedAndRAUW(SILValue newGuaranteedValue,
+                                  InstModCallbacks callbacks) &&;
+
+  /// Given a new guaranteed value, insert end_borrow for the newGuaranteedValue
+  /// at all of our destroy_values in prepration for converting from owned to
+  /// guaranteed.
+  ///
+  /// This is used when converting load [copy] -> load_borrow.
+  void insertEndBorrowsAtDestroys(SILValue newGuaranteedValue,
+                                  DeadEndBlocks &deadEndBlocks,
+                                  ValueLifetimeAnalysis::Frontier &scratch);
 };
 
 } // end anonymous namespace
@@ -101,7 +130,8 @@ LiveRange::DestroyingInstsRange LiveRange::getDestroyingInsts() const {
 }
 
 LiveRange::LiveRange(SILValue value)
-    : destroyingUses(), generalForwardingUses(), unknownConsumingUses() {
+    : value(value), destroyingUses(), generalForwardingUses(),
+      unknownConsumingUses() {
   assert(value.getOwnershipKind() == ValueOwnershipKind::Owned);
 
   // We know that our silvalue produces an @owned value. Look through all of our
@@ -198,6 +228,108 @@ LiveRange::LiveRange(SILValue value)
   }
 }
 
+void LiveRange::insertEndBorrowsAtDestroys(
+    SILValue newGuaranteedValue, DeadEndBlocks &deadEndBlocks,
+    ValueLifetimeAnalysis::Frontier &scratch) {
+  assert(scratch.empty() && "Expected scratch to be initially empty?!");
+
+  // Since we are looking through forwarding uses that can accept guaranteed
+  // parameters, we can have multiple destroy_value along the same path. We need
+  // to find the post-dominating block set of these destroy value to ensure that
+  // we do not insert multiple end_borrow.
+  //
+  // TODO: Hoist this out?
+  auto *inst = value->getDefiningInstruction();
+  assert(inst && "Should only call this with value's that are actually part of "
+                 "an instruction");
+
+  ValueLifetimeAnalysis analysis(inst, getDestroyingInsts());
+  bool foundCriticalEdges = !analysis.computeFrontier(
+      scratch, ValueLifetimeAnalysis::DontModifyCFG, &deadEndBlocks);
+  (void)foundCriticalEdges;
+  assert(!foundCriticalEdges);
+  auto loc = RegularLocation::getAutoGeneratedLocation();
+  while (!scratch.empty()) {
+    auto *insertPoint = scratch.pop_back_val();
+    SILBuilderWithScope builder(insertPoint);
+    builder.createEndBorrow(loc, newGuaranteedValue);
+  }
+}
+
+void LiveRange::convertToGuaranteedAndRAUW(SILValue newGuaranteedValue,
+                                           InstModCallbacks callbacks) && {
+  assert(isa<SingleValueInstruction>(value) &&
+         "Can only convert single value instruction live ranges to guaranteed");
+  while (!destroyingUses.empty()) {
+    auto *d = destroyingUses.pop_back_val();
+    callbacks.deleteInst(d->getUser());
+    ++NumEliminatedInsts;
+  }
+
+  callbacks.eraseAndRAUWSingleValueInst(cast<SingleValueInstruction>(value),
+                                        newGuaranteedValue);
+
+  // Then change all of our guaranteed forwarding insts to have guaranteed
+  // ownership kind instead of what ever they previously had (ignoring trivial
+  // results);
+  while (!generalForwardingUses.empty()) {
+    auto *i = generalForwardingUses.pop_back_val()->getUser();
+
+    // If this is a term inst, just convert all of its incoming values that are
+    // owned to be guaranteed.
+    if (auto *ti = dyn_cast<TermInst>(i)) {
+      for (auto &succ : ti->getSuccessors()) {
+        auto *succBlock = succ.getBB();
+
+        // If we do not have any arguments, then continue.
+        if (succBlock->args_empty())
+          continue;
+
+        for (auto *succArg : succBlock->getSILPhiArguments()) {
+          // If we have an any value, just continue.
+          if (succArg->getOwnershipKind() == ValueOwnershipKind::Owned) {
+            succArg->setOwnershipKind(ValueOwnershipKind::Guaranteed);
+          }
+        }
+      }
+      continue;
+    }
+
+    assert(i->hasResults());
+    for (SILValue result : i->getResults()) {
+      if (auto *svi = dyn_cast<OwnershipForwardingSingleValueInst>(result)) {
+        if (svi->getOwnershipKind() == ValueOwnershipKind::Owned) {
+          svi->setOwnershipKind(ValueOwnershipKind::Guaranteed);
+        }
+        continue;
+      }
+
+      if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(result)) {
+        if (ofci->getOwnershipKind() == ValueOwnershipKind::Owned) {
+          ofci->setOwnershipKind(ValueOwnershipKind::Guaranteed);
+        }
+        continue;
+      }
+
+      if (auto *sei = dyn_cast<OwnershipForwardingSelectEnumInstBase>(result)) {
+        if (sei->getOwnershipKind() == ValueOwnershipKind::Owned) {
+          sei->setOwnershipKind(ValueOwnershipKind::Guaranteed);
+        }
+        continue;
+      }
+
+      if (auto *mvir = dyn_cast<MultipleValueInstructionResult>(result)) {
+        if (mvir->getOwnershipKind() == ValueOwnershipKind::Owned) {
+          mvir->setOwnershipKind(ValueOwnershipKind::Guaranteed);
+        }
+        continue;
+      }
+
+      llvm_unreachable("unhandled forwarding instruction?!");
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                        Address Written To Analysis
 //===----------------------------------------------------------------------===//
@@ -321,76 +453,6 @@ bool IsAddressWrittenToDefUseAnalysis::isWrittenToHelper(SILValue initialValue)
   return false;
 }
 
-//===----------------------------------------------------------------------===//
-//             Convert Forwarding Insts from Owned -> Guaranteed
-//===----------------------------------------------------------------------===//
-
-static void convertForwardingUsesFromOwnedToGuaranteed(
-    ArrayRef<Operand *> guaranteedForwardingUses) {
-  // Then change all of our guaranteed forwarding insts to have guaranteed
-  // ownership kind instead of what ever they previously had (ignoring trivial
-  // results);
-  while (!guaranteedForwardingUses.empty()) {
-    auto *use = guaranteedForwardingUses.back();
-    guaranteedForwardingUses = guaranteedForwardingUses.drop_back();
-
-    auto *i = use->getUser();
-
-    // If this is a term inst, just convert all of its incoming values that are
-    // owned to be guaranteed.
-    if (auto *ti = dyn_cast<TermInst>(i)) {
-      for (auto &succ : ti->getSuccessors()) {
-        auto *succBlock = succ.getBB();
-
-        // If we do not have any arguments, then continue.
-        if (succBlock->args_empty())
-          continue;
-
-        for (auto *succArg : succBlock->getSILPhiArguments()) {
-          // If we have an any value, just continue.
-          if (succArg->getOwnershipKind() == ValueOwnershipKind::Owned) {
-            succArg->setOwnershipKind(ValueOwnershipKind::Guaranteed);
-          }
-        }
-      }
-      continue;
-    }
-
-    assert(i->hasResults());
-    for (SILValue result : i->getResults()) {
-      if (auto *svi = dyn_cast<OwnershipForwardingSingleValueInst>(result)) {
-        if (svi->getOwnershipKind() == ValueOwnershipKind::Owned) {
-          svi->setOwnershipKind(ValueOwnershipKind::Guaranteed);
-        }
-        continue;
-      }
-
-      if (auto *ofci = dyn_cast<OwnershipForwardingConversionInst>(result)) {
-        if (ofci->getOwnershipKind() == ValueOwnershipKind::Owned) {
-          ofci->setOwnershipKind(ValueOwnershipKind::Guaranteed);
-        }
-        continue;
-      }
-
-      if (auto *sei = dyn_cast<OwnershipForwardingSelectEnumInstBase>(result)) {
-        if (sei->getOwnershipKind() == ValueOwnershipKind::Owned) {
-          sei->setOwnershipKind(ValueOwnershipKind::Guaranteed);
-        }
-        continue;
-      }
-
-      if (auto *mvir = dyn_cast<MultipleValueInstructionResult>(result)) {
-        if (mvir->getOwnershipKind() == ValueOwnershipKind::Owned) {
-          mvir->setOwnershipKind(ValueOwnershipKind::Guaranteed);
-        }
-        continue;
-      }
-
-      llvm_unreachable("unhandled forwarding instruction?!");
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                               Implementation
 //===----------------------------------------------------------------------===//
@@ -473,6 +535,15 @@ struct SemanticARCOptVisitor
     visitedSinceLastMutation.clear();
   }
 
+  InstModCallbacks getCallbacks() {
+    return InstModCallbacks(
+        [this](SILInstruction *inst) { eraseInstruction(inst); },
+        [](SILInstruction *) {}, [](SILValue, SILValue) {},
+        [this](SingleValueInstruction *i, SILValue value) {
+          eraseAndRAUWSingleValueInstruction(i, value);
+        });
+  }
+
   /// The default visitor.
   bool visitSILInstruction(SILInstruction *i) {
     assert(!isGuaranteedForwardingInst(i) &&
@@ -808,18 +879,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(CopyValueInst
   }
 
   // Otherwise, we know that our copy_value/destroy_values are all completely
-  // within the guaranteed value scope. First delete the destroys/copies.
-  while (!destroys.empty()) {
-    auto *d = destroys.back();
-    destroys = destroys.drop_back();
-    eraseInstruction(d->getUser());
-    ++NumEliminatedInsts;
-  }
-
-  eraseAndRAUWSingleValueInstruction(cvi, cvi->getOperand());
-  convertForwardingUsesFromOwnedToGuaranteed(
-      lr.getNonConsumingForwardingUses());
-
+  // within the guaranteed value scope. So RAUW and convert to guaranteed!
+  std::move(lr).convertToGuaranteedAndRAUW(cvi->getOperand(), getCallbacks());
   ++NumEliminatedInsts;
   return true;
 }
@@ -1291,41 +1352,8 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
   auto *lbi =
       SILBuilderWithScope(li).createLoadBorrow(li->getLoc(), li->getOperand());
 
-  // Since we are looking through forwarding uses that can accept guaranteed
-  // parameters, we can have multiple destroy_value along the same path. We need
-  // to find the post-dominating block set of these destroy value to ensure that
-  // we do not insert multiple end_borrow.
-  assert(lifetimeFrontier.empty());
-  ValueLifetimeAnalysis analysis(li, lr.getDestroyingInsts());
-  bool foundCriticalEdges = !analysis.computeFrontier(
-      lifetimeFrontier, ValueLifetimeAnalysis::DontModifyCFG,
-      &getDeadEndBlocks());
-  (void)foundCriticalEdges;
-  assert(!foundCriticalEdges);
-  auto loc = RegularLocation::getAutoGeneratedLocation();
-  while (!lifetimeFrontier.empty()) {
-    auto *insertPoint = lifetimeFrontier.pop_back_val();
-    SILBuilderWithScope builder(insertPoint);
-    builder.createEndBorrow(loc, lbi);
-  }
-
-  // Then delete all of our destroy_value.
-  auto destroyValues = lr.getDestroyingUses();
-  while (!destroyValues.empty()) {
-    auto *dvi = destroyValues.back();
-    destroyValues = destroyValues.drop_back();
-    eraseInstruction(dvi->getUser());
-    ++NumEliminatedInsts;
-  }
-
-  // RAUW our other uses from the load to the load_borrow.
-  eraseAndRAUWSingleValueInstruction(li, lbi);
-
-  // And then change the ownership all of our owned forwarding users to be
-  // guaranteed.
-  convertForwardingUsesFromOwnedToGuaranteed(
-      lr.getNonConsumingForwardingUses());
-
+  lr.insertEndBorrowsAtDestroys(lbi, getDeadEndBlocks(), lifetimeFrontier);
+  std::move(lr).convertToGuaranteedAndRAUW(lbi, getCallbacks());
   ++NumEliminatedInsts;
   ++NumLoadCopyConvertedToLoadBorrow;
   return true;