Remove getSpeculative in favour of getSymbolicMax

david-arm · david-arm · commit 2425c69261b4 · 2024-04-26T11:07:38.000+01:00
* I've rewritten the loop variant of BackedgeTakenInfo::getSymbolicMax
to be more consistent with BackedgeTakenInfo::getExact so that it
now also accepts predicates.
* I've changed getPredicatedBackedgeTakenCount to use getSymbolicMax,
although we still require the latch block to have an exact
exit-not-taken count.
diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h
@@ -893,9 +893,10 @@ class ScalarEvolution {
   /// SCEV predicates to Predicates that are required to be true in order for
   /// the answer to be correct. Predicates can be checked with run-time
   /// checks and can be used to perform loop versioning. If \p Speculative is
-  /// true, this will attempt to return the speculative backedge count for loops
-  /// with early exits. However, this is only possible if we can formulate an
-  /// exact expression for the backedge count from the latch block.
+  /// true, this will attempt to return the speculative - a restricted variant
+  /// of the symbolic maximum - backedge count for loops with early exits.
+  /// However, this is only possible if we can formulate an exact expression for
+  /// the backedge count from the latch block.
   const SCEV *getPredicatedBackedgeTakenCount(
       const Loop *L, SmallVector<const SCEVPredicate *, 4> &Predicates,
       bool Speculative = false);
@@ -1492,10 +1493,6 @@ class ScalarEvolution {
     /// the loop.
     bool IsComplete = false;
 
-    /// Expression indicating the least maximum backedge-taken count of the loop
-    /// that is known, or a SCEVCouldNotCompute. Lazily computed on first query.
-    const SCEV *SymbolicMax = nullptr;
-
     /// True iff the backedge is taken either exactly Max or zero times.
     bool MaxOrZero = false;
 
@@ -1544,16 +1541,6 @@ class ScalarEvolution {
     const SCEV *getExact(const Loop *L, ScalarEvolution *SE,
                          SmallVector<const SCEVPredicate *, 4> *Predicates = nullptr) const;
 
-    /// Similar to the above, except we permit unknown exit counts from
-    /// non-latch exit blocks. Any such early exit blocks must dominate the
-    /// latch and so the returned expression represents the speculative, or
-    /// maximum possible, *backedge-taken* count of the loop. If there is no
-    /// exact exit count for the latch this function returns
-    /// SCEVCouldNotCompute.
-    const SCEV *getSpeculative(
-        const Loop *L, ScalarEvolution *SE,
-        SmallVector<const SCEVPredicate *, 4> *Predicates = nullptr) const;
-
     /// Return the number of times this loop exit may fall through to the back
     /// edge, or SCEVCouldNotCompute. The loop is guaranteed not to exit via
     /// this block before this number of iterations, but may exit via another
@@ -1573,7 +1560,9 @@ class ScalarEvolution {
                                ScalarEvolution *SE) const;
 
     /// Get the symbolic max backedge taken count for the loop.
-    const SCEV *getSymbolicMax(const Loop *L, ScalarEvolution *SE);
+    const SCEV *getSymbolicMax(
+        const Loop *L, ScalarEvolution *SE,
+        SmallVector<const SCEVPredicate *, 4> *Predicates = nullptr) const;
 
     /// Get the symbolic max backedge taken count for the particular loop exit.
     const SCEV *getSymbolicMax(const BasicBlock *ExitingBlock,
@@ -1582,6 +1571,10 @@ class ScalarEvolution {
     /// Return true if the number of times this backedge is taken is either the
     /// value returned by getConstantMax or zero.
     bool isConstantMaxOrZero(ScalarEvolution *SE) const;
+
+    /// Return true if we have an exact exit-not-taken count for the exiting
+    /// block.
+    bool hasExact(const BasicBlock *ExitingBlock, ScalarEvolution *SE) const;
   };
 
   /// Cache the backedge-taken count of the loops for this function as they
@@ -1785,11 +1778,6 @@ class ScalarEvolution {
   ExitLimit computeExitLimit(const Loop *L, BasicBlock *ExitingBlock,
                              bool AllowPredicates = false);
 
-  /// Return a symbolic upper bound for the backedge taken count of the loop.
-  /// This is more general than getConstantMaxBackedgeTakenCount as it returns
-  /// an arbitrary expression as opposed to only constants.
-  const SCEV *computeSymbolicMaxBackedgeTakenCount(const Loop *L);
-
   // Helper functions for computeExitLimitFromCond to avoid exponential time
   // complexity.
 
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -8279,10 +8279,14 @@ const SCEV *ScalarEvolution::getExitCount(const Loop *L,
 const SCEV *ScalarEvolution::getPredicatedBackedgeTakenCount(
     const Loop *L, SmallVector<const SCEVPredicate *, 4> &Preds,
     bool Speculative) {
-  if (Speculative)
-    return getPredicatedBackedgeTakenInfo(L).getSpeculative(L, this, &Preds);
-  else
-    return getPredicatedBackedgeTakenInfo(L).getExact(L, this, &Preds);
+  const BackedgeTakenInfo &BTI = getPredicatedBackedgeTakenInfo(L);
+  if (Speculative) {
+    const BasicBlock *Latch = L->getLoopLatch();
+    if (!Latch || !BTI.hasExact(Latch, this))
+      return getCouldNotCompute();
+    return BTI.getSymbolicMax(L, this, &Preds);
+  } else
+    return BTI.getExact(L, this, &Preds);
 }
 
 const SCEV *ScalarEvolution::getBackedgeTakenCount(const Loop *L,
@@ -8620,45 +8624,6 @@ void ScalarEvolution::BackedgeTakenInfo::getCountableExitingBlocks(
   return;
 }
 
-const SCEV *ScalarEvolution::BackedgeTakenInfo::getSpeculative(
-    const Loop *L, ScalarEvolution *SE,
-    SmallVector<const SCEVPredicate *, 4> *Preds) const {
-  // All exiting blocks we have collected must dominate the only backedge.
-  const BasicBlock *Latch = L->getLoopLatch();
-  if (!Latch || !hasAnyInfo())
-    return SE->getCouldNotCompute();
-
-  // All exiting blocks we have gathered dominate loop's latch, so speculative
-  // trip count is simply a minimum out of all these calculated exit counts.
-  SmallVector<const SCEV *, 2> Ops;
-  bool FoundLatch = false;
-  for (const auto &ENT : ExitNotTaken) {
-    const SCEV *BECount = ENT.ExactNotTaken;
-    if (BECount == SE->getCouldNotCompute())
-      continue;
-
-    assert(SE->DT.dominates(ENT.ExitingBlock, Latch) &&
-           "We should only have known counts for exiting blocks that dominate "
-           "latch!");
-    Ops.push_back(BECount);
-    if (Preds)
-      for (const auto *P : ENT.Predicates)
-        Preds->push_back(P);
-    assert((Preds || ENT.hasAlwaysTruePredicate()) &&
-           "Predicate should be always true!");
-    if (ENT.ExitingBlock == Latch)
-      FoundLatch = true;
-  }
-
-  if (!FoundLatch)
-    return SE->getCouldNotCompute();
-
-  // If an earlier exit exits on the first iteration (exit count zero), then
-  // a later poison exit count should not propagate into the result. This are
-  // exactly the semantics provided by umin_seq.
-  return SE->getUMinFromMismatchedTypes(Ops, /* Sequential */ true);
-}
-
 /// Get the exact not taken count for this loop exit.
 const SCEV *
 ScalarEvolution::BackedgeTakenInfo::getExact(const BasicBlock *ExitingBlock,
@@ -8670,6 +8635,15 @@ ScalarEvolution::BackedgeTakenInfo::getExact(const BasicBlock *ExitingBlock,
   return SE->getCouldNotCompute();
 }
 
+bool ScalarEvolution::BackedgeTakenInfo::hasExact(
+    const BasicBlock *ExitingBlock, ScalarEvolution *SE) const {
+  for (const auto &ENT : ExitNotTaken)
+    if (ENT.ExitingBlock == ExitingBlock)
+      return ENT.ExactNotTaken != SE->getCouldNotCompute();
+
+  return false;
+}
+
 const SCEV *ScalarEvolution::BackedgeTakenInfo::getConstantMax(
     const BasicBlock *ExitingBlock, ScalarEvolution *SE) const {
   for (const auto &ENT : ExitNotTaken)
@@ -8704,12 +8678,41 @@ ScalarEvolution::BackedgeTakenInfo::getConstantMax(ScalarEvolution *SE) const {
   return getConstantMax();
 }
 
-const SCEV *
-ScalarEvolution::BackedgeTakenInfo::getSymbolicMax(const Loop *L,
-                                                   ScalarEvolution *SE) {
-  if (!SymbolicMax)
-    SymbolicMax = SE->computeSymbolicMaxBackedgeTakenCount(L);
-  return SymbolicMax;
+const SCEV *ScalarEvolution::BackedgeTakenInfo::getSymbolicMax(
+    const Loop *L, ScalarEvolution *SE,
+    SmallVector<const SCEVPredicate *, 4> *Preds) const {
+  // If any exits were not computable, the loop is not computable.
+  if (ExitNotTaken.empty())
+    return SE->getCouldNotCompute();
+
+  const BasicBlock *Latch = L->getLoopLatch();
+  // All exiting blocks we have collected must dominate the only backedge.
+  if (!Latch)
+    return SE->getCouldNotCompute();
+
+  // Form an expression for the maximum exit count possible for this loop. We
+  // merge the max and exact information to approximate a version of
+  // getConstantMaxBackedgeTakenCount which isn't restricted to just constants.
+  SmallVector<const SCEV *, 4> ExitCounts;
+  for (const auto &ENT : ExitNotTaken) {
+    const SCEV *ExitCount = ENT.SymbolicMaxNotTaken;
+    if (ExitCount == SE->getCouldNotCompute())
+      continue;
+
+    assert(SE->DT.dominates(ENT.ExitingBlock, Latch) &&
+           "We should only have known counts for exiting blocks that dominate "
+           "the latch!");
+    ExitCounts.push_back(ExitCount);
+    if (Preds)
+      for (const auto *P : ENT.Predicates)
+        Preds->push_back(P);
+    assert((Preds || ENT.hasAlwaysTruePredicate()) &&
+           "Predicate should be always true!");
+  }
+
+  if (ExitCounts.empty())
+    return SE->getCouldNotCompute();
+  return SE->getUMinFromMismatchedTypes(ExitCounts, /*Sequential*/ true);
 }
 
 bool ScalarEvolution::BackedgeTakenInfo::isConstantMaxOrZero(
@@ -15024,30 +15027,6 @@ bool ScalarEvolution::matchURem(const SCEV *Expr, const SCEV *&LHS,
   return false;
 }
 
-const SCEV *
-ScalarEvolution::computeSymbolicMaxBackedgeTakenCount(const Loop *L) {
-  SmallVector<BasicBlock*, 16> ExitingBlocks;
-  L->getExitingBlocks(ExitingBlocks);
-
-  // Form an expression for the maximum exit count possible for this loop. We
-  // merge the max and exact information to approximate a version of
-  // getConstantMaxBackedgeTakenCount which isn't restricted to just constants.
-  SmallVector<const SCEV*, 4> ExitCounts;
-  for (BasicBlock *ExitingBB : ExitingBlocks) {
-    const SCEV *ExitCount =
-        getExitCount(L, ExitingBB, ScalarEvolution::SymbolicMaximum);
-    if (!isa<SCEVCouldNotCompute>(ExitCount)) {
-      assert(DT.dominates(ExitingBB, L->getLoopLatch()) &&
-             "We should only have known counts for exiting blocks that "
-             "dominate latch!");
-      ExitCounts.push_back(ExitCount);
-    }
-  }
-  if (ExitCounts.empty())
-    return getCouldNotCompute();
-  return getUMinFromMismatchedTypes(ExitCounts, /*Sequential*/ true);
-}
-
 /// A rewriter to replace SCEV expressions in Map with the corresponding entry
 /// in the map. It skips AddRecExpr because we cannot guarantee that the
 /// replacement is loop invariant in the loop of the AddRec.
