Support @guaranteed forwarding phis

Author: meg-gupta

include/swift/SIL/LinearLifetimeChecker.h

@@ -53,7 +53,7 @@ class LinearLifetimeChecker {
   class ErrorBuilder;
 
 private:
-  friend class ReborrowVerifier;
+  friend class GuaranteedPhiVerifier;
   friend class SILOwnershipVerifier;
   friend class SILValueOwnershipChecker;
 

include/swift/SIL/OwnershipUtils.h

@@ -90,6 +90,25 @@ inline bool isGuaranteedForwarding(SILValue value) {
   return canOpcodeForwardGuaranteedValues(value);
 }
 
+/// Returns true if it is a forwarding phi
+inline bool isGuaranteedForwardingPhi(SILPhiArgument *phi) {
+  if (phi->getOwnershipKind() != OwnershipKind::Guaranteed) {
+    return false;
+  }
+  bool isGuaranteedForwardingPhi = true;
+  phi->visitTransitiveIncomingPhiOperands(
+      [&](auto *phi, auto *operand) -> bool {
+        if (isa<BeginBorrowInst>(operand->get()) ||
+            isa<LoadBorrowInst>(operand->get())) {
+          isGuaranteedForwardingPhi = false;
+          return false;
+        }
+        return true;
+      });
+
+  return isGuaranteedForwardingPhi;
+}
+
 /// Is the opcode that produces \p value capable of forwarding owned values?
 ///
 /// This may be true even if the current instance of the instruction is not a
@@ -633,6 +652,21 @@ struct BorrowedValue {
   bool
   visitTransitiveLifetimeEndingUses(function_ref<bool(Operand *)> func) const;
 
+  /// Visit all GuaranteedForwarding operands of a borrow, not looking through
+  /// reborrows.
+  bool visitTransitiveGuaranteedForwardingUses(
+      function_ref<bool(Operand *)> visitor) const;
+
+  /// Visit all GuaranteedForwardingPhi uses of a borrow, not looking through
+  /// reborrows.
+  bool visitTransitiveGuaranteedForwardingPhiUses(
+      function_ref<bool(Operand *)> func) const;
+
+  /// Visit all GuaranteedForwardingPhi uses of a borrow, looking through
+  /// reborrows.
+  bool visitExtendedTransitiveGuaranteedForwardingPhiUses(
+      function_ref<bool(Operand *)> func) const;
+
   void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 
@@ -1249,14 +1283,19 @@ OwnedValueIntroducer getSingleOwnedValueIntroducer(SILValue value);
 
 using BaseValueSet = SmallPtrSet<SILValue, 8>;
 
-/// Starting from \p initialScopeOperand, find all reborrows and their
-/// corresponding base values, and run the visitor function \p
-/// visitReborrowBaseValuePair on them.
-///  Note that a reborrow phi, can have different base values based on different
-/// control flow paths.
-void findTransitiveReborrowBaseValuePairs(
-    BorrowingOperand initialScopeOperand, SILValue origBaseValue,
-    function_ref<void(SILPhiArgument *, SILValue)> visitReborrowBaseValuePair);
+/// Starting from \p borrowInst, find all reborrows along with their base
+/// values, and run the visitor function \p visitReborrowPhiBaseValuePair on
+/// them.
+void visitExtendedReborrowPhiBaseValuePairs(
+    BeginBorrowInst *borrowInst, function_ref<void(SILPhiArgument *, SILValue)>
+                                     visitReborrowPhiBaseValuePair);
+
+/// Starting from \p borrow, find all GuaranteedForwardingPhi uses along with
+/// their base values, and run the visitor function \p
+/// visitGuaranteedForwardingPhiBaseValuePair on them.
+void visitExtendedGuaranteedForwardingPhiBaseValuePairs(
+    BorrowedValue borrow, function_ref<void(SILPhiArgument *, SILValue)>
+                              visitGuaranteedForwardingPhiBaseValuePair);
 
 /// Visit the phis in the same block as \p phi which are reborrows of a borrow
 /// of one of the values reaching \p phi.

include/swift/SIL/SILValue.h

@@ -829,6 +829,8 @@ struct OperandOwnership {
     /// borrow scope.
     /// (tuple_extract, struct_extract, cast, switch)
     GuaranteedForwarding,
+    /// A GuaranteedForwarding value passed as a phi operand.
+    GuaranteedForwardingPhi,
     /// End Borrow. End the borrow scope opened directly by the operand.
     /// The operand must be a begin_borrow, begin_apply, or function argument.
     /// (end_borrow, end_apply)
@@ -923,6 +925,7 @@ inline OwnershipConstraint OperandOwnership::getOwnershipConstraint() {
   case OperandOwnership::GuaranteedForwarding:
     return {OwnershipKind::Guaranteed,
             UseLifetimeConstraint::NonLifetimeEnding};
+  case OperandOwnership::GuaranteedForwardingPhi:
   case OperandOwnership::EndBorrow:
   case OperandOwnership::Reborrow:
     return {OwnershipKind::Guaranteed, UseLifetimeConstraint::LifetimeEnding};
@@ -949,6 +952,7 @@ inline bool canAcceptUnownedValue(OperandOwnership operandOwnership) {
   case OperandOwnership::ForwardingConsume:
   case OperandOwnership::InteriorPointer:
   case OperandOwnership::GuaranteedForwarding:
+  case OperandOwnership::GuaranteedForwardingPhi:
   case OperandOwnership::EndBorrow:
   case OperandOwnership::Reborrow:
     return false;

lib/SIL/IR/OperandOwnership.cpp

@@ -439,10 +439,19 @@ OperandOwnership OperandOwnershipClassifier::visitBranchInst(BranchInst *bi) {
   ValueOwnershipKind destBlockArgOwnershipKind =
       bi->getDestBB()->getArgument(getOperandIndex())->getOwnershipKind();
 
-  // FIXME: remove this special case once all aggregate operations behave just
-  // like phis.
   if (destBlockArgOwnershipKind == OwnershipKind::Guaranteed) {
-    return OperandOwnership::Reborrow;
+    auto phiOp = getValue();
+    if (isa<BeginBorrowInst>(phiOp) || isa<LoadBorrowInst>(phiOp)) {
+      return OperandOwnership::Reborrow;
+    }
+    auto *arg = dyn_cast<SILPhiArgument>(phiOp);
+    if (!arg || !arg->isPhi()) {
+      return OperandOwnership::GuaranteedForwardingPhi;
+    }
+
+    return isGuaranteedForwardingPhi(cast<SILPhiArgument>(phiOp))
+               ? OperandOwnership::GuaranteedForwardingPhi
+               : OperandOwnership::Reborrow;
   }
   return destBlockArgOwnershipKind.getForwardingOperandOwnership(
     /*allowUnowned*/true);

lib/SIL/IR/SILValue.cpp

@@ -432,6 +432,8 @@ StringRef OperandOwnership::asString() const {
     return "interior-pointer";
   case OperandOwnership::GuaranteedForwarding:
     return "guaranteed-forwarding";
+  case OperandOwnership::GuaranteedForwardingPhi:
+    return "guaranteed-forwarding-phi";
   case OperandOwnership::EndBorrow:
     return "end-borrow";
   case OperandOwnership::Reborrow: