Merge pull request #75422 from nate-chandler/opt/20240722/1

nate-chandler · web-flow · commit 1901aa708276 · 2024-07-23T20:56:51.000-07:00
[NFC] PrunedLiveness: Clarified boundary API.
diff --git a/include/swift/SIL/PrunedLiveness.h b/include/swift/SIL/PrunedLiveness.h
@@ -617,10 +617,13 @@ class PrunedLiveRange : public PrunedLiveness {
   bool isAvailableOut(SILBasicBlock *block, DeadEndBlocks &deadEndBlocks) const;
   bool isInstructionAvailable(SILInstruction *user,
                               DeadEndBlocks &deadEndBlocks) const;
+  /// Whether \p user is within the liveness boundary (never extended into
+  /// dead-end regions).
+  bool isWithinLivenessBoundary(SILInstruction *inst) const;
   /// Whether \p user is within the boundary extended from live regions into
   /// dead-end regions up to the availability boundary.
   bool isWithinExtendedBoundary(SILInstruction *user,
-                                DeadEndBlocks *deadEndBlocks) const;
+                                DeadEndBlocks &deadEndBlocks) const;
 
 public:
   /// Add \p inst to liveness which uses the def as indicated by \p usage.
@@ -660,7 +663,12 @@ class PrunedLiveRange : public PrunedLiveness {
 
   /// Check if \p inst occurs in between the definition this def and the
   /// liveness boundary.
-  bool isWithinBoundary(SILInstruction *inst) const;
+  ///
+  /// Pass \p deadEndBlocks when the defs' lifetime isn't known to be complete.
+  /// When passed, the liveness boundary is understood to extend into dead-end
+  /// regions.
+  bool isWithinBoundary(SILInstruction *inst,
+                        DeadEndBlocks *deadEndBlocks) const;
 
   /// Returns true when all \p uses are between this def and the liveness
   /// boundary \p deadEndBlocks is optional.
diff --git a/lib/SIL/Utils/OSSALifetimeCompletion.cpp b/lib/SIL/Utils/OSSALifetimeCompletion.cpp
@@ -131,7 +131,8 @@ static void visitUsersOutsideLinearLivenessBoundary(
       continue;
     }
     auto *user = pair.first;
-    if (linearLiveness.getLiveness().isWithinBoundary(user)) {
+    if (linearLiveness.getLiveness().isWithinBoundary(
+            user, /*deadEndBlocks=*/nullptr)) {
       continue;
     }
     visitor(user);
diff --git a/lib/SIL/Utils/PrunedLiveness.cpp b/lib/SIL/Utils/PrunedLiveness.cpp
@@ -501,7 +501,7 @@ static FunctionTest SSAUseLivenessTest("ssa_use_liveness", [](auto &function,
 } // end namespace swift::test
 
 template <typename LivenessWithDefs>
-bool PrunedLiveRange<LivenessWithDefs>::isWithinBoundary(
+bool PrunedLiveRange<LivenessWithDefs>::isWithinLivenessBoundary(
     SILInstruction *inst) const {
   assert(asImpl().isInitialized());
 
@@ -574,8 +574,18 @@ bool PrunedLiveRange<LivenessWithDefs>::isInstructionAvailable(
 }
 
 template <typename LivenessWithDefs>
-bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
+bool PrunedLiveRange<LivenessWithDefs>::isWithinBoundary(
     SILInstruction *inst, DeadEndBlocks *deadEndBlocks) const {
+  if (deadEndBlocks) {
+    return asImpl().isWithinExtendedBoundary(inst, *deadEndBlocks);
+  } else {
+    return asImpl().isWithinLivenessBoundary(inst);
+  }
+}
+
+template <typename LivenessWithDefs>
+bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
+    SILInstruction *inst, DeadEndBlocks &deadEndBlocks) const {
   // A value has a pruned live region, a live region and an available region.
   // (Note: PrunedLiveness does not distinguish between the pruned live region
   // and the live region; the pruned live region coincides with the live region
@@ -628,21 +638,13 @@ bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
   // That this region is of interest is another result of lacking complete
   // OSSA lifetimes.
 
-  if (asImpl().isWithinBoundary(inst)) {
+  if (asImpl().isWithinLivenessBoundary(inst)) {
     // The extended region is a superset of the pruned live region.
     return true;
   }
 
-  if (!deadEndBlocks) {
-    // Without knowledge of the dead-end region, the extended region can't be
-    // determined.  It could, of course, be rediscovered here, but that would
-    // be silly; instead, allowing a nullable pointer provides a mechanism for
-    // the client to indicate what invariants hold.  Specifically, omitting
-    // dead-end blocks is equivalent to asserting that lifetimes are complete.
-    return false;
-  }
   SILBasicBlock *parent = inst->getParent();
-  if (!deadEndBlocks->isDeadEnd(parent)) {
+  if (!deadEndBlocks.isDeadEnd(parent)) {
     // The extended region intersected with the non-dead-end region is equal to
     // the pruned live region.
     return false;
@@ -652,7 +654,7 @@ bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
     break;
   case PrunedLiveBlocks::LiveWithin:
     // Dead defs may result in LiveWithin but AvailableOut blocks.
-    return isInstructionAvailable(inst, *deadEndBlocks);
+    return isInstructionAvailable(inst, deadEndBlocks);
   case PrunedLiveBlocks::LiveOut:
     // The instruction is not within the boundary, but its parent is LiveOut;
     // therefore it must be a def block.
@@ -687,7 +689,7 @@ bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
   worklist.push(parent);
   while (auto *block = worklist.pop()) {
     auto isLive = liveBlocks.getBlockLiveness(block);
-    if (!deadEndBlocks->isDeadEnd(block)) {
+    if (!deadEndBlocks.isDeadEnd(block)) {
       // The first block beyond the dead-end region has been reached.
       if (isLive != PrunedLiveBlocks::LiveOut) {
         // Cases (2) above.
@@ -706,7 +708,7 @@ bool PrunedLiveRange<LivenessWithDefs>::isWithinExtendedBoundary(
     case PrunedLiveBlocks::LiveWithin:
       // Availability may have ended in this block.  Check whether the block is
       // "AvailableOut".
-      if (!isAvailableOut(block, *deadEndBlocks)) {
+      if (!isAvailableOut(block, deadEndBlocks)) {
         // Case (1) above.
         return false;
       }
@@ -799,7 +801,7 @@ bool PrunedLiveRange<LivenessWithDefs>::areUsesWithinBoundary(
 
   for (auto *use : uses) {
     auto *user = use->getUser();
-    if (!isWithinExtendedBoundary(user, deadEndBlocks))
+    if (!isWithinBoundary(user, deadEndBlocks))
       return false;
   }
   return true;
@@ -812,7 +814,7 @@ bool PrunedLiveRange<LivenessWithDefs>::areUsesOutsideBoundary(
 
   for (auto *use : uses) {
     auto *user = use->getUser();
-    if (isWithinExtendedBoundary(user, deadEndBlocks))
+    if (isWithinBoundary(user, deadEndBlocks))
       return false;
   }
   return true;
diff --git a/lib/SIL/Utils/ScopedAddressUtils.cpp b/lib/SIL/Utils/ScopedAddressUtils.cpp
@@ -202,7 +202,8 @@ bool swift::hasOtherStoreBorrowsInLifetime(StoreBorrowInst *storeBorrow,
 
   for (auto *otherStoreBorrow : otherStoreBorrows) {
     // Return true, if otherStoreBorrow was in \p storeBorrow's scope
-    if (liveness->isWithinBoundary(otherStoreBorrow)) {
+    if (liveness->isWithinBoundary(otherStoreBorrow,
+                                   /*deadEndBlocks=*/nullptr)) {
       return true;
     }
   }
diff --git a/lib/SIL/Verifier/LoadBorrowImmutabilityChecker.cpp b/lib/SIL/Verifier/LoadBorrowImmutabilityChecker.cpp
@@ -337,7 +337,7 @@ bool LoadBorrowImmutabilityAnalysis::isImmutableInScope(
       continue;
     }
 
-    if (borrowLiveness.isWithinBoundary(write)) {
+    if (borrowLiveness.isWithinBoundary(write, /*deadEndBlocks=*/nullptr)) {
       llvm::errs() << "Write: " << *write;
       return false;
     }
diff --git a/lib/SIL/Verifier/SILOwnershipVerifier.cpp b/lib/SIL/Verifier/SILOwnershipVerifier.cpp
@@ -516,7 +516,7 @@ bool SILValueOwnershipChecker::checkDeadEnds(
   }
   auto allWithinBoundary = true;
   for (auto *use : regularUses) {
-    if (!liveness.isWithinBoundary(use->getUser())) {
+    if (!liveness.isWithinBoundary(use->getUser(), /*deadEndBlocks=*/nullptr)) {
       allWithinBoundary |= errorBuilder.handleMalformedSIL([&] {
         llvm::errs()
             << "Owned value without lifetime ending uses whose regular use "
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -2714,7 +2714,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                                   LinearLiveness::DoNotIncludeExtensions);
     linearLiveness.compute();
     auto &liveness = linearLiveness.getLiveness();
-    require(!liveness.isWithinBoundary(I),
+    require(!liveness.isWithinBoundary(I, /*deadEndBlocks=*/nullptr),
             "extend_lifetime use within unextended linear liveness boundary!?");
     PrunedLivenessBoundary boundary;
     liveness.computeBoundary(boundary);
@@ -2789,7 +2789,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       if (scopedAddress.isScopeEndingUse(use)) {
         continue;
       }
-      if (!scopedAddressLiveness->isWithinBoundary(user)) {
+      if (!scopedAddressLiveness->isWithinBoundary(user,
+                                                   /*deadEndBlocks=*/nullptr)) {
         llvm::errs() << "User found outside scope: " << *user;
         return false;
       }
diff --git a/lib/SILOptimizer/Mandatory/AddressLowering.cpp b/lib/SILOptimizer/Mandatory/AddressLowering.cpp
@@ -364,7 +364,7 @@ static bool isStoreCopy(SILValue value) {
     if (summary.innerBorrowKind != InnerBorrowKind::Contained) {
       return true;
     }
-    if (!liveness.isWithinBoundary(storeInst)) {
+    if (!liveness.isWithinBoundary(storeInst, /*deadEndBlocks=*/nullptr)) {
       return true;
     }
     return false;
diff --git a/lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp b/lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp
@@ -892,7 +892,8 @@ static SILValue tryRewriteToPartialApplyStack(
         if (!origUse->getUser()->mayWriteToMemory()) {
           return true;
         }
-        if (closureLiveness.isWithinBoundary(origUse->getUser())) {
+        if (closureLiveness.isWithinBoundary(origUse->getUser(),
+                                             /*deadEndBlocks=*/nullptr)) {
           origIsUnmodifiedDuringClosureLifetime = false;
           LLVM_DEBUG(llvm::dbgs() << "-- original has other possibly writing "
                                      "use during closure lifetime\n";
diff --git a/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp b/lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp
@@ -499,7 +499,8 @@ bool ConsumeOperatorCopyableValuesChecker::check() {
         mvi->setAllowsDiagnostics(false);
 
         LLVM_DEBUG(llvm::dbgs() << "Move Value: " << *mvi);
-        if (livenessInfo.liveness->isWithinBoundary(mvi)) {
+        if (livenessInfo.liveness->isWithinBoundary(
+                mvi, /*deadEndBlocks=*/nullptr)) {
           LLVM_DEBUG(llvm::dbgs() << "    WithinBoundary: Yes!\n");
           emitDiagnosticForMove(lexicalValue, varName, mvi);
         } else {
diff --git a/lib/SILOptimizer/Mandatory/DiagnoseLifetimeIssues.cpp b/lib/SILOptimizer/Mandatory/DiagnoseLifetimeIssues.cpp
@@ -322,7 +322,7 @@ static bool isOutOfLifetime(SILInstruction *inst, SSAPrunedLiveness &liveness) {
   // impossible that a use of the object is not a potential load. So we would
   // always see a potential load if the lifetime of the object goes beyond the
   // store_weak.
-  return !liveness.isWithinBoundary(inst);
+  return !liveness.isWithinBoundary(inst, /*deadEndBlocks=*/nullptr);
 }
 
 /// Reports a warning if the stored object \p storedObj is never loaded within
diff --git a/lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp b/lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp
@@ -2052,8 +2052,8 @@ struct GatherUsesVisitor : public TransitiveAddressWalker<GatherUsesVisitor> {
     liveness->initializeDef(bai);
     liveness->computeSimple();
     for (auto *consumingUse : li->getConsumingUses()) {
-      if (!liveness->areUsesWithinBoundary(
-              {consumingUse},
+      if (!liveness->isWithinBoundary(
+              consumingUse->getUser(),
               moveChecker.deba->get(consumingUse->getFunction()))) {
         diagnosticEmitter.emitAddressExclusivityHazardDiagnostic(
             markedValue, consumingUse->getUser());
diff --git a/lib/SILOptimizer/Mandatory/ReferenceBindingTransform.cpp b/lib/SILOptimizer/Mandatory/ReferenceBindingTransform.cpp
@@ -111,7 +111,7 @@ struct ValidateAllUsesWithinLiveness : public AccessUseVisitor {
     if (isa<EndAccessInst>(user))
       return true;
 
-    if (liveness.isWithinBoundary(user)) {
+    if (liveness.isWithinBoundary(user, /*deadEndBlocks=*/nullptr)) {
       LLVM_DEBUG(llvm::dbgs() << "User in boundary: " << *user);
       diagnose(op->getUser(),
                diag::sil_referencebinding_src_used_within_inout_scope);
diff --git a/lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp b/lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp
@@ -259,7 +259,7 @@ void CanonicalizeOSSALifetime::extendLivenessToDeadEnds() {
   SSAPrunedLiveness completeLiveness(*liveness, &discoveredBlocks);
 
   for (auto destroy : destroys) {
-    if (liveness->isWithinBoundary(destroy))
+    if (liveness->isWithinBoundary(destroy, /*deadEndBlocks=*/nullptr))
       continue;
     completeLiveness.updateForUse(destroy, /*lifetimeEnding*/ true);
   }
@@ -592,7 +592,7 @@ void CanonicalizeOSSALifetime::visitExtendedUnconsumedBoundary(
 
 #ifndef NDEBUG
   for (auto *consume : consumes) {
-    assert(!liveness->isWithinBoundary(consume));
+    assert(!liveness->isWithinBoundary(consume, /*deadEndBlocks=*/nullptr));
   }
 #endif
 

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,8 @@ static void visitUsersOutsideLinearLivenessBoundary(`
`131`	`131`	`continue;`
`132`	`132`	`}`
`133`	`133`	`auto *user = pair.first;`
`134`		`- if (linearLiveness.getLiveness().isWithinBoundary(user)) {`
	`134`	`+ if (linearLiveness.getLiveness().isWithinBoundary(`
	`135`	`+ user, /deadEndBlocks=/nullptr)) {`
`135`	`136`	`continue;`
`136`	`137`	`}`
`137`	`138`	`visitor(user);`
Original file line number	Diff line number	Diff line change
`@@ -202,7 +202,8 @@ bool swift::hasOtherStoreBorrowsInLifetime(StoreBorrowInst *storeBorrow,`
`202`	`202`
`203`	`203`	`for (auto *otherStoreBorrow : otherStoreBorrows) {`
`204`	`204`	`// Return true, if otherStoreBorrow was in \p storeBorrow's scope`
`205`		`- if (liveness->isWithinBoundary(otherStoreBorrow)) {`
	`205`	`+ if (liveness->isWithinBoundary(otherStoreBorrow,`
	`206`	`+ /deadEndBlocks=/nullptr)) {`
`206`	`207`	`return true;`
`207`	`208`	`}`
`208`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -337,7 +337,7 @@ bool LoadBorrowImmutabilityAnalysis::isImmutableInScope(`
`337`	`337`	`continue;`
`338`	`338`	`}`
`339`	`339`
`340`		`- if (borrowLiveness.isWithinBoundary(write)) {`
	`340`	`+ if (borrowLiveness.isWithinBoundary(write, /deadEndBlocks=/nullptr)) {`
`341`	`341`	`llvm::errs() << "Write: " << *write;`
`342`	`342`	`return false;`
`343`	`343`	`}`
Original file line number	Diff line number	Diff line change
`@@ -516,7 +516,7 @@ bool SILValueOwnershipChecker::checkDeadEnds(`
`516`	`516`	`}`
`517`	`517`	`auto allWithinBoundary = true;`
`518`	`518`	`for (auto *use : regularUses) {`
`519`		`- if (!liveness.isWithinBoundary(use->getUser())) {`
	`519`	`+ if (!liveness.isWithinBoundary(use->getUser(), /deadEndBlocks=/nullptr)) {`
`520`	`520`	`allWithinBoundary \|= errorBuilder.handleMalformedSIL([&] {`
`521`	`521`	`llvm::errs()`
`522`	`522`	`<< "Owned value without lifetime ending uses whose regular use "`
Original file line number	Diff line number	Diff line change
`@@ -364,7 +364,7 @@ static bool isStoreCopy(SILValue value) {`
`364`	`364`	`if (summary.innerBorrowKind != InnerBorrowKind::Contained) {`
`365`	`365`	`return true;`
`366`	`366`	`}`
`367`		`- if (!liveness.isWithinBoundary(storeInst)) {`
	`367`	`+ if (!liveness.isWithinBoundary(storeInst, /deadEndBlocks=/nullptr)) {`
`368`	`368`	`return true;`
`369`	`369`	`}`
`370`	`370`	`return false;`