Merge pull request #68756 from nate-chandler/nfc/20230925/1/distinguish-non-users

[PrunedLiveness] Add extendToNonUse.

Author: nate-chandler

include/swift/SIL/FieldSensitivePrunedLiveness.h

@@ -375,9 +375,12 @@ struct TypeTreeLeafTypeRange {
 
   /// Sets each bit in \p bits corresponding to an element of this range.
   void setBits(SmallBitVector &bits) const {
-    for (auto element : getRange()) {
-      bits.set(element);
-    }
+    bits.set(startEltOffset, endEltOffset);
+  }
+
+  /// Resets each bit in \p bits corresponding to an element of this range.
+  void resetBits(SmallBitVector &bits) const {
+    bits.reset(startEltOffset, endEltOffset);
   }
 
   IntRange<unsigned> getRange() const {
@@ -694,6 +697,15 @@ class FieldSensitivePrunedLiveness {
   enum IsInterestingUser { NonUser, NonLifetimeEndingUse, LifetimeEndingUse };
 
   struct InterestingUser {
+    // Together these bit vectors encode four states per field:
+    //   +---------------+----------------+---------------+
+    // - | liveBits[bit] | consumingBits] |     state     |
+    //   +---------------+----------------+---------------+
+    //   |      0        |        0       | dead          |
+    //   |      0        |        1       | non-use       |
+    //   |      1        |        0       | non-consuming |
+    //   |      1        |        1       | consuming     |
+    //   +---------------+----------------+---------------+
     SmallBitVector liveBits;
     SmallBitVector consumingBits;
 
@@ -708,18 +720,33 @@ class FieldSensitivePrunedLiveness {
 
     /// Record that the instruction uses the bits of the value in \p range.
     void addUses(TypeTreeLeafTypeRange range, bool lifetimeEnding) {
-      range.setBits(liveBits);
-      if (lifetimeEnding) {
-        range.setBits(consumingBits);
-      }
+      SmallBitVector bits(liveBits.size());
+      range.setBits(bits);
+      addUses(bits, lifetimeEnding);
     }
 
     /// Record that the instruction uses the bits in \p bits.
     void addUses(SmallBitVector const &bits, bool lifetimeEnding) {
-      liveBits |= bits;
       if (lifetimeEnding) {
-        consumingBits |= bits;
+        consumingBits |= bits & ~liveBits;
+      } else {
+        consumingBits &= ~bits;
       }
+      liveBits |= bits;
+    }
+
+    /// Extend liveness at the bits in the specified  \p range without
+    /// overriding whether the lifetimes of those bits end.
+    void extendToNonUse(TypeTreeLeafTypeRange range) {
+      SmallBitVector bits(liveBits.size());
+      range.setBits(bits);
+      extendToNonUse(bits);
+    }
+
+    /// Extend liveness at the specified \p bits without overriding whether the
+    /// lifetimes of those bits end.
+    void extendToNonUse(SmallBitVector const &bits) {
+      consumingBits |= bits & ~liveBits;
     }
 
     /// Populates the provided vector with contiguous ranges of bits which are
@@ -755,10 +782,18 @@ class FieldSensitivePrunedLiveness {
     }
 
     IsInterestingUser isInterestingUser(unsigned element) const {
-      if (!liveBits.test(element))
+      auto isLive = liveBits.test(element);
+      auto isConsuming = consumingBits.test(element);
+      if (!isLive && !isConsuming) {
         return NonUser;
-      return consumingBits.test(element) ? LifetimeEndingUse
-                                         : NonLifetimeEndingUse;
+      } else if (!isLive && isConsuming) {
+        return NonLifetimeEndingUse;
+      } else if (isLive && isConsuming) {
+        return LifetimeEndingUse;
+      } else if (isLive && !isConsuming) {
+        return NonLifetimeEndingUse;
+      }
+      llvm_unreachable("covered conditions");
     }
   };
 
@@ -875,6 +910,16 @@ class FieldSensitivePrunedLiveness {
                     bool lifetimeEnding,
                     SmallBitVector const &useBeforeDefBits);
 
+  /// Adds \p user which doesn't use the def to liveness.
+  ///
+  /// Different from calling updateForUse because it never overrides the value
+  /// \p lifetimeEnding stored for \p inst.
+  void extendToNonUse(SILInstruction *user, TypeTreeLeafTypeRange span,
+                      SmallBitVector const &useBeforeDefBits);
+
+  void extendToNonUse(SILInstruction *user, SmallBitVector const &bits,
+                      SmallBitVector const &useBeforeDefBits);
+
   void getBlockLiveness(SILBasicBlock *bb, TypeTreeLeafTypeRange span,
                         SmallVectorImpl<FieldSensitivePrunedLiveBlocks::IsLive>
                             &resultingFoundLiveness) const {
@@ -943,7 +988,7 @@ class FieldSensitivePrunedLiveness {
 
   unsigned getNumSubElements() const { return liveBlocks.getNumBitsToTrack(); }
 
-  void print(llvm::raw_ostream &os) const { liveBlocks.print(os); }
+  void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 
 protected:
@@ -971,6 +1016,14 @@ class FieldSensitivePrunedLiveness {
                           bool lifetimeEnding) {
     getOrCreateInterestingUser(user).addUses(bits, lifetimeEnding);
   }
+
+  void extendToNonUse(SILInstruction *user, TypeTreeLeafTypeRange range) {
+    getOrCreateInterestingUser(user).extendToNonUse(range);
+  }
+
+  void extendToNonUse(SILInstruction *user, SmallBitVector const &bits) {
+    getOrCreateInterestingUser(user).extendToNonUse(bits);
+  }
 };
 
 /// Record the last use points and CFG edges that form the boundary of
@@ -1089,6 +1142,14 @@ class FieldSensitivePrunedLiveRange : public FieldSensitivePrunedLiveness {
   void updateForUse(SILInstruction *user, SmallBitVector const &bits,
                     bool lifetimeEnding);
 
+  /// Customize extendToNonUse for FieldSensitivePrunedLiveness to consider
+  /// defs as kills.
+  void extendToNonUse(SILInstruction *user, TypeTreeLeafTypeRange span);
+
+  /// Customize extendToNonUse for FieldSensitivePrunedLiveness to consider
+  /// defs as kills.
+  void extendToNonUse(SILInstruction *user, SmallBitVector const &bits);
+
   /// Compute the boundary from the blocks discovered during liveness analysis.
   ///
   /// Precondition: \p liveness.getDiscoveredBlocks() is a valid list of all

include/swift/SIL/PrunedLiveness.h

@@ -353,6 +353,61 @@ struct LiveRangeSummary {
 /// necessarily include liveness up to destroy_value or end_borrow
 /// instructions.
 class PrunedLiveness {
+public:
+  /// A tristate describing how an instruction uses the value:
+  /// - non-ending: the value's lifetime does not end at the instruction;
+  ///               results from updateForUse(, lifetimeEnding: false)
+  /// - ending: the value's lifetime ends at the instruction; results from
+  ///           updateForUse(, lifetimeEnding: true)
+  /// - non-use: the instruction doesn't use the value but liveness was extended
+  ///            to it; results from extendToNonUse
+  ///
+  /// If an instruction is added to liveness with multiple LifetimeEnding
+  /// instances, the stored instance needs to be updated appropriately, taking
+  /// into account the instances that were already seen.
+  ///
+  /// For example, if Nonuse is seen after Ending, it is ignored: that the
+  /// instruction ends the lifetime takes priority: the instruction doesn't end
+  /// the lifetime of the value any less because liveness was extended to it.
+  ///
+  /// Similarly, if Ending is seen after NonEnding, it is ignored: that the
+  /// instruction ends the lifetime of a copy of the value can't change the fact
+  /// that liveness already extends _beyond_ the instruction because it was
+  /// already recognized as a non-ending use.
+  ///
+  /// This relationship of "overriding" is captured by the order of the cases in
+  /// LifetimeEnding::Value and which case overrides another is computed by
+  /// taking the meet--i.e. the lesser of the two cases overrides.
+  ///
+  /// Note: Taking the meet may not be appropriate for branch instructions
+  ///       which may need to be recognized as lifetime-ending when they have
+  ///       as uses both a reborrow and a guaranteed phi.
+  struct LifetimeEnding {
+    enum class Value {
+      // The instruction doesn't consume the value.
+      NonEnding,
+      // The instruction consumes the value.
+      Ending,
+      // The instruction doesn't use the value.
+      NonUse,
+    };
+    Value value;
+
+    LifetimeEnding(Value value) : value(value) {}
+    explicit LifetimeEnding(bool lifetimeEnding)
+        : value(lifetimeEnding ? Value::Ending : Value::NonEnding) {}
+    operator Value() const { return value; }
+    LifetimeEnding meet(LifetimeEnding const other) const {
+      return value < other.value ? *this : other;
+    }
+    void meetInPlace(LifetimeEnding const other) { *this = meet(other); }
+    bool isEnding() const { return value == Value::Ending; }
+
+    static LifetimeEnding NonUse() { return {Value::NonUse}; };
+    static LifetimeEnding Ending() { return {Value::Ending}; };
+    static LifetimeEnding NonEnding() { return {Value::NonEnding}; };
+  };
+
 protected:
   PrunedLiveBlocks liveBlocks;
 
@@ -365,7 +420,7 @@ class PrunedLiveness {
   // they may be the last use in the block.
   //
   // Non-lifetime-ending within a LiveOut block are uninteresting.
-  llvm::SmallMapVector<SILInstruction *, bool, 8> users;
+  llvm::SmallMapVector<SILInstruction *, LifetimeEnding, 8> users;
 
 public:
   PrunedLiveness(SILFunction *function,
@@ -411,11 +466,12 @@ class PrunedLiveness {
     auto useIter = users.find(user);
     if (useIter == users.end())
       return NonUser;
-    return useIter->second ? LifetimeEndingUse : NonLifetimeEndingUse;
+    return useIter->second == LifetimeEnding::Ending() ? LifetimeEndingUse
+                                                       : NonLifetimeEndingUse;
   }
 
   using ConstUserRange =
-      iterator_range<const std::pair<SILInstruction *, bool> *>;
+      iterator_range<const std::pair<SILInstruction *, LifetimeEnding> *>;
   ConstUserRange getAllUsers() const {
     return llvm::make_range(users.begin(), users.end());
   }
@@ -425,49 +481,53 @@ class PrunedLiveness {
   /// IDE.
   struct RangeIterationHelpers {
     struct MapFunctor {
-      SILInstruction *
-      operator()(const std::pair<SILInstruction *, bool> &pair) const {
+      SILInstruction *operator()(
+          const std::pair<SILInstruction *, LifetimeEnding> &pair) const {
         // Strip off the const to ease use with other APIs.
         return const_cast<SILInstruction *>(pair.first);
       }
     };
 
-    struct LifetimeEnding {
+    struct IsLifetimeEnding {
       struct FilterFunctor {
-        bool operator()(const std::pair<SILInstruction *, bool> &pair) const {
-          return pair.second;
+        bool operator()(
+            const std::pair<SILInstruction *, LifetimeEnding> &pair) const {
+          return pair.second.isEnding();
         }
       };
 
       using MapFilterIter = llvm::mapped_iterator<
-          llvm::filter_iterator<const std::pair<SILInstruction *, bool> *,
-                                FilterFunctor>,
+          llvm::filter_iterator<
+              const std::pair<SILInstruction *, LifetimeEnding> *,
+              FilterFunctor>,
           MapFunctor>;
     };
 
     struct NonLifetimeEnding {
       struct FilterFunctor {
-        bool operator()(const std::pair<SILInstruction *, bool> &pair) const {
-          return !pair.second;
+        bool operator()(
+            const std::pair<SILInstruction *, LifetimeEnding> &pair) const {
+          return !pair.second.isEnding();
         }
       };
 
       using MapFilterIter = llvm::mapped_iterator<
-          llvm::filter_iterator<const std::pair<SILInstruction *, bool> *,
-                                FilterFunctor>,
+          llvm::filter_iterator<
+              const std::pair<SILInstruction *, LifetimeEnding> *,
+              FilterFunctor>,
           MapFunctor>;
     };
   };
   using LifetimeEndingUserRange = llvm::iterator_range<
-      RangeIterationHelpers::LifetimeEnding::MapFilterIter>;
+      RangeIterationHelpers::IsLifetimeEnding::MapFilterIter>;
 
   /// Return a range consisting of the current set of consuming users fed into
   /// this PrunedLiveness instance.
   LifetimeEndingUserRange getLifetimeEndingUsers() const {
     return map_range(
         llvm::make_filter_range(
             getAllUsers(),
-            RangeIterationHelpers::LifetimeEnding::FilterFunctor()),
+            RangeIterationHelpers::IsLifetimeEnding::FilterFunctor()),
         RangeIterationHelpers::MapFunctor());
   }
 
@@ -552,6 +612,8 @@ class PrunedLiveRange : public PrunedLiveness {
                                            ValueSet &visited,
                                            SILValue value);
 
+  void updateForUse(SILInstruction *user, LifetimeEnding lifetimeEnding);
+
 public:
   /// For flexibility, \p lifetimeEnding is provided by the
   /// caller. PrunedLiveness makes no assumptions about the def-use
@@ -560,6 +622,12 @@ class PrunedLiveRange : public PrunedLiveness {
   /// live range vs. a nested borrow scope within the extended live range.
   void updateForUse(SILInstruction *user, bool lifetimeEnding);
 
+  /// Adds \p inst which doesn't use the def to liveness.
+  ///
+  /// Different from calling updateForUse because it never overrides the value
+  /// \p lifetimeEnding stored for \p inst.
+  void extendToNonUse(SILInstruction *inst);
+
   /// 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.

include/swift/SIL/SILBasicBlock.h

@@ -742,6 +742,29 @@ inline SILFunction *SILInstruction::getFunction() const {
   return getParent()->getParent();
 }
 
+inline bool SILInstruction::visitPriorInstructions(
+    llvm::function_ref<bool(SILInstruction *)> visitor) {
+  if (auto *previous = getPreviousInstruction()) {
+    return visitor(previous);
+  }
+  for (auto *predecessor : getParent()->getPredecessorBlocks()) {
+    if (!visitor(&predecessor->back()))
+      return false;
+  }
+  return true;
+}
+inline bool SILInstruction::visitSubsequentInstructions(
+    llvm::function_ref<bool(SILInstruction *)> visitor) {
+  if (auto *next = getNextInstruction()) {
+    return visitor(next);
+  }
+  for (auto *successor : getParent()->getSuccessorBlocks()) {
+    if (!visitor(&successor->front()))
+      return false;
+  }
+  return true;
+}
+
 inline SILInstruction *SILInstruction::getPreviousInstruction() {
   auto pos = getIterator();
   return pos == getParent()->begin() ? nullptr : &*std::prev(pos);

include/swift/SIL/SILInstruction.h

@@ -517,6 +517,24 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// instruction in its block.
   SILInstruction *getNextInstruction();
 
+  /// Calls \p visitor with each instruction that is immediately prior.  Returns
+  /// false and stops visiting if \p visitor returns false.
+  ///
+  /// If \p this is is the first instruction in a block, then \p visitor is
+  /// called with the back of each predecessor.  In particular if \p this is
+  /// the first instruction of the entry block, \p visitor is never called.
+  bool
+  visitPriorInstructions(llvm::function_ref<bool(SILInstruction *)> visitor);
+
+  /// Calls \p visitor with each instruction that is immediately subsequent.
+  /// Returns false and stops visiting if \p visitor returns false.
+  ///
+  /// If \p this is the last instruction in a block, then \p visitor is called
+  /// with the front of each successor.  In particular if \p this is the last
+  /// instruction of a block without successors, \p visitor is never called.
+  bool visitSubsequentInstructions(
+      llvm::function_ref<bool(SILInstruction *)> visitor);
+
   /// This method unlinks 'self' from the containing basic block and deletes it.
   void eraseFromParent();