Eliminate unused and incomplete OSSA logic.

Author: atrick

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -153,11 +153,6 @@ struct OwnershipFixupContext {
   // used again to extend the lifetime of the replacement value.
   SmallVector<Operand *, 8> guaranteedUsePoints;
 
-  // FIXME: remove these two vectors once BorrowedLifetimeExtender is used
-  // everywhere.
-  SmallVector<Operand *, 8> transitiveBorrowedUses;
-  SmallVector<PhiOperand, 8> recursiveReborrows;
-
   /// Extra state initialized by OwnershipRAUWFixupHelper::get() that we use
   /// when RAUWing addresses. This ensures we do not need to recompute this
   /// state when we perform the actual RAUW.
@@ -191,8 +186,6 @@ struct OwnershipFixupContext {
 
   void clear() {
     guaranteedUsePoints.clear();
-    transitiveBorrowedUses.clear();
-    recursiveReborrows.clear();
     extraAddressFixupInfo.allAddressUsesFromOldValue.clear();
     extraAddressFixupInfo.base = AccessBase();
   }

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -286,37 +286,6 @@ static void cleanupOperandsBeforeDeletion(SILInstruction *oldValue,
   }
 }
 
-static SILPhiArgument *
-insertOwnedBaseValueAlongBranchEdge(BranchInst *bi, SILValue innerCopy,
-                                    InstModCallbacks &callbacks) {
-  auto *destBB = bi->getDestBB();
-  // We need to create the phi argument before calling addNewEdgeValueToBranch
-  // since it checks that the destination block has enough arguments for the
-  // argument.
-  auto *phiArg =
-      destBB->createPhiArgument(innerCopy->getType(), OwnershipKind::Owned);
-  InstructionDeleter deleter(callbacks);
-  addNewEdgeValueToBranch(bi, destBB, innerCopy, deleter);
-
-  // Grab our predecessor blocks, ignoring us, add to the branch edge an
-  // undef corresponding to our value.
-  //
-  // We gather all predecessor blocks in a separate array to avoid
-  // iterator invalidation issues as we mess with terminators.
-  SmallVector<SILBasicBlock *, 8> predecessorBlocks(
-      destBB->getPredecessorBlocks());
-
-  for (auto *predBlock : predecessorBlocks) {
-    if (predBlock == innerCopy->getParentBlock())
-      continue;
-    addNewEdgeValueToBranch(
-        predBlock->getTerminator(), destBB,
-        SILUndef::get(innerCopy->getType(), *destBB->getParent()), deleter);
-  }
-
-  return phiArg;
-}
-
 //===----------------------------------------------------------------------===//
 //                      Ownership RAUW Helper Functions
 //===----------------------------------------------------------------------===//
@@ -373,9 +342,6 @@ bool OwnershipRAUWHelper::hasValidRAUWOwnership(SILValue oldValue,
 
 // Determine whether it is valid to replace \p oldValue with \p newValue and
 // extend the lifetime of \p oldValue to cover the new uses.
-//
-// This updates the OwnershipFixupContext, populating transitiveBorrowedUses and
-// recursiveReborrows.
 static bool canFixUpOwnershipForRAUW(SILValue oldValue, SILValue newValue,
                                      OwnershipFixupContext &context) {
   if (!OwnershipRAUWHelper::hasValidRAUWOwnership(oldValue, newValue))
@@ -388,26 +354,6 @@ static bool canFixUpOwnershipForRAUW(SILValue oldValue, SILValue newValue,
   // book-keeping in the OwnershipFixupContext.
   context.clear();
 
-  if (auto borrowedValue = BorrowedValue(oldValue)) {
-    // FIXME: remove this logic and use BorrowedLifetimeExtender.
-    SmallPtrSet<SILValue, 4> reborrows;
-    auto visitReborrow = [&](Operand *endScope) {
-      auto borrowingOper = BorrowingOperand(endScope);
-      assert(borrowingOper.isReborrow());
-      if (reborrows.insert(borrowingOper.getBorrowIntroducingUserResult().value)
-              .second) {
-        context.recursiveReborrows.push_back(endScope);
-      }
-    };
-    findTransitiveGuaranteedUses(oldValue, context.transitiveBorrowedUses,
-                                 visitReborrow);
-    for (unsigned idx = 0; idx < context.recursiveReborrows.size(); ++idx) {
-      findTransitiveGuaranteedUses(context.recursiveReborrows[idx].getValue(),
-                                   context.transitiveBorrowedUses,
-                                   visitReborrow);
-    }
-    return true;
-  }
   // Check that no transitive uses have a PointerEscape, and record the leaf
   // uses for liveness extension.
   return findExtendedTransitiveGuaranteedUses(oldValue,
@@ -708,15 +654,6 @@ struct OwnershipLifetimeExtender {
   /// the BorrowedValue that begins the scope.
   SILValue borrowOverSingleUse(SILValue newValue,
                                Operand *singleGuaranteedUse);
-
-  // --- FIXME!!! remove the following (replaced by BorrowedLifetimeExtender)
-
-  /// Create a new borrow scope for \p newValue that is cleaned up along all
-  /// paths that do not go through consuming point. The caller is expected to
-  /// consumg \p newValue at \p consumingPoint since we insert a destroy_value
-  /// right after wards.
-  BeginBorrowInst *createPlusOneBorrow(SILValue newValue,
-                                       SILInstruction *consumingPoint);
 };
 
 } // end anonymous namespace
@@ -768,59 +705,6 @@ OwnershipLifetimeExtender::createPlusOneCopy(SILValue value,
   return result;
 }
 
-// FIXME: This can be completely removed
-BeginBorrowInst *
-OwnershipLifetimeExtender::createPlusOneBorrow(SILValue value,
-                                               SILInstruction *consumingPoint) {
-  auto *newValInsertPt = value->getDefiningInsertionPoint();
-  assert(newValInsertPt);
-  CopyValueInst *copy;
-  BeginBorrowInst *borrow;
-  if (!isa<SILArgument>(value)) {
-    SILBuilderWithScope::insertAfter(newValInsertPt, [&](SILBuilder &builder) {
-      copy = builder.createCopyValue(builder.getInsertionPointLoc(), value);
-      borrow = builder.createBeginBorrow(builder.getInsertionPointLoc(), copy);
-    });
-  } else {
-    SILBuilderWithScope builder(newValInsertPt);
-    copy = builder.createCopyValue(newValInsertPt->getLoc(), value);
-    borrow = builder.createBeginBorrow(newValInsertPt->getLoc(), copy);
-  }
-
-  auto &callbacks = ctx.callbacks;
-  callbacks.createdNewInst(copy);
-  callbacks.createdNewInst(borrow);
-
-  auto *result = borrow;
-  findJointPostDominatingSet(
-      newValInsertPt->getParent(), consumingPoint->getParent(),
-      // inputBlocksFoundDuringWalk.
-      [&](SILBasicBlock *loopBlock) {
-        // This must be consumingPoint->getParent() since we only have one
-        // consuming use. In this case, we know that this is the consuming
-        // point where we will need a control equivalent copy_value (and that
-        // destroy_value will be put for the out of loop value as appropriate.
-        assert(loopBlock == consumingPoint->getParent());
-        auto front = loopBlock->begin();
-        SILBuilderWithScope newBuilder(front);
-        result = newBuilder.createBeginBorrow(front->getLoc(), borrow);
-        callbacks.createdNewInst(result);
-
-        llvm_unreachable("Should never visit this!");
-      },
-      // Input blocks in joint post dom set. We don't care about thse.
-      [&](SILBasicBlock *postDomBlock) {
-        auto front = postDomBlock->begin();
-        SILBuilderWithScope newBuilder(front);
-        auto loc = RegularLocation::getAutoGeneratedLocation(front->getLoc());
-        auto *ebi = newBuilder.createEndBorrow(loc, borrow);
-        callbacks.createdNewInst(ebi);
-        auto *dvi = newBuilder.createDestroyValue(loc, copy);
-        callbacks.createdNewInst(dvi);
-      });
-  return result;
-}
-
 // A copy_value that we lifetime extend with destroy_value over range. We assume
 // all instructions passed into range do not consume value.
 template <typename RangeTy>
@@ -1060,83 +944,6 @@ OwnershipLifetimeExtender::borrowOverSingleUse(SILValue newValue,
   return newBeginBorrow;
 }
 
-//===----------------------------------------------------------------------===//
-//                            Reborrow Elimination
-//===----------------------------------------------------------------------===//
-
-static void eliminateReborrowsOfRecursiveBorrows(
-    ArrayRef<PhiOperand> transitiveReborrows,
-    SmallVectorImpl<Operand *> &usePoints, InstModCallbacks &callbacks) {
-  SmallVector<std::pair<SILPhiArgument *, SILPhiArgument *>, 8>
-      baseBorrowedValuePair;
-  // Ok, we have transitive reborrows.
-  for (auto it : transitiveReborrows) {
-    // We eliminate the reborrow by creating a new copy+borrow at the reborrow
-    // edge from the base value and using that for the reborrow instead of the
-    // actual value. We of course insert an end_borrow for our original incoming
-    // value.
-    auto *bi = cast<BranchInst>(it.predBlock->getTerminator());
-    auto &op = bi->getOperandRef(it.argIndex);
-    BorrowingOperand borrowingOperand(&op);
-    SILValue value = borrowingOperand->get();
-    SILBuilderWithScope reborrowBuilder(bi);
-    // Use an auto-generated location here, because the branch may have an
-    // incompatible LocationKind
-    auto loc = RegularLocation::getAutoGeneratedLocation(bi->getLoc());
-    auto *innerCopy = reborrowBuilder.createCopyValue(loc, value);
-    auto *innerBorrow = reborrowBuilder.createBeginBorrow(loc, innerCopy);
-    auto *outerEndBorrow = reborrowBuilder.createEndBorrow(loc, value);
-
-    callbacks.createdNewInst(innerCopy);
-    callbacks.createdNewInst(innerBorrow);
-    callbacks.createdNewInst(outerEndBorrow);
-
-    // Then set our borrowing operand to take our innerBorrow instead of value
-    // (whose lifetime we just ended).
-    callbacks.setUseValue(*borrowingOperand, innerBorrow);
-    // Add our outer end borrow as a use point to make sure that we extend our
-    // base value to this point.
-    usePoints.push_back(&outerEndBorrow->getAllOperands()[0]);
-
-    // Then check if in our destination block, we have further reborrows. If we
-    // do, we need to recursively process them.
-    auto *borrowedArg =
-        const_cast<SILPhiArgument *>(bi->getArgForOperand(*borrowingOperand));
-    auto *baseArg =
-        insertOwnedBaseValueAlongBranchEdge(bi, innerCopy, callbacks);
-    baseBorrowedValuePair.emplace_back(baseArg, borrowedArg);
-  }
-
-  // Now recursively update all further reborrows...
-  while (!baseBorrowedValuePair.empty()) {
-    SILPhiArgument *baseArg;
-    SILPhiArgument *borrowedArg;
-    std::tie(baseArg, borrowedArg) = baseBorrowedValuePair.pop_back_val();
-
-    for (auto *use : borrowedArg->getConsumingUses()) {
-      // If our consuming use is an end of scope marker, we need to end
-      // the lifetime of our base arg.
-      if (isEndOfScopeMarker(use->getUser())) {
-        SILBuilderWithScope::insertAfter(use->getUser(), [&](SILBuilder &b) {
-          auto *dvi = b.createDestroyValue(b.getInsertionPointLoc(), baseArg);
-          callbacks.createdNewInst(dvi);
-        });
-        continue;
-      }
-
-      // Otherwise, we have a reborrow. For now our reborrows must be
-      // phis. Add our owned value as a new argument of that phi along our
-      // edge and undef along all other edges.
-      auto borrowingOp = BorrowingOperand(use);
-      auto *brInst = cast<BranchInst>(borrowingOp.op->getUser());
-      auto *newBorrowedPhi = brInst->getArgForOperand(*borrowingOp);
-      auto *newBasePhi =
-          insertOwnedBaseValueAlongBranchEdge(brInst, baseArg, callbacks);
-      baseBorrowedValuePair.emplace_back(newBasePhi, newBorrowedPhi);
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                OwnershipRAUWUtility - RAUW + fix ownership
 //===----------------------------------------------------------------------===//
@@ -1622,35 +1429,6 @@ SILBasicBlock::iterator SingleUseReplacementUtility::handleGuaranteed() {
   // Ok, our use is guaranteed and our new value may not be guaranteed.
   auto extender = getLifetimeExtender();
 
-  // If our original use was a lifetime ending use...
-  //
-  // TODO: Also just call borrowOverSingleUse in the lifetime-ending case.
-  if (use->isLifetimeEnding()) {
-    // And additionally was a reborrow, we will have placed it in recursive
-    // reborrows. In this case the RAUW
-    if (ctx.recursiveReborrows.size()) {
-      eliminateReborrowsOfRecursiveBorrows(
-          ctx.recursiveReborrows, ctx.transitiveBorrowedUses, ctx.callbacks);
-      // By eliminate the reborrows our lifetime ending use was already
-      // handled. Now, we need to lifetime extend the borrow over all of the
-      // end_lifetime after we eliminate the reborrow. These will be the
-      // transitive borrowed uses.
-      auto borrowPt = newValue->getNextInstruction()->getIterator();
-      SILValue borrow = extender.borrowCopyOverGuaranteedUses(
-          newValue, borrowPt, llvm::makeArrayRef(ctx.transitiveBorrowedUses));
-
-      // Then replace use->get() with this borrow.
-      return replaceSingleUse(use, borrow, ctx.callbacks);
-    } else {
-      // If we didn't have a reborrow and still had a lifetime ending use,
-      // handle it.
-      SILValue borrow = extender.createPlusOneBorrow(newValue, use->getUser());
-      // Then replace use->get() with this copy. We will insert compensating end
-      // scope instructions on use->get() if we need to.
-      return replaceSingleUse(use, borrow, ctx.callbacks);
-    }
-  }
-
   // If we don't have a lifetime ending use, just create the borrow.
   SILValue copy = extender.borrowOverSingleUse(newValue, use);