Merge pull request #27211 from gottesmm/pr-9566688fe160ddaa5cdb741e119f513579ad8c4d

[ownership] Create a context structure for the linear lifetime checker.

Author: gottesmm

include/swift/SIL/OwnershipUtils.h

@@ -127,27 +127,50 @@ class LinearLifetimeError {
   }
 };
 
-/// Returns true if:
+/// A class used to validate linear lifetime with respect to an SSA-like
+/// definition.
 ///
-/// 1. No consuming uses are reachable from any other consuming use, from any
-/// non-consuming uses, or from the producer instruction.
-/// 2. The consuming use set jointly post dominates producers and all non
-/// consuming uses.
+/// This class is able to both validate that a linear lifetime has been properly
+/// constructed (for verification and safety purposes) as well as return to the
+/// caller upon failure, what the failure was. In certain cases (for instance if
+/// there exists a path without a non-consuming use), the class will report back
+/// the specific insertion points needed to insert these compensating releases.
 ///
-/// \p value The value whose lifetime we are checking.
-/// \p consumingUses the array of users that destroy or consume a value.
-/// \p nonConsumingUses regular uses
-/// \p deadEndBlocks a cache for the dead end block computation
-/// \p errorBehavior If we detect an error, should we return false or hard
-/// error.
-/// \p leakingBlocks If non-null a list of blocks where the value was detected
-/// to leak. Can be used to insert missing destroys.
-LinearLifetimeError valueHasLinearLifetime(
-    SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
-    ArrayRef<BranchPropagatedUser> nonConsumingUses,
-    SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-    DeadEndBlocks &deadEndBlocks, ownership::ErrorBehaviorKind errorBehavior,
-    SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
+/// DISCUSSION: A linear lifetime consists of a starting block or instruction
+/// and a list of non-consuming uses and a set of consuming uses. The consuming
+/// uses must not be reachable from each other and jointly post-dominate all
+/// consuming uses as well as the defining block/instruction.
+class LinearLifetimeChecker {
+  SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks;
+  DeadEndBlocks &deadEndBlocks;
+
+public:
+  LinearLifetimeChecker(SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                        DeadEndBlocks &deadEndBlocks)
+      : visitedBlocks(visitedBlocks), deadEndBlocks(deadEndBlocks) {}
+
+  /// Returns true if:
+  ///
+  /// 1. No consuming uses are reachable from any other consuming use, from any
+  /// non-consuming uses, or from the producer instruction.
+  /// 2. The consuming use set jointly post dominates producers and all non
+  /// consuming uses.
+  ///
+  /// Returns false otherwise.
+  ///
+  /// \p value The value whose lifetime we are checking.
+  /// \p consumingUses the array of users that destroy or consume a value.
+  /// \p nonConsumingUses regular uses
+  /// \p errorBehavior If we detect an error, should we return false or hard
+  /// error.
+  /// \p leakingBlocks If non-null a list of blocks where the value was detected
+  /// to leak. Can be used to insert missing destroys.
+  LinearLifetimeError
+  checkValue(SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
+             ArrayRef<BranchPropagatedUser> nonConsumingUses,
+             ownership::ErrorBehaviorKind errorBehavior,
+             SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
+};
 
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);

lib/SIL/LinearLifetimeChecker.cpp

@@ -507,10 +507,9 @@ void State::checkDataflowEndState(DeadEndBlocks &deBlocks) {
 //                           Top Level Entrypoints
 //===----------------------------------------------------------------------===//
 
-LinearLifetimeError swift::valueHasLinearLifetime(
+LinearLifetimeError LinearLifetimeChecker::checkValue(
     SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
     ArrayRef<BranchPropagatedUser> nonConsumingUses,
-    SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks, DeadEndBlocks &deBlocks,
     ErrorBehaviorKind errorBehavior,
     SmallVectorImpl<SILBasicBlock *> *leakingBlocks) {
   assert(!consumingUses.empty() && "Must have at least one consuming user?!");
@@ -547,7 +546,7 @@ LinearLifetimeError swift::valueHasLinearLifetime(
     // same block, we would have flagged.
     if (llvm::any_of(nonConsumingUses, [&](BranchPropagatedUser user) {
           return user.getParent() != value->getParentBlock() &&
-            !deBlocks.isDeadEnd(user.getParent());
+                 !deadEndBlocks.isDeadEnd(user.getParent());
         })) {
       state.error.handleUseAfterFree([&] {
         llvm::errs() << "Function: '" << value->getFunction()->getName()
@@ -592,10 +591,10 @@ LinearLifetimeError swift::valueHasLinearLifetime(
 
   // Now that our algorithm is completely prepared, run the
   // dataflow... If we find a failure, return false.
-  state.performDataflow(deBlocks);
+  state.performDataflow(deadEndBlocks);
 
   // ...and then check that the end state shows that we have a valid linear
   // typed value.
-  state.checkDataflowEndState(deBlocks);
+  state.checkDataflowEndState(deadEndBlocks);
   return state.error;
 }

lib/SIL/OwnershipUtils.cpp

@@ -206,8 +206,8 @@ bool BorrowScopeIntroducingValue::areInstructionsWithinScope(
   visitLocalScopeEndingInstructions(
       [&scratchSpace](SILInstruction *i) { scratchSpace.emplace_back(i); });
 
-  auto result = valueHasLinearLifetime(
-      value, scratchSpace, instructions, visitedBlocks, deadEndBlocks,
-      ownership::ErrorBehaviorKind::ReturnFalse);
+  LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+  auto result = checker.checkValue(value, scratchSpace, instructions,
+                                   ownership::ErrorBehaviorKind::ReturnFalse);
   return !result.getFoundError();
 }

lib/SIL/SILOwnershipVerifier.cpp

@@ -136,9 +136,9 @@ class SILValueOwnershipChecker {
     SmallVector<BranchPropagatedUser, 32> allRegularUsers;
     llvm::copy(regularUsers, std::back_inserter(allRegularUsers));
     llvm::copy(implicitRegularUsers, std::back_inserter(allRegularUsers));
-    auto linearLifetimeResult =
-        valueHasLinearLifetime(value, lifetimeEndingUsers, allRegularUsers,
-                               visitedBlocks, deadEndBlocks, errorBehavior);
+    LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+    auto linearLifetimeResult = checker.checkValue(
+        value, lifetimeEndingUsers, allRegularUsers, errorBehavior);
     result = !linearLifetimeResult.getFoundError();
 
     return result.getValue();

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -150,9 +150,9 @@ static void fixupReferenceCounts(
       // just cares about the block the value is in. In a forthcoming commit, I
       // am going to change this to use a different API on the linear lifetime
       // checker that makes this clearer.
-      auto error =
-          valueHasLinearLifetime(pai, {applySite}, {}, visitedBlocks,
-                                 deadEndBlocks, errorBehavior, &leakingBlocks);
+      LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+      auto error = checker.checkValue(pai, {applySite}, {}, errorBehavior,
+                                      &leakingBlocks);
       if (error.getFoundLeak()) {
         while (!leakingBlocks.empty()) {
           auto *leakingBlock = leakingBlocks.pop_back_val();
@@ -201,9 +201,9 @@ static void fixupReferenceCounts(
       // just cares about the block the value is in. In a forthcoming commit, I
       // am going to change this to use a different API on the linear lifetime
       // checker that makes this clearer.
-      auto error =
-          valueHasLinearLifetime(pai, {applySite}, {}, visitedBlocks,
-                                 deadEndBlocks, errorBehavior, &leakingBlocks);
+      LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+      auto error = checker.checkValue(pai, {applySite}, {}, errorBehavior,
+                                      &leakingBlocks);
       if (error.getFoundError()) {
         while (!leakingBlocks.empty()) {
           auto *leakingBlock = leakingBlocks.pop_back_val();
@@ -240,9 +240,9 @@ static void fixupReferenceCounts(
       // just cares about the block the value is in. In a forthcoming commit, I
       // am going to change this to use a different API on the linear lifetime
       // checker that makes this clearer.
-      auto error =
-          valueHasLinearLifetime(pai, {applySite}, {}, visitedBlocks,
-                                 deadEndBlocks, errorBehavior, &leakingBlocks);
+      LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+      auto error = checker.checkValue(pai, {applySite}, {}, errorBehavior,
+                                      &leakingBlocks);
       if (error.getFoundError()) {
         while (!leakingBlocks.empty()) {
           auto *leakingBlock = leakingBlocks.pop_back_val();

lib/SILOptimizer/Mandatory/PredictableMemOpt.cpp

@@ -780,9 +780,8 @@ AvailableValueAggregator::addMissingDestroysForCopiedValues(
     // Then perform the linear lifetime check. If we succeed, continue. We have
     // no further work to do.
     auto errorKind = ownership::ErrorBehaviorKind::ReturnFalse;
-    auto error =
-        valueHasLinearLifetime(cvi, {svi}, {}, visitedBlocks, deadEndBlocks,
-                               errorKind, &leakingBlocks);
+    LinearLifetimeChecker checker(visitedBlocks, deadEndBlocks);
+    auto error = checker.checkValue(cvi, {svi}, {}, errorKind, &leakingBlocks);
     if (!error.getFoundError())
       continue;
 

lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -671,11 +671,10 @@ class StorageGuaranteesLoadVisitor
     }
 
     SmallPtrSet<SILBasicBlock *, 4> visitedBlocks;
-    
-    auto result = valueHasLinearLifetime(baseObject, baseEndBorrows,
-                                   valueDestroys, visitedBlocks,
-                                   ARCOpt.getDeadEndBlocks(),
-                                   ownership::ErrorBehaviorKind::ReturnFalse);
+
+    LinearLifetimeChecker checker(visitedBlocks, ARCOpt.getDeadEndBlocks());
+    auto result = checker.checkValue(baseObject, baseEndBorrows, valueDestroys,
+                                     ownership::ErrorBehaviorKind::ReturnFalse);
     return answer(result.getFoundError());
   }