[NFC] Move the updateForUse API into PrunedliveRange

PrunedLiveness only knows about the live blocks and uses.

The PrunedLiveRange subclass is now responsible for updating liveness
based on both the defs and uses. This is in preparation for handling
non-SSA liveness when uses occur before the first def.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -225,6 +225,11 @@ class PrunedLiveBlocks {
   }
 
   /// Update this liveness result for a single use.
+  ///
+  /// Note: this never propagates liveness upward beyond def blocks.
+  /// PrunedLiveRange knows about defs and whether it is possible for a
+  /// block to contain a use before the first def. It must check that case
+  /// separately and propagate liveness to predecessors.
   IsLive updateForUse(SILInstruction *user) {
     assert(isInitialized() && "at least one definition must be initialized");
 
@@ -344,6 +349,7 @@ struct LiveRangeSummary {
 /// necessarily include liveness up to destroy_value or end_borrow
 /// instructions.
 class PrunedLiveness {
+protected:
   PrunedLiveBlocks liveBlocks;
 
   // Map all "interesting" user instructions in this def's live range to a flag
@@ -386,27 +392,6 @@ class PrunedLiveness {
     liveBlocks.initializeDefBlock(defBB);
   }
 
-  /// For flexibility, \p lifetimeEnding is provided by the
-  /// caller. PrunedLiveness makes no assumptions about the def-use
-  /// relationships that generate liveness. For example, use->isLifetimeEnding()
-  /// cannot distinguish the end of the borrow scope that defines this extended
-  /// live range vs. a nested borrow scope within the extended live range.
-  void updateForUse(SILInstruction *user, bool lifetimeEnding);
-
-  /// Updates the liveness for a whole borrow scope, beginning at \p op.
-  /// Returns false if this cannot be done. This assumes that nested OSSA
-  /// lifetimes are complete.
-  InnerBorrowKind updateForBorrowingOperand(Operand *operand);
-
-  /// Update liveness for an interior pointer use. These are normally handled
-  /// like an instantaneous use. But if \p operand "borrows" a value for the
-  /// duration of a scoped address (store_borrow), then update liveness for the
-  /// entire scope. This assumes that nested OSSA lifetimes are complete.
-  AddressUseKind checkAndUpdateInteriorPointer(Operand *operand);
-
-  /// Update this liveness to extend across the given liveness.
-  void extendAcrossLiveness(PrunedLiveness &otherLiveness);
-
   PrunedLiveBlocks::IsLive getBlockLiveness(SILBasicBlock *bb) const {
     return liveBlocks.getBlockLiveness(bb);
   }
@@ -561,6 +546,27 @@ class PrunedLiveRange : public PrunedLiveness {
                                            SILValue value);
 
 public:
+  /// For flexibility, \p lifetimeEnding is provided by the
+  /// caller. PrunedLiveness makes no assumptions about the def-use
+  /// relationships that generate liveness. For example, use->isLifetimeEnding()
+  /// cannot distinguish the end of the borrow scope that defines this extended
+  /// live range vs. a nested borrow scope within the extended live range.
+  void updateForUse(SILInstruction *user, bool lifetimeEnding);
+
+  /// Updates the liveness for a whole borrow scope, beginning at \p op.
+  /// Returns false if this cannot be done. This assumes that nested OSSA
+  /// lifetimes are complete.
+  InnerBorrowKind updateForBorrowingOperand(Operand *operand);
+
+  /// Update liveness for an interior pointer use. These are normally handled
+  /// like an instantaneous use. But if \p operand "borrows" a value for the
+  /// duration of a scoped address (store_borrow), then update liveness for the
+  /// entire scope. This assumes that nested OSSA lifetimes are complete.
+  AddressUseKind checkAndUpdateInteriorPointer(Operand *operand);
+
+  /// Update this liveness to extend across the given liveness.
+  void extendAcrossLiveness(PrunedLiveness &otherLiveness);
+
   /// Update liveness for all direct uses of \p def. Transitively follows
   /// guaranteed forwards up to but not including guaranteed phis. If \p def is
   /// used by a guaranteed phi return InnerBorrowKind::Reborrowed.

include/swift/SIL/ScopedAddressUtils.h

@@ -119,7 +119,7 @@ struct ScopedAddressValue {
   ///
   /// Valid for any type of liveness, SSA or MultiDef, that may be used by a
   /// scoped address.
-  AddressUseKind updateTransitiveLiveness(PrunedLiveness &liveness) const;
+  AddressUseKind updateTransitiveLiveness(SSAPrunedLiveness &liveness) const;
 
   /// Create appropriate scope ending instruction at \p insertPt.
   void createScopeEnd(SILBasicBlock::iterator insertPt, SILLocation loc) const;

lib/SIL/Utils/PrunedLiveness.cpp

@@ -51,79 +51,9 @@ void PrunedLiveBlocks::computeUseBlockLiveness(SILBasicBlock *userBB) {
 }
 
 //===----------------------------------------------------------------------===//
-//                            MARK: PrunedLiveness
+//                    PrunedLiveBlocks and PrunedLiveness
 //===----------------------------------------------------------------------===//
 
-void PrunedLiveness::updateForUse(SILInstruction *user, bool lifetimeEnding) {
-  liveBlocks.updateForUse(user);
-
-  // Note that a user may use the current value from multiple operands. If any
-  // of the uses are non-lifetime-ending, then we must consider the user
-  // itself non-lifetime-ending; it cannot be a final destroy point because
-  // the value of the non-lifetime-ending operand must be kept alive until the
-  // end of the user. Consider a call that takes the same value using
-  // different conventions:
-  //
-  //   apply %f(%val, %val) : $(@guaranteed, @owned) -> ()
-  //
-  // This call is not considered the end of %val's lifetime. The @owned
-  // argument must be copied.
-  auto iterAndSuccess = users.insert({user, lifetimeEnding});
-  if (!iterAndSuccess.second)
-    iterAndSuccess.first->second &= lifetimeEnding;
-}
-
-InnerBorrowKind PrunedLiveness::updateForBorrowingOperand(Operand *operand) {
-  assert(operand->getOperandOwnership() == OperandOwnership::Borrow);
-
-  // A nested borrow scope is considered a use-point at each scope ending
-  // instruction.
-  //
-  // Note: Ownership liveness should follow reborrows that are dominated by the
-  // ownership definition.
-  if (!BorrowingOperand(operand).visitScopeEndingUses([this](Operand *end) {
-        if (end->getOperandOwnership() == OperandOwnership::Reborrow) {
-          return false;
-        }
-        updateForUse(end->getUser(), /*lifetimeEnding*/ false);
-        return true;
-      })) {
-    return InnerBorrowKind::Reborrowed;
-  }
-  return InnerBorrowKind::Contained;
-}
-
-AddressUseKind PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
-  assert(operand->getOperandOwnership() == OperandOwnership::InteriorPointer);
-
-  if (auto scopedAddress = ScopedAddressValue::forUse(operand)) {
-    scopedAddress.visitScopeEndingUses([this](Operand *end) {
-      updateForUse(end->getUser(), /*lifetimeEnding*/ false);
-      return true;
-    });
-    return AddressUseKind::NonEscaping;
-  }
-  // FIXME: findTransitiveUses should be a visitor so we're not recursively
-  // allocating use vectors and potentially merging the use points.
-  SmallVector<Operand *, 8> uses;
-  auto useKind = InteriorPointerOperand(operand).findTransitiveUses(&uses);
-  for (auto *use : uses) {
-    updateForUse(use->getUser(), /*lifetimeEnding*/ false);
-  }
-  if (uses.empty()) {
-    // Handle a dead address
-    updateForUse(operand->getUser(), /*lifetimeEnding*/ false);
-  }
-  return useKind;
-}
-
-void PrunedLiveness::extendAcrossLiveness(PrunedLiveness &otherLivesness) {
-  // update this liveness for all the interesting users in otherLiveness.
-  for (std::pair<SILInstruction *, bool> userAndEnd : otherLivesness.users) {
-    updateForUse(userAndEnd.first, userAndEnd.second);
-  }
-}
-
 llvm::StringRef PrunedLiveBlocks::getStringRef(IsLive isLive) const {
   switch (isLive) {
   case Dead:
@@ -235,6 +165,85 @@ void PrunedLivenessBoundary::visitInsertionPoints(
 //                              PrunedLiveRange
 //===----------------------------------------------------------------------===//
 
+template <typename LivenessWithDefs>
+void PrunedLiveRange<LivenessWithDefs>::updateForUse(SILInstruction *user,
+                                                     bool lifetimeEnding) {
+  liveBlocks.updateForUse(user);
+
+  // Note that a user may use the current value from multiple operands. If any
+  // of the uses are non-lifetime-ending, then we must consider the user
+  // itself non-lifetime-ending; it cannot be a final destroy point because
+  // the value of the non-lifetime-ending operand must be kept alive until the
+  // end of the user. Consider a call that takes the same value using
+  // different conventions:
+  //
+  //   apply %f(%val, %val) : $(@guaranteed, @owned) -> ()
+  //
+  // This call is not considered the end of %val's lifetime. The @owned
+  // argument must be copied.
+  auto iterAndSuccess = users.insert({user, lifetimeEnding});
+  if (!iterAndSuccess.second)
+    iterAndSuccess.first->second &= lifetimeEnding;
+}
+
+template <typename LivenessWithDefs>
+InnerBorrowKind
+PrunedLiveRange<LivenessWithDefs>::updateForBorrowingOperand(Operand *operand) {
+  assert(operand->getOperandOwnership() == OperandOwnership::Borrow);
+
+  // A nested borrow scope is considered a use-point at each scope ending
+  // instruction.
+  //
+  // Note: Ownership liveness should follow reborrows that are dominated by the
+  // ownership definition.
+  if (!BorrowingOperand(operand).visitScopeEndingUses([this](Operand *end) {
+        if (end->getOperandOwnership() == OperandOwnership::Reborrow) {
+          return false;
+        }
+        updateForUse(end->getUser(), /*lifetimeEnding*/ false);
+        return true;
+      })) {
+    return InnerBorrowKind::Reborrowed;
+  }
+  return InnerBorrowKind::Contained;
+}
+
+template <typename LivenessWithDefs>
+AddressUseKind PrunedLiveRange<LivenessWithDefs>::checkAndUpdateInteriorPointer(
+    Operand *operand) {
+  assert(operand->getOperandOwnership() == OperandOwnership::InteriorPointer);
+
+  if (auto scopedAddress = ScopedAddressValue::forUse(operand)) {
+    scopedAddress.visitScopeEndingUses([this](Operand *end) {
+      updateForUse(end->getUser(), /*lifetimeEnding*/ false);
+      return true;
+    });
+    return AddressUseKind::NonEscaping;
+  }
+  // FIXME: findTransitiveUses should be a visitor so we're not recursively
+  // allocating use vectors and potentially merging the use points.
+  SmallVector<Operand *, 8> uses;
+  auto useKind = InteriorPointerOperand(operand).findTransitiveUses(&uses);
+  for (auto *use : uses) {
+    updateForUse(use->getUser(), /*lifetimeEnding*/ false);
+  }
+  if (uses.empty()) {
+    // Handle a dead address
+    updateForUse(operand->getUser(), /*lifetimeEnding*/ false);
+  }
+  return useKind;
+}
+
+template <typename LivenessWithDefs>
+void PrunedLiveRange<LivenessWithDefs>::extendAcrossLiveness(
+    PrunedLiveness &otherLiveness) {
+  // update this liveness for all the interesting users in otherLiveness.
+  for (std::pair<SILInstruction *, bool> userAndEnd :
+       otherLiveness.getAllUsers()) {
+    updateForUse(userAndEnd.first, userAndEnd.second);
+  }
+}
+
 template <typename LivenessWithDefs>
 LiveRangeSummary PrunedLiveRange<LivenessWithDefs>::updateForDef(SILValue def) {
   ValueSet visited(def->getFunction());
@@ -606,7 +615,7 @@ LiveRangeSummary MultiDefPrunedLiveness::computeSimple() {
 // liveness, clients should check uses that are in PrunedLivenessBoundary.
 void DiagnosticPrunedLiveness::
 updateForUse(SILInstruction *user, bool lifetimeEnding) {
-  PrunedLiveness::updateForUse(user, 0);
+  SSAPrunedLiveness::updateForUse(user, 0);
 
   auto useBlockLive = getBlockLiveness(user->getParent());
   // Record all uses of blocks on the liveness boundary. For blocks marked

lib/SIL/Utils/ScopedAddressUtils.cpp

@@ -105,8 +105,8 @@ AddressUseKind ScopedAddressValue::computeTransitiveLiveness(
   return updateTransitiveLiveness(liveness);
 }
 
-AddressUseKind
-ScopedAddressValue::updateTransitiveLiveness(PrunedLiveness &liveness) const {
+AddressUseKind ScopedAddressValue::updateTransitiveLiveness(
+    SSAPrunedLiveness &liveness) const {
   SmallVector<Operand *, 4> uses;
   // Collect all uses that need to be enclosed by the scope.
   auto addressKind = findTransitiveUsesForAddress(value, &uses);