OwnershipUseVisitor::visitInnerBorrowUses: support dependent values

Add liveness support for dependent values: borrowed-from & mark_dependence so
they aren't reported as unknown uses.

Centralize the logic in BorrowingOperand::getScopeIntroducingUserResult
and BorrowingOperand::getDependentUserResult().

Author: atrick

include/swift/SIL/OwnershipUseVisitor.h

@@ -261,17 +261,36 @@ bool OwnershipUseVisitor<Impl>::visitOuterBorrowScopeEnd(Operand *borrowEnd) {
 /// (begin_borrow, load_borrow, or begin_apply).
 template <typename Impl>
 bool OwnershipUseVisitor<Impl>::visitInnerBorrow(Operand *borrowingOperand) {
-  if (!asImpl().handleInnerBorrow(borrowingOperand))
-    return false;
+  auto bo = BorrowingOperand(borrowingOperand);
+  assert(bo && "unexpected Borrow operand ownership");
+  if (bo.getScopeIntroducingUserResult()) {
+    if (!asImpl().handleInnerBorrow(borrowingOperand))
+      return false;
 
-  return BorrowingOperand(borrowingOperand)
-    .visitScopeEndingUses(
+    return bo.visitScopeEndingUses(
       [&](Operand *borrowEnd) {
         return visitInnerBorrowScopeEnd(borrowEnd);
       },
       [&](Operand *unknownUse) {
         return asImpl().handlePointerEscape(unknownUse);
       });
+  }
+  if (auto dependentValue = bo.getDependentUserResult()) {
+    switch (dependentValue->getOwnershipKind()) {
+    case OwnershipKind::Guaranteed:
+      if (!handleUsePoint(borrowingOperand,
+                          UseLifetimeConstraint::NonLifetimeEnding)) {
+        return false;
+      }
+      return visitGuaranteedUses(dependentValue);
+    case OwnershipKind::Any:
+    case OwnershipKind::None:
+    case OwnershipKind::Owned: // non-escapable
+    case OwnershipKind::Unowned:
+      break;
+    }
+  }
+  return asImpl().handlePointerEscape(borrowingOperand);
 }
 
 /// Note: borrowEnd->get() may be a borrow introducer for an inner scope, or a

include/swift/SIL/OwnershipUtils.h

@@ -362,6 +362,10 @@ struct BorrowingOperand {
   /// Returns false and early exits if the \p visitScopeEnd or \p
   /// visitUnknownUse returns false.
   ///
+  /// This only calls 'visitScopeEnd` when getScopeIntroducingUserResult() is
+  /// valid. Otherwise, it immediate calls visitUnknownUse on the current
+  /// operand.
+  ///
   /// For an instantaneous borrow, such as apply, this visits no uses. For
   /// begin_apply it visits the end_apply uses. For borrow introducers, it
   /// visits the end of the introduced borrow scope.
@@ -430,25 +434,7 @@ struct BorrowingOperand {
   /// If true, getBorrowIntroducingUserResult() can be called to acquire the
   /// SILValue that introduces a new borrow scope.
   bool hasBorrowIntroducingUser() const {
-    // TODO: Can we derive this by running a borrow introducer check ourselves?
-    switch (kind) {
-    case BorrowingOperandKind::Invalid:
-      llvm_unreachable("Using invalid case?!");
-    case BorrowingOperandKind::BeginBorrow:
-    case BorrowingOperandKind::BorrowedFrom:
-    case BorrowingOperandKind::Branch:
-      return true;
-    case BorrowingOperandKind::StoreBorrow:
-    case BorrowingOperandKind::BeginApply:
-    case BorrowingOperandKind::Apply:
-    case BorrowingOperandKind::TryApply:
-    case BorrowingOperandKind::Yield:
-    case BorrowingOperandKind::PartialApplyStack:
-    case BorrowingOperandKind::MarkDependenceNonEscaping:
-    case BorrowingOperandKind::BeginAsyncLet:
-      return false;
-    }
-    llvm_unreachable("Covered switch isn't covered?!");
+    return getBorrowIntroducingUserResult() != SILValue();
   }
 
   /// If this operand's user has a single result that introduces the borrow
@@ -457,8 +443,21 @@ struct BorrowingOperand {
   /// guaranteed forwarding phis, are not scoped.
   SILValue getBorrowIntroducingUserResult() const;
 
-  /// Return the borrowing operand's value.
-  SILValue getScopeIntroducingUserResult();
+  /// Return the borrowing operand's value if it is a scoped operation,
+  /// such as partial_apply, mark_dependence, store_borrow, begin_async_let.
+  ///
+  /// This is meant to be equivalent to BeginBorrowValue in
+  /// SwiftCompilerSources.
+  SILValue getScopeIntroducingUserResult() const;
+
+  // Return the dependent value of borrowed-from or mark_dependence.
+  //
+  // This only returns a valid result when getScopeIntroducingUserResult()
+  // returns an invalid result. Ideally, we would convert BorrowingOperand into
+  // an enum to partition the kinds of borrows.
+  //
+  // This may be a guaranteed, trivial, or owned non-escapable value.
+  SILValue getDependentUserResult() const;
 
   void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }

lib/SIL/Utils/OwnershipUtils.cpp

@@ -786,6 +786,7 @@ bool BorrowingOperand::visitExtendedScopeEndingUses(
   return visitScopeEndingUses(visitor, visitUnknownUse);
 }
 
+// This should be equivalent to SwiftCompilerSources, BorrowedValue.
 SILValue BorrowingOperand::getBorrowIntroducingUserResult() const {
   switch (kind) {
   case BorrowingOperandKind::Invalid:
@@ -800,8 +801,16 @@ SILValue BorrowingOperand::getBorrowIntroducingUserResult() const {
     return SILValue();
 
   case BorrowingOperandKind::BeginBorrow:
-  case BorrowingOperandKind::BorrowedFrom: {
     return cast<SingleValueInstruction>(op->getUser());
+
+  case BorrowingOperandKind::BorrowedFrom: {
+    // A reborrow introduces a new borrow scope, a guaranteed forwarding phi
+    // does not.
+    auto *bfi = cast<BorrowedFromInst>(op->getUser());
+    if (bfi->isReborrow()) {
+      return bfi->getBorrowedValue();
+    }
+    return SILValue();
   }
   case BorrowingOperandKind::Branch: {
     auto *bi = cast<BranchInst>(op->getUser());
@@ -811,29 +820,57 @@ SILValue BorrowingOperand::getBorrowIntroducingUserResult() const {
   llvm_unreachable("covered switch");
 }
 
-SILValue BorrowingOperand::getScopeIntroducingUserResult() {
+SILValue BorrowingOperand::getScopeIntroducingUserResult() const {
   switch (kind) {
-  case BorrowingOperandKind::Invalid:
-  case BorrowingOperandKind::Yield:
-  case BorrowingOperandKind::Apply:
-  case BorrowingOperandKind::TryApply:
-    return SILValue();
-
   case BorrowingOperandKind::BeginAsyncLet:
   case BorrowingOperandKind::PartialApplyStack:
-  case BorrowingOperandKind::MarkDependenceNonEscaping:
-  case BorrowingOperandKind::BeginBorrow:
-  case BorrowingOperandKind::BorrowedFrom:
   case BorrowingOperandKind::StoreBorrow:
     return cast<SingleValueInstruction>(op->getUser());
 
+  case BorrowingOperandKind::MarkDependenceNonEscaping:
+    if (auto *mdi = cast<MarkDependenceInst>(op->getUser())) {
+      if (mdi->hasScopedLifetime())
+        return mdi;
+    }
+    return SILValue();
+
   case BorrowingOperandKind::BeginApply:
     return cast<BeginApplyInst>(op->getUser())->getTokenResult();
 
-  case BorrowingOperandKind::Branch: {
-    PhiOperand phiOp(op);
-    return phiOp.getValue();
+  default:
+    return getBorrowIntroducingUserResult();
   }
+  llvm_unreachable("covered switch");
+}
+
+SILValue BorrowingOperand::getDependentUserResult() const {
+  switch (kind) {
+  case BorrowingOperandKind::BorrowedFrom: {
+    auto *bfi = cast<BorrowedFromInst>(op->getUser());
+    if (!bfi->isReborrow())
+      return bfi;
+    
+    return SILValue();
+  }
+  case BorrowingOperandKind::MarkDependenceNonEscaping: {
+    auto *mdi = cast<MarkDependenceInst>(op->getUser());
+    assert(mdi->isNonEscaping() && "escaping dependencies don't borrow");
+    if (!mdi->hasScopedLifetime())
+      return mdi;
+    
+    return SILValue();
+  }
+  case BorrowingOperandKind::Invalid:
+  case BorrowingOperandKind::BeginBorrow:
+  case BorrowingOperandKind::StoreBorrow:
+  case BorrowingOperandKind::BeginApply:
+  case BorrowingOperandKind::Branch:
+  case BorrowingOperandKind::Apply:
+  case BorrowingOperandKind::TryApply:
+  case BorrowingOperandKind::Yield:
+  case BorrowingOperandKind::PartialApplyStack:
+  case BorrowingOperandKind::BeginAsyncLet:
+    return SILValue();
   }
   llvm_unreachable("covered switch");
 }
@@ -1044,6 +1081,9 @@ bool BorrowedValue::visitInteriorPointerOperandHelper(
       }
 
       auto result = borrowingOperand.getBorrowIntroducingUserResult();
+      if (!result) {
+        result = borrowingOperand.getDependentUserResult();
+      }
       for (auto *use : result->getUses()) {
         if (auto intPtrOperand = InteriorPointerOperand(use)) {
           func(intPtrOperand);
@@ -1070,11 +1110,12 @@ bool BorrowedValue::visitInteriorPointerOperandHelper(
       continue;
     }
 
-    // Look through object.
+    // Look through object. SingleValueInstruction is overly restrictive but
+    // rules out any interesting corner cases.
     if (auto *svi = dyn_cast<SingleValueInstruction>(user)) {
-      if (Projection::isObjectProjection(svi)) {
-        for (SILValue result : user->getResults()) {
-          llvm::copy(result->getUses(), std::back_inserter(worklist));
+      if (ForwardingInstruction::isa(user)) {
+        for (auto *use : svi->getUses()) {
+          worklist.push_back(use);
         }
         continue;
       }