Merge pull request #65590 from nate-chandler/pruned-liveness/remove-invalidate

[Pruned Liveness] Removed invalidate API.

Author: nate-chandler

include/swift/SIL/PrunedLiveness.h

@@ -202,10 +202,6 @@ class PrunedLiveBlocks {
 
   bool isInitialized() const { return initializedFlag; }
 
-  void invalidate() {
-    initializedFlag = false;
-  }
-
   void initializeDiscoveredBlocks(
       SmallVectorImpl<SILBasicBlock *> *discoveredBlocks) {
     assert(!isInitialized() && "cannot reinitialize after blocks are live");
@@ -371,11 +367,6 @@ class PrunedLiveness {
 
   bool empty() const { return users.empty(); }
 
-  void invalidate() {
-    liveBlocks.invalidate();
-    users.clear();
-  }
-
   void initializeDiscoveredBlocks(
       SmallVectorImpl<SILBasicBlock *> *discoveredBlocks) {
     liveBlocks.initializeDiscoveredBlocks(discoveredBlocks);
@@ -639,12 +630,6 @@ class SSAPrunedLiveness : public PrunedLiveRange<SSAPrunedLiveness> {
 
   SILValue getDef() const { return def; }
 
-  void invalidate() {
-    def = SILValue();
-    defInst = nullptr;
-    PrunedLiveRange::invalidate();
-  }
-
   void initializeDef(SILValue def) {
     assert(!this->def && "reinitialization");
 
@@ -710,10 +695,6 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
       : PrunedLiveRange(function, discoveredBlocks), defs(function),
         defBlocks(function) {}
 
-  void invalidate() {
-    PrunedLiveRange::invalidate();
-  }
-
   void initializeDef(SILInstruction *defInst) {
     initializeDefNode(cast<SILNode>(defInst));
   }
@@ -800,12 +781,6 @@ class DiagnosticPrunedLiveness : public SSAPrunedLiveness {
       : SSAPrunedLiveness(function, discoveredBlocks),
         nonLifetimeEndingUsesInLiveOut(nonLifetimeEndingUsesInLiveOut) {}
 
-  void invalidate() {
-    SSAPrunedLiveness::invalidate();
-    if (nonLifetimeEndingUsesInLiveOut)
-      nonLifetimeEndingUsesInLiveOut->clear();
-  }
-
   void updateForUse(SILInstruction *user, bool lifetimeEnding);
 
   using NonLifetimeEndingUsesInLiveOutRange =

include/swift/SIL/SILBitfield.h

@@ -181,13 +181,16 @@ template <typename BitfieldContainer> struct BitfieldRef {
     return ref;
   }
 
+  explicit operator bool() { return ref; }
+
   // Stack-allocated state must be nested relative to other node bitfields.
   struct StackState {
     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;
     }
 

include/swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h

@@ -60,10 +60,13 @@ class CanonicalizeBorrowScope {
   // The borrow that begins this scope.
   BorrowedValue borrowedValue;
 
+  /// The function containing this scope.
+  SILFunction *function;
+
   /// Pruned liveness for the extended live range including copies. For this
   /// purpose, only consuming instructions are considered "lifetime
   /// ending". end_borrows do not end a liverange that may include owned copies.
-  SSAPrunedLiveness liveness;
+  BitfieldRef<SSAPrunedLiveness> liveness;
 
   InstructionDeleter &deleter;
 
@@ -86,11 +89,11 @@ class CanonicalizeBorrowScope {
 
 public:
   CanonicalizeBorrowScope(SILFunction *function, InstructionDeleter &deleter)
-    : liveness(function), deleter(deleter) {}
+      : function(function), deleter(deleter) {}
 
   BorrowedValue getBorrowedValue() const { return borrowedValue; }
 
-  const SSAPrunedLiveness &getLiveness() const { return liveness; }
+  const SSAPrunedLiveness &getLiveness() const { return *liveness; }
 
   InstructionDeleter &getDeleter() { return deleter; }
 
@@ -136,11 +139,13 @@ class CanonicalizeBorrowScope {
 
 protected:
   void initBorrow(BorrowedValue borrow) {
-    assert(borrow && liveness.empty() && persistentCopies.empty());
+    assert(borrow && persistentCopies.empty() &&
+           (!liveness || liveness->empty()));
 
     updatedCopies.clear();
     borrowedValue = borrow;
-    liveness.initializeDef(borrowedValue.value);
+    if (liveness)
+      liveness->initializeDef(borrowedValue.value);
   }
 
   bool computeBorrowLiveness();

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -325,10 +325,9 @@ class CanonicalizeOSSALifetime final {
     liveness->initializeDef(getCurrentDef());
   }
 
-  void invalidateLiveness() {
+  void clear() {
     consumingBlocks.clear();
     debugValues.clear();
-    liveness->invalidate();
     discoveredBlocks.clear();
   }
 

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -115,13 +115,6 @@ class GuaranteedOwnershipExtension {
     : deleter(deleter), deBlocks(deBlocks),
       guaranteedLiveness(function), ownedLifetime(function) {}
 
-  void invalidate() {
-    guaranteedLiveness.invalidate();
-    ownedLifetime.invalidate();
-    ownedConsumeBlocks.clear();
-    beginBorrow = nullptr;
-  }
-
   /// Invalid indicates that the current guaranteed scope is insufficient, and
   /// it does not meet the precondition for scope extension.
   ///

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/Utils/CanonicalizeBorrowScope.cpp

@@ -180,7 +180,7 @@ bool CanonicalizeBorrowScope::computeBorrowLiveness() {
   // the reborrowed value will not be rewritten when canonicalizing the current
   // borrow scope because they are "hidden" behind the reborrow.
   borrowedValue.visitLocalScopeEndingUses([this](Operand *use) {
-    liveness.updateForUse(use->getUser(), /*lifetimeEnding*/ true);
+    liveness->updateForUse(use->getUser(), /*lifetimeEnding*/ true);
     return true;
   });
   return true;
@@ -824,8 +824,6 @@ bool CanonicalizeBorrowScope::canonicalizeFunctionArgument(
 
   LLVM_DEBUG(llvm::dbgs() << "*** Canonicalize Borrow: " << borrowedValue);
 
-  SWIFT_DEFER { liveness.invalidate(); };
-
   RewriteInnerBorrowUses innerRewriter(*this);
   beginVisitBorrowScopeUses(); // reset the def/use worklist
 
@@ -839,12 +837,13 @@ bool CanonicalizeBorrowScope::canonicalizeFunctionArgument(
 /// forwarding operations.
 bool CanonicalizeBorrowScope::
 canonicalizeBorrowScope(BorrowedValue borrowedValue) {
+  BitfieldRef<SSAPrunedLiveness>::StackState livenessBitfieldContainer(
+      liveness, function);
+
   LLVM_DEBUG(llvm::dbgs() << "*** Canonicalize Borrow: " << borrowedValue);
 
   initBorrow(borrowedValue);
 
-  SWIFT_DEFER { liveness.invalidate(); };
-
   if (!computeBorrowLiveness())
     return false;
 

lib/SILOptimizer/Utils/CanonicalizeOSSALifetime.cpp

@@ -1108,7 +1108,7 @@ bool CanonicalizeOSSALifetime::computeLiveness() {
   // Step 1: compute liveness
   if (!computeCanonicalLiveness()) {
     LLVM_DEBUG(llvm::errs() << "Failed to compute canonical liveness?!\n");
-    invalidateLiveness();
+    clear();
     return false;
   }
   if (currentDef->isLexical()) {
@@ -1145,7 +1145,7 @@ void CanonicalizeOSSALifetime::rewriteLifetimes() {
   // Step 6: rewrite copies and delete extra destroys
   rewriteCopies();
 
-  invalidateLiveness();
+  clear();
   consumes.clear();
 }