Merge pull request #65478 from nate-chandler/rdar108627366

[SILOptimizer] Use BitfieldRef instead of invalidating SSAPrunedLiveness.

Author: nate-chandler

lib/SILOptimizer/Mandatory/DiagnoseLifetimeIssues.cpp

@@ -66,7 +66,7 @@ class DiagnoseLifetimeIssues {
   SILFunction *function = nullptr;
 
   /// The liveness of the object in question, computed in visitUses.
-  SSAPrunedLiveness liveness;
+  BitfieldRef<SSAPrunedLiveness> liveness;
 
   /// All weak stores of the object, which are found in visitUses.
   llvm::SmallVector<SILInstruction *, 8> weakStores;
@@ -86,8 +86,7 @@ class DiagnoseLifetimeIssues {
   void reportDeadStore(SILInstruction *allocationInst);
 
 public:
-  DiagnoseLifetimeIssues(SILFunction *function)
-    : function(function), liveness(function) {}
+  DiagnoseLifetimeIssues(SILFunction *function) : function(function) {}
 
   void diagnose();
 };
@@ -215,7 +214,7 @@ visitUses(SILValue def, bool updateLivenessAndWeakStores, int callDepth) {
       case OperandOwnership::UnownedInstantaneousUse:
       case OperandOwnership::BitwiseEscape:
         if (updateLivenessAndWeakStores)
-          liveness.updateForUse(user, /*lifetimeEnding*/ false);
+          liveness->updateForUse(user, /*lifetimeEnding*/ false);
         break;
       case OperandOwnership::GuaranteedForwarding:
       case OperandOwnership::ForwardingConsume:
@@ -241,9 +240,9 @@ visitUses(SILValue def, bool updateLivenessAndWeakStores, int callDepth) {
           return CanEscape;
         break;
       case OperandOwnership::Borrow: {
-        if (updateLivenessAndWeakStores
-            && (liveness.updateForBorrowingOperand(use)
-                != InnerBorrowKind::Contained)) {
+        if (updateLivenessAndWeakStores &&
+            (liveness->updateForBorrowingOperand(use) !=
+             InnerBorrowKind::Contained)) {
           return CanEscape;
         }
         BorrowingOperand borrowOper(use);
@@ -326,11 +325,12 @@ static bool isOutOfLifetime(SILInstruction *inst, SSAPrunedLiveness &liveness) {
 /// Reports a warning if the stored object \p storedObj is never loaded within
 /// the lifetime of the stored object.
 void DiagnoseLifetimeIssues::reportDeadStore(SILInstruction *allocationInst) {
-  liveness.invalidate();
+  BitfieldRef<SSAPrunedLiveness>::StackState livenessBitfieldContainer(
+      liveness, allocationInst->getFunction());
   weakStores.clear();
 
   SILValue storedDef = cast<SingleValueInstruction>(allocationInst);
-  liveness.initializeDef(storedDef);
+  liveness->initializeDef(storedDef);
 
   // Compute the canonical lifetime of storedDef, like the copy-propagation pass
   // would do.
@@ -346,7 +346,7 @@ void DiagnoseLifetimeIssues::reportDeadStore(SILInstruction *allocationInst) {
   assert((state == IsStoredWeakly) == !weakStores.empty());
 
   for (SILInstruction *storeInst : weakStores) {
-    if (isOutOfLifetime(storeInst, liveness)) {
+    if (isOutOfLifetime(storeInst, *liveness)) {
       // Issue the warning.
       storeInst->getModule().getASTContext().Diags.diagnose(
         storeInst->getLoc().getSourceLoc(), diag::warn_dead_weak_store);

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1359,14 +1359,13 @@ struct GatherUsesVisitor final : public TransitiveAddressWalker {
 
   // Pruned liveness used to validate that load [take]/load [copy] can be
   // converted to load_borrow without violating exclusivity.
-  SSAPrunedLiveness &liveness;
+  BitfieldRef<SSAPrunedLiveness> liveness;
 
   GatherUsesVisitor(MoveOnlyAddressCheckerPImpl &moveChecker,
                     UseState &useState, MarkMustCheckInst *markedValue,
-                    DiagnosticEmitter &diagnosticEmitter,
-                    SSAPrunedLiveness &gatherUsesLiveness)
+                    DiagnosticEmitter &diagnosticEmitter)
       : moveChecker(moveChecker), useState(useState), markedValue(markedValue),
-        diagnosticEmitter(diagnosticEmitter), liveness(gatherUsesLiveness) {}
+        diagnosticEmitter(diagnosticEmitter) {}
 
   bool visitUse(Operand *op) override;
   void reset(MarkMustCheckInst *address) { useState.address = address; }
@@ -1383,7 +1382,8 @@ struct GatherUsesVisitor final : public TransitiveAddressWalker {
 
   /// Returns true if we emitted an error.
   bool checkForExclusivityHazards(LoadInst *li) {
-    SWIFT_DEFER { liveness.invalidate(); };
+    BitfieldRef<SSAPrunedLiveness>::StackState state(liveness,
+                                                     li->getFunction());
 
     LLVM_DEBUG(llvm::dbgs() << "Checking for exclusivity hazards for: " << *li);
 
@@ -1404,10 +1404,10 @@ struct GatherUsesVisitor final : public TransitiveAddressWalker {
     }
 
     bool emittedError = false;
-    liveness.initializeDef(bai);
-    liveness.computeSimple();
+    liveness->initializeDef(bai);
+    liveness->computeSimple();
     for (auto *consumingUse : li->getConsumingUses()) {
-      if (!liveness.isWithinBoundary(consumingUse->getUser())) {
+      if (!liveness->isWithinBoundary(consumingUse->getUser())) {
         diagnosticEmitter.emitAddressExclusivityHazardDiagnostic(
             markedValue, consumingUse->getUser());
         emittedError = true;
@@ -2415,10 +2415,8 @@ bool MoveOnlyAddressCheckerPImpl::performSingleCheck(
   // Then gather all uses of our address by walking from def->uses. We use this
   // to categorize the uses of this address into their ownership behavior (e.x.:
   // init, reinit, take, destroy, etc.).
-  SmallVector<SILBasicBlock *, 32> gatherUsesDiscoveredBlocks;
-  SSAPrunedLiveness gatherUsesLiveness(fn, &gatherUsesDiscoveredBlocks);
   GatherUsesVisitor visitor(*this, addressUseState, markedAddress,
-                            diagnosticEmitter, gatherUsesLiveness);
+                            diagnosticEmitter);
   SWIFT_DEFER { visitor.clear(); };
   visitor.reset(markedAddress);
   if (AddressUseKind::Unknown == std::move(visitor).walk(markedAddress)) {