Merge pull request #65490 from nate-chandler/cherrypick/release/5.9/rdar108627366

5.9: [SILOptimizer] Use BitfieldRef instead of invalidating SSAPrunedLiveness.

Author: nate-chandler

include/swift/SIL/SILBitfield.h

@@ -186,8 +186,9 @@ template <typename BitfieldContainer> struct BitfieldRef {
     BitfieldRef &ref;
     BitfieldContainer container;
 
-    StackState(BitfieldRef &ref, SILFunction *function)
-        : ref(ref), container(function) {
+    template <typename... ArgTypes>
+    StackState(BitfieldRef &ref, ArgTypes &&...Args)
+        : ref(ref), container(std::forward<ArgTypes>(Args)...) {
       ref.ref = &container;
     }
 

lib/SILOptimizer/Mandatory/ConsumeOperatorCopyableValuesChecker.cpp

@@ -58,14 +58,12 @@ struct CheckerLivenessInfo {
   SmallSetVector<Operand *, 8> consumingUse;
   SmallSetVector<SILInstruction *, 8> nonLifetimeEndingUsesInLiveOut;
   SmallVector<Operand *, 8> interiorPointerTransitiveUses;
-  DiagnosticPrunedLiveness liveness;
+  BitfieldRef<DiagnosticPrunedLiveness> liveness;
 
-  CheckerLivenessInfo(SILFunction *fn)
-      : nonLifetimeEndingUsesInLiveOut(),
-        liveness(fn, nullptr, &nonLifetimeEndingUsesInLiveOut) {}
+  CheckerLivenessInfo() : nonLifetimeEndingUsesInLiveOut() {}
 
   void initDef(SILValue def) {
-    liveness.initializeDef(def);
+    liveness->initializeDef(def);
     defUseWorklist.insert(def);
   }
 
@@ -78,7 +76,6 @@ struct CheckerLivenessInfo {
 
   void clear() {
     defUseWorklist.clear();
-    liveness.invalidate();
     consumingUse.clear();
     interiorPointerTransitiveUses.clear();
     nonLifetimeEndingUsesInLiveOut.clear();
@@ -121,16 +118,16 @@ bool CheckerLivenessInfo::compute() {
       case OperandOwnership::InstantaneousUse:
       case OperandOwnership::UnownedInstantaneousUse:
       case OperandOwnership::BitwiseEscape:
-        liveness.updateForUse(user, /*lifetimeEnding*/ false);
+        liveness->updateForUse(user, /*lifetimeEnding*/ false);
         break;
       case OperandOwnership::ForwardingConsume:
         consumingUse.insert(use);
-        liveness.updateForUse(user, /*lifetimeEnding*/ true);
+        liveness->updateForUse(user, /*lifetimeEnding*/ true);
         break;
       case OperandOwnership::DestroyingConsume:
         // destroy_value does not force pruned liveness (but store etc. does).
         if (!isa<DestroyValueInst>(user)) {
-          liveness.updateForUse(user, /*lifetimeEnding*/ true);
+          liveness->updateForUse(user, /*lifetimeEnding*/ true);
         }
         consumingUse.insert(use);
         break;
@@ -147,12 +144,12 @@ bool CheckerLivenessInfo::compute() {
           // of the new variable as a use. Thus we only include the begin_borrow
           // itself as the use.
           if (bbi->isLexical()) {
-            liveness.updateForUse(bbi, false /*lifetime ending*/);
+            liveness->updateForUse(bbi, false /*lifetime ending*/);
           } else {
             // Otherwise, try to update liveness for a borrowing operand
             // use. This will make it so that we add the end_borrows of the
             // liveness use. If we have a reborrow here, we will bail.
-            if (liveness.updateForBorrowingOperand(use) !=
+            if (liveness->updateForBorrowingOperand(use) !=
                 InnerBorrowKind::Contained) {
               return false;
             }
@@ -163,7 +160,7 @@ bool CheckerLivenessInfo::compute() {
       case OperandOwnership::GuaranteedForwarding:
         // A forwarding borrow is validated as part of its parent borrow. So
         // just mark it as extending liveness and look through it.
-        liveness.updateForUse(user, /*lifetimeEnding*/ false);
+        liveness->updateForUse(user, /*lifetimeEnding*/ false);
         ForwardingOperand(use).visitForwardedValues([&](SILValue result) {
           if (SILArgument::isTerminatorResult(result)) {
             return true;
@@ -187,7 +184,8 @@ bool CheckerLivenessInfo::compute() {
           (void)addrUseKind;
           while (!interiorPointerTransitiveUses.empty()) {
             auto *addrUse = interiorPointerTransitiveUses.pop_back_val();
-            liveness.updateForUse(addrUse->getUser(), /*lifetimeEnding*/ false);
+            liveness->updateForUse(addrUse->getUser(),
+                                   /*lifetimeEnding*/ false);
           }
         }
         break;
@@ -220,8 +218,7 @@ struct ConsumeOperatorCopyableValuesChecker {
   SILLoopInfo *loopInfoToUpdate;
 
   ConsumeOperatorCopyableValuesChecker(SILFunction *fn)
-      : fn(fn), livenessInfo(fn), dominanceToUpdate(nullptr),
-        loopInfoToUpdate(nullptr) {}
+      : fn(fn), dominanceToUpdate(nullptr), loopInfoToUpdate(nullptr) {}
 
   void setDominanceToUpdate(DominanceInfo *newDFI) {
     dominanceToUpdate = newDFI;
@@ -262,7 +259,7 @@ void ConsumeOperatorCopyableValuesChecker::emitDiagnosticForMove(
   // going to be emitting a diagnostic and thus later parts of the compiler are
   // not going to run. First we look for uses in the same block as our move.
   auto *mviBlock = mvi->getParent();
-  auto mviBlockLiveness = livenessInfo.liveness.getBlockLiveness(mviBlock);
+  auto mviBlockLiveness = livenessInfo.liveness->getBlockLiveness(mviBlock);
   switch (mviBlockLiveness) {
   case PrunedLiveBlocks::Dead:
     llvm_unreachable("We should never see this");
@@ -278,7 +275,7 @@ void ConsumeOperatorCopyableValuesChecker::emitDiagnosticForMove(
     // implementation choice.
     for (SILInstruction &inst :
          make_range(std::next(mvi->getIterator()), mviBlock->end())) {
-      switch (livenessInfo.liveness.isInterestingUser(&inst)) {
+      switch (livenessInfo.liveness->isInterestingUser(&inst)) {
       case PrunedLiveness::NonUser:
         break;
       case PrunedLiveness::NonLifetimeEndingUse:
@@ -334,9 +331,9 @@ void ConsumeOperatorCopyableValuesChecker::emitDiagnosticForMove(
     // adding successors since we do not need to look further than the pruned
     // liveness boundary for uses.
     if (PrunedLiveBlocks::LiveOut !=
-        livenessInfo.liveness.getBlockLiveness(block)) {
+        livenessInfo.liveness->getBlockLiveness(block)) {
       for (SILInstruction &inst : *block) {
-        switch (livenessInfo.liveness.isInterestingUser(&inst)) {
+        switch (livenessInfo.liveness->isInterestingUser(&inst)) {
         case PrunedLiveness::NonUser:
           break;
         case PrunedLiveness::NonLifetimeEndingUse:
@@ -442,6 +439,10 @@ bool ConsumeOperatorCopyableValuesChecker::check() {
   // TODO: We should add llvm.dbg.addr support for fastisel and also teach
   // CodeGen how to handle llvm.dbg.addr better.
   while (!valuesToProcess.empty()) {
+    BitfieldRef<DiagnosticPrunedLiveness>::StackState livenessBitfieldContainer(
+        livenessInfo.liveness, fn, nullptr,
+        &livenessInfo.nonLifetimeEndingUsesInLiveOut);
+
     auto lexicalValue = valuesToProcess.front();
     valuesToProcess = valuesToProcess.drop_front(1);
     LLVM_DEBUG(llvm::dbgs() << "Visiting: " << *lexicalValue);
@@ -473,7 +474,7 @@ bool ConsumeOperatorCopyableValuesChecker::check() {
         mvi->setAllowsDiagnostics(false);
 
         LLVM_DEBUG(llvm::dbgs() << "Move Value: " << *mvi);
-        if (livenessInfo.liveness.isWithinBoundary(mvi)) {
+        if (livenessInfo.liveness->isWithinBoundary(mvi)) {
           LLVM_DEBUG(llvm::dbgs() << "    WithinBoundary: Yes!\n");
           emitDiagnosticForMove(lexicalValue, varName, mvi);
         } else {

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)) {