Prepare OwnershipRAUWHelper support for terminator results.

The 'oldValue' can now be a terminator result instead of a
SingleValueInstruction.

Author: atrick

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -117,24 +117,26 @@ class OwnershipRAUWHelper {
 
 private:
   OwnershipFixupContext *ctx;
-  SingleValueInstruction *oldValue;
+  SILValue oldValue;
   SILValue newValue;
 
 public:
-  OwnershipRAUWHelper() : ctx(nullptr), oldValue(nullptr), newValue(nullptr) {}
+  OwnershipRAUWHelper() : ctx(nullptr) {}
 
   /// Return an instance of this class if we can perform the specific RAUW
   /// operation ignoring if the types line up. Returns None otherwise.
   ///
+  /// \p oldValue may be either a SingleValueInstruction or a terminator result.
+  ///
   /// DISCUSSION: We do not check that the types line up here so that we can
   /// allow for our users to transform our new value in ways that preserve
   /// ownership at \p oldValue before we perform the actual RAUW. If \p newValue
   /// is an object, any instructions in the chain of transforming instructions
   /// from \p newValue at \p oldValue's must be forwarding. If \p newValue is an
   /// address, then these transforms can only transform the address into a
   /// derived address.
-  OwnershipRAUWHelper(OwnershipFixupContext &ctx,
-                      SingleValueInstruction *oldValue, SILValue newValue);
+  OwnershipRAUWHelper(OwnershipFixupContext &ctx, SILValue oldValue,
+                      SILValue newValue);
 
   /// Returns true if this helper was initialized into a valid state.
   operator bool() const { return isValid(); }

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -830,10 +830,20 @@ rewriteReborrows(SILValue newBorrowedValue,
 namespace {
 
 struct OwnershipRAUWUtility {
-  SingleValueInstruction *oldValue;
+  SILValue oldValue;
   SILValue newValue;
   OwnershipFixupContext &ctx;
 
+  // For terminator results, the consuming point is the predecessor's
+  // terminator. This avoids destroys on unused paths. It is also the
+  // instruction which will be deleted, thus needs operand cleanup.
+  SILInstruction *getConsumingPoint() const {
+    if (auto *blockArg = dyn_cast<SILPhiArgument>(oldValue))
+      return blockArg->getTerminatorForResult();
+
+    return cast<SingleValueInstruction>(oldValue);
+  }
+
   SILBasicBlock::iterator handleUnowned();
 
   SILBasicBlock::iterator handleGuaranteed();
@@ -989,9 +999,9 @@ SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
   // NOTE: This handles RAUWing with undef.
   if (newValue.getOwnershipKind() == OwnershipKind::None)
     return replaceAllUsesAndErase(oldValue, newValue, ctx.callbacks);
-  assert(SILValue(oldValue).getOwnershipKind() != OwnershipKind::None);
+  assert(oldValue.getOwnershipKind() != OwnershipKind::None);
 
-  switch (SILValue(oldValue).getOwnershipKind()) {
+  switch (oldValue.getOwnershipKind()) {
   case OwnershipKind::None:
     // If our old value was none and our new value is not, we need to do
     // something more complex that we do not support yet, so bail. We should
@@ -1005,13 +1015,15 @@ SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
   case OwnershipKind::Owned: {
     // If we have an owned value that we want to replace with a value with any
     // other non-None ownership, we need to copy the other value for a
-    // lifetimeEnding RAUW, then RAUW the value, and insert a destroy_value on
+    // lifetimeEnding RAUW, RAUW the value, and insert a destroy_value of
     // the original value.
     auto extender = getLifetimeExtender();
-    SILValue copy = extender.createPlusOneCopy(newValue, oldValue);
-    cleanupOperandsBeforeDeletion(oldValue, ctx.callbacks);
-    auto result = replaceAllUsesAndErase(oldValue, copy, ctx.callbacks);
-    return result;
+    auto *consumingPoint = getConsumingPoint();
+    SILValue copy = extender.createPlusOneCopy(newValue, consumingPoint);
+
+    cleanupOperandsBeforeDeletion(consumingPoint, ctx.callbacks);
+
+    return replaceAllUsesAndErase(oldValue, copy, ctx.callbacks);
   }
   case OwnershipKind::Unowned: {
     return handleUnowned();
@@ -1027,8 +1039,7 @@ SILBasicBlock::iterator OwnershipRAUWUtility::perform() {
 SILBasicBlock::iterator
 OwnershipRAUWHelper::replaceAddressUses(SingleValueInstruction *oldValue,
                                         SILValue newValue) {
-  assert(oldValue->getType().isAddress() &&
-         oldValue->getType() == newValue->getType());
+  assert(oldValue->getType().isAddress() && newValue->getType().isAddress());
 
   // If we are replacing addresses, see if we need to handle interior pointer
   // fixups. If we don't have any extra info, then we know that we can just RAUW
@@ -1080,7 +1091,7 @@ OwnershipRAUWHelper::replaceAddressUses(SingleValueInstruction *oldValue,
 //===----------------------------------------------------------------------===//
 
 OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
-                                         SingleValueInstruction *inputOldValue,
+                                         SILValue inputOldValue,
                                          SILValue inputNewValue)
     : ctx(&inputCtx), oldValue(inputOldValue), newValue(inputNewValue) {
   // If we are already not valid, just bail.
@@ -1092,6 +1103,14 @@ OwnershipRAUWHelper::OwnershipRAUWHelper(OwnershipFixupContext &inputCtx,
   if (!oldValue->getFunction()->hasOwnership())
     return;
 
+  // This utility currently only handles erasing SingleValueInstructions and
+  // terminator results.
+  assert(isa<SingleValueInstruction>(inputOldValue)
+         || cast<SILPhiArgument>(inputOldValue)->isTerminatorResult());
+
+  // Clear the context before populating it anew.
+  ctx->clear();
+
   // Otherwise, lets check if we can perform this RAUW operation. If we can't,
   // set ctx to nullptr to invalidate the helper and return.
   if (!canFixUpOwnershipForRAUW(oldValue, newValue, inputCtx)) {
@@ -1204,9 +1223,12 @@ OwnershipRAUWHelper::perform(SingleValueInstruction *maybeTransformedNewValue) {
   // Make sure to always clear our context after we transform.
   SWIFT_DEFER { ctx->clear(); };
 
-  if (oldValue->getType().isAddress())
-    return replaceAddressUses(oldValue, actualNewValue);
-
+  if (oldValue->getType().isAddress()) {
+    assert(isa<SingleValueInstruction>(oldValue)
+           && "block argument cannot be an address");
+    return replaceAddressUses(cast<SingleValueInstruction>(oldValue),
+                              actualNewValue);
+  }
   OwnershipRAUWUtility utility{oldValue, actualNewValue, *ctx};
   return utility.perform();
 }