Expose findInnerTransitiveGuaranteedUses

Author: atrick

include/swift/SIL/OwnershipUtils.h

@@ -75,6 +75,31 @@ inline bool isForwardingConsume(SILValue value) {
   return canOpcodeForwardOwnedValues(value);
 }
 
+/// Find all "use points" of \p guaranteedValue that determine its lifetime
+/// requirement.
+///
+/// Precondition: \p guaranteedValue is not a BorrowedValue.
+///
+/// In general, if the client does not know whether \p guaranteed value
+/// introduces a borrow scope or not, it should instead call
+/// findTransitiveGuaranteedUses() which efficiently gathers use
+/// points for arbitrary guaranteed values, including those that introduce a
+/// borrow scope and may be reborrowed.
+///
+/// In valid OSSA, this should never be called on values that introduce a new
+/// scope (doing so would be extremely innefficient). The lifetime of a borrow
+/// introducing instruction is always determined by its direct EndBorrow uses
+/// (see BorrowedValue::visitLocalScopeEndingUses). None of the non-scope-ending
+/// uses are relevant, and there's no need to transively follow forwarding
+/// uses. However, this utility may be used on borrow-introducing values when
+/// updating OSSA form to place EndBorrow uses after introducing new phis.
+///
+/// When this is called on a value that does not introduce a new scope, none of
+/// the use points can be EndBorrows or Reborrows. Those uses are only allowed
+/// on borrow-introducing values.
+bool findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
+                                       SmallVectorImpl<Operand *> &usePoints);
+
 /// Find all "use points" of a guaranteed value within its enclosing borrow
 /// scope (without looking through reborrows). To find the use points of the
 /// extended borrow scope, after looking through reborrows, use
@@ -101,7 +126,7 @@ inline bool isForwardingConsume(SILValue value) {
 /// 2. If \p guaranteedValue does not introduce a borrow scope (it is not a
 /// valid BorrowedValue), then its uses are discovered transitively by looking
 /// through forwarding operations. If any use is a PointerEscape, then this
-/// returns false without adding more uses--the guaranteed values lifetime is
+/// returns false without adding more uses--the guaranteed value's lifetime is
 /// indeterminite. If a use introduces a nested borrow scope, it creates use
 /// points where the "extended" borrow scope ends. An extended borrow
 /// scope is found by looking through any reborrows that end the nested

lib/SIL/Utils/OwnershipUtils.cpp

@@ -147,21 +147,18 @@ bool swift::canOpcodeForwardOwnedValues(Operand *use) {
 //                 Guaranteed Use-Point (Lifetime) Discovery
 //===----------------------------------------------------------------------===//
 
-// Find all use points of \p guaranteedValue within its borrow scope where \p
-// guaranteedValue is not itself a BorrowedValue (it does not introduce a borrow
-// scope). This means there is no need to consider reborrows, and all uses are
-// naturally dominated by \p guaranteedValue. On the other hand, if a
-// PointerEscape is found, then no assumption can be made about \p
-// guaranteedValue's lifetime. Therefore the use points are incomplete and this
-// returns false.
+// Find all use points of \p guaranteedValue within its borrow scope. All uses
+// are naturally dominated by \p guaranteedValue. If a PointerEscape is found,
+// then no assumption can be made about \p guaranteedValue's lifetime. Therefore
+// the use points are incomplete and this returns false.
 //
 // Accumulate results in \p usePoints, ignoring existing elements.
 //
 // Skip over nested borrow scopes. Their scope-ending instructions are their use
 // points. Transitively find all nested scope-ending instructions by looking
 // through nested reborrows. Nested reborrows are not use points and \p
 // visitReborrow is not called for them.
-static bool
+bool swift::
 findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
                                   SmallVectorImpl<Operand *> &usePoints) {
   // Push the value's immediate uses.
@@ -195,7 +192,6 @@ findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
     case OperandOwnership::TrivialUse:
     case OperandOwnership::ForwardingConsume:
     case OperandOwnership::DestroyingConsume:
-    case OperandOwnership::Reborrow:
       llvm_unreachable("this operand cannot handle an inner guaranteed use");
 
     case OperandOwnership::ForwardingUnowned:
@@ -205,7 +201,12 @@ findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
     case OperandOwnership::InstantaneousUse:
     case OperandOwnership::UnownedInstantaneousUse:
     case OperandOwnership::BitwiseEscape:
-    // An end_borrow may be pushed as a use when processing a nested borrow.
+    // Reborrow only happens when this is called on a value that creates a
+    // borrow scope.
+    case OperandOwnership::Reborrow:
+    // EndBorrow either happens when this is called on a value that creates a
+    // borrow scope, or when it is pushed as a use when processing a nested
+    // borrow.
     case OperandOwnership::EndBorrow:
       break;