[llvm] e5fa7eb - [SCEV] Add printout of symbolic max backedge-taken and block exit count
Max Kazantsev via llvm-commits
llvm-commits at lists.llvm.org
Thu Nov 24 04:30:37 PST 2022
Author: Max Kazantsev
Date: 2022-11-24T19:29:58+07:00
New Revision: e5fa7eb120319559564332f91859e8dcedb0f6f9
URL: https://github.com/llvm/llvm-project/commit/e5fa7eb120319559564332f91859e8dcedb0f6f9
DIFF: https://github.com/llvm/llvm-project/commit/e5fa7eb120319559564332f91859e8dcedb0f6f9.diff
LOG: [SCEV] Add printout of symbolic max backedge-taken and block exit count
We do compute it and use in optimizations, but never print it out. We need
to do it in order to be able to track improvements in its computation.
Added:
Modified:
llvm/lib/Analysis/ScalarEvolution.cpp
llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll
llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
llvm/test/Analysis/ScalarEvolution/cycled_phis.ll
llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll
llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
llvm/test/Analysis/ScalarEvolution/exit-count-select.ll
llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll
llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll
llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll
llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll
llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
llvm/test/Analysis/ScalarEvolution/load.ll
llvm/test/Analysis/ScalarEvolution/logical-operations.ll
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll
llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll
llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll
llvm/test/Analysis/ScalarEvolution/ne-overflow.ll
llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll
llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
llvm/test/Analysis/ScalarEvolution/nsw-offset.ll
llvm/test/Analysis/ScalarEvolution/nsw.ll
llvm/test/Analysis/ScalarEvolution/outer_phi.ll
llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll
llvm/test/Analysis/ScalarEvolution/pr48225.ll
llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll
llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll
llvm/test/Analysis/ScalarEvolution/ranges.ll
llvm/test/Analysis/ScalarEvolution/sdiv.ll
llvm/test/Analysis/ScalarEvolution/sext-mul.ll
llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll
llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll
llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll
llvm/test/Analysis/ScalarEvolution/srem.ll
llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll
llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll
llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll
llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll
llvm/test/Analysis/ScalarEvolution/trip-count.ll
llvm/test/Analysis/ScalarEvolution/trip-count10.ll
llvm/test/Analysis/ScalarEvolution/trip-count14.ll
llvm/test/Analysis/ScalarEvolution/trip-count15.ll
llvm/test/Analysis/ScalarEvolution/trip-count2.ll
llvm/test/Analysis/ScalarEvolution/trip-count3.ll
llvm/test/Analysis/ScalarEvolution/trip-count4.ll
llvm/test/Analysis/ScalarEvolution/trip-count6.ll
llvm/test/Analysis/ScalarEvolution/trip-count7.ll
llvm/test/Analysis/ScalarEvolution/trip-count8.ll
llvm/test/Analysis/ScalarEvolution/trip-count9.ll
llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll
llvm/test/Analysis/ScalarEvolution/unknown_phis.ll
llvm/test/Analysis/ScalarEvolution/widenable-condition.ll
llvm/test/Transforms/LoopDeletion/invalidate-scev-after-hoisting.ll
Removed:
################################################################################
diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp
index 7a7f85af3824..e6bfdf80450c 100644
--- a/llvm/lib/Analysis/ScalarEvolution.cpp
+++ b/llvm/lib/Analysis/ScalarEvolution.cpp
@@ -13382,6 +13382,27 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
+ auto *SymbolicBTC = SE->getSymbolicMaxBackedgeTakenCount(L);
+ if (!isa<SCEVCouldNotCompute>(SymbolicBTC)) {
+ OS << "symbolic max backedge-taken count is " << *SymbolicBTC;
+ if (SE->isBackedgeTakenCountMaxOrZero(L))
+ OS << ", actual taken count either this or zero.";
+ } else {
+ OS << "Unpredictable symbolic max backedge-taken count. ";
+ }
+
+ if (ExitingBlocks.size() > 1)
+ for (BasicBlock *ExitingBlock : ExitingBlocks) {
+ OS << " symbolic max exit count for " << ExitingBlock->getName() << ": "
+ << *SE->getExitCount(L, ExitingBlock, ScalarEvolution::SymbolicMaximum)
+ << "\n";
+ }
+
+ OS << "\n"
+ "Loop ";
+ L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
+ OS << ": ";
+
SmallVector<const SCEVPredicate *, 4> Preds;
auto PBT = SE->getPredicatedBackedgeTakenCount(L, Preds);
if (!isa<SCEVCouldNotCompute>(PBT)) {
diff --git a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
index 88beac3c7738..3a9bf8298b9b 100644
--- a/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
+++ b/llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
@@ -48,6 +48,7 @@ define i32 @d(i32 %base) {
; CHECK-NEXT: Determining loop execution counts for: @d
; CHECK-NEXT: Loop %for.cond: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.cond: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.cond: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.cond: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll b/llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll
index 8de3e487a253..798cc3546d1b 100644
--- a/llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll
+++ b/llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll
@@ -28,14 +28,17 @@ define void @test(i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @test
; CHECK-NEXT: Loop %loop2: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop2: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop2: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %loop3: backedge-taken count is false
; CHECK-NEXT: Loop %loop3: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop3: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop3: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop3: Trip multiple is 1
; CHECK-NEXT: Loop %loop.header: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop.header: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop.header: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop.header: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll b/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
index a6195498d7a8..6c056c2175bc 100644
--- a/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
+++ b/llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
@@ -31,9 +31,12 @@ define void @test(i64* %arg) {
; CHECK-NEXT: exit count for loop2.header: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for loop2.latch: false
; CHECK-NEXT: Loop %loop2.header: constant max backedge-taken count is false
-; CHECK-NEXT: Loop %loop2.header: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop2.header: symbolic max backedge-taken count is false symbolic max exit count for loop2.header: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for loop2.latch: false
+; CHECK: Loop %loop2.header: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %loop.header: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop.header: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop.header: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop.header: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/cycled_phis.ll b/llvm/test/Analysis/ScalarEvolution/cycled_phis.ll
index a3146cf04dca..324268815c44 100644
--- a/llvm/test/Analysis/ScalarEvolution/cycled_phis.ll
+++ b/llvm/test/Analysis/ScalarEvolution/cycled_phis.ll
@@ -16,6 +16,7 @@ define void @test_01() {
; CHECK-NEXT: Determining loop execution counts for: @test_01
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -52,9 +53,11 @@ define void @test_02(i32* %p, i32* %q) {
; CHECK-NEXT: Determining loop execution counts for: @test_02
; CHECK-NEXT: Loop %inner_loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %inner_loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %inner_loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %inner_loop: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %outer_loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -103,9 +106,11 @@ define void @test_03(i32* %p, i32* %q) {
; CHECK-NEXT: Determining loop execution counts for: @test_03
; CHECK-NEXT: Loop %inner_loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %inner_loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %inner_loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %inner_loop: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %outer_loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %outer_loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll b/llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll
index f4b1f8292a1a..4b652c7e6df5 100644
--- a/llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll
+++ b/llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll
@@ -15,11 +15,13 @@ define void @test_and(i16 %in) {
; CHECK-NEXT: Determining loop execution counts for: @test_and
; CHECK-NEXT: Loop %bb1.i: backedge-taken count is (1 + (-1 * %in))
; CHECK-NEXT: Loop %bb1.i: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %bb1.i: symbolic max backedge-taken count is (1 + (-1 * %in))
; CHECK-NEXT: Loop %bb1.i: Predicated backedge-taken count is (1 + (-1 * %in))
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb1.i: Trip multiple is 1
; CHECK-NEXT: Loop %bb2: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb2: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %bb2: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb2: Unpredictable predicated backedge-taken count.
;
br label %bb2
@@ -55,6 +57,7 @@ define void @test_or() {
; CHECK-NEXT: Determining loop execution counts for: @test_or
; CHECK-NEXT: Loop %BB: backedge-taken count is undef
; CHECK-NEXT: Loop %BB: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %BB: symbolic max backedge-taken count is undef
; CHECK-NEXT: Loop %BB: Predicated backedge-taken count is undef
; CHECK-NEXT: Predicates:
; CHECK: Loop %BB: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
index 39fe9d092fea..d42474184a0a 100644
--- a/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
+++ b/llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
@@ -13,6 +13,7 @@ define i32 @logical_and_2ops(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_2ops
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -42,6 +43,7 @@ define i32 @logical_or_2ops(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_2ops
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -73,6 +75,7 @@ define i32 @logical_and_3ops(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_3ops
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -106,6 +109,7 @@ define i32 @logical_or_3ops(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -141,6 +145,7 @@ define i32 @logical_or_3ops_duplicate(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops_duplicate
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m umin_seq %k)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -178,6 +183,7 @@ define i32 @logical_or_3ops_redundant_uminseq_operand(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops_redundant_uminseq_operand
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -214,6 +220,7 @@ define i32 @logical_or_3ops_redundant_umin_operand(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops_redundant_umin_operand
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %k umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %k umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %k umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -252,6 +259,7 @@ define i32 @logical_or_4ops_redundant_operand_across_umins(i32 %n, i32 %m, i32 %
; CHECK-NEXT: Determining loop execution counts for: @logical_or_4ops_redundant_operand_across_umins
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n umin %m) umin_seq %k umin_seq %q)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n umin %m) umin_seq %k umin_seq %q)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n umin %m) umin_seq %k umin_seq %q)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -291,6 +299,7 @@ define i32 @logical_or_3ops_operand_wise_redundant_umin(i32 %n, i32 %m, i32 %k)
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops_operand_wise_redundant_umin
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -328,6 +337,7 @@ define i32 @logical_or_3ops_partially_redundant_umin(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_3ops_partially_redundant_umin
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq (%m umin %k))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq (%m umin %k))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq (%m umin %k))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -373,11 +383,13 @@ define i32 @logical_or_5ops_redundant_opearand_of_inner_uminseq(i32 %a, i32 %b,
; CHECK-NEXT: Determining loop execution counts for: @logical_or_5ops_redundant_opearand_of_inner_uminseq
; CHECK-NEXT: Loop %loop: backedge-taken count is (%a umin_seq %b umin_seq ((%e umin_seq %d) umin %c))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%a umin_seq %b umin_seq ((%e umin_seq %d) umin %c))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%a umin_seq %b umin_seq ((%e umin_seq %d) umin %c))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
; CHECK-NEXT: Loop %first.loop: backedge-taken count is (%e umin_seq %d umin_seq %a)
; CHECK-NEXT: Loop %first.loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %first.loop: symbolic max backedge-taken count is (%e umin_seq %d umin_seq %a)
; CHECK-NEXT: Loop %first.loop: Predicated backedge-taken count is (%e umin_seq %d umin_seq %a)
; CHECK-NEXT: Predicates:
; CHECK: Loop %first.loop: Trip multiple is 1
@@ -424,6 +436,7 @@ define i32 @logical_and_2ops_and_constant(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_2ops_and_constant
; CHECK-NEXT: Loop %loop: backedge-taken count is (42 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 42
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (42 umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (42 umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -462,16 +475,19 @@ define i32 @computeSCEVAtScope(i32 %d.0) {
; CHECK-NEXT: Determining loop execution counts for: @computeSCEVAtScope
; CHECK-NEXT: Loop %for.cond: backedge-taken count is (-1 * %d.0)
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.cond: symbolic max backedge-taken count is (-1 * %d.0)
; CHECK-NEXT: Loop %for.cond: Predicated backedge-taken count is (-1 * %d.0)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.cond: Trip multiple is 1
; CHECK-NEXT: Loop %for.cond4: backedge-taken count is 0
; CHECK-NEXT: Loop %for.cond4: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.cond4: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.cond4: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.cond4: Trip multiple is 1
; CHECK-NEXT: Loop %while.cond: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %while.cond: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %while.cond: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %while.cond: Unpredictable predicated backedge-taken count.
;
entry:
@@ -528,6 +544,7 @@ define i64 @uminseq_vs_ptrtoint_complexity(i64 %n, i64 %m, i64* %ptr) {
; CHECK-NEXT: Determining loop execution counts for: @uminseq_vs_ptrtoint_complexity
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -561,6 +578,7 @@ define i32 @logical_and_implies_poison1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison1
; CHECK-NEXT: Loop %loop: backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -593,6 +611,7 @@ define i32 @logical_and_implies_poison2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -625,6 +644,7 @@ define i32 @logical_and_implies_poison3(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison3
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n + %m) umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n + %m) umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -657,6 +677,7 @@ define i32 @logical_and_implies_poison_wrong_direction(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_wrong_direction
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq (%n + %m))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq (%n + %m))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq (%n + %m))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -687,6 +708,7 @@ define i32 @logical_and_implies_poison_noundef(i32 %n, i32 noundef %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_noundef
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -716,6 +738,7 @@ define i32 @logical_and_implies_poison_noundef_wrong_direction(i32 %n, i32 nound
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_noundef_wrong_direction
; CHECK-NEXT: Loop %loop: backedge-taken count is (%m umin_seq %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%m umin_seq %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%m umin_seq %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -749,6 +772,7 @@ define i32 @logical_and_implies_poison_complex1(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_complex1
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin (1 + %n + %m))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n + %m) umin (1 + %n + %m))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n + %m) umin (1 + %n + %m))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -784,6 +808,7 @@ define i32 @logical_and_implies_poison_complex2(i32 %n, i32 %m, i32 %l) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_complex2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin (%n + %m + %l))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n + %m) umin (%n + %m + %l))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n + %m) umin (%n + %m + %l))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -819,6 +844,7 @@ define i32 @logical_and_implies_poison_complex_wrong_direction(i32 %n, i32 %m, i
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_poison_complex_wrong_direction
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin_seq (%n + %m + %l))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((%n + %m) umin_seq (%n + %m + %l))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((%n + %m) umin_seq (%n + %m + %l))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -854,6 +880,7 @@ define i32 @logical_and_implies_multiple_ops(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_multiple_ops
; CHECK-NEXT: Loop %loop: backedge-taken count is (((1 + %n) umin %n) umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (((1 + %n) umin %n) umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (((1 + %n) umin %n) umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -890,6 +917,7 @@ define i32 @logical_and_implies_multiple_ops2(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_multiple_ops2
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m umin_seq (1 + %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m umin_seq (1 + %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m umin_seq (1 + %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -926,6 +954,7 @@ define i32 @logical_and_implies_multiple_ops3(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_implies_multiple_ops3
; CHECK-NEXT: Loop %loop: backedge-taken count is (%m umin_seq ((1 + %n) umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%m umin_seq ((1 + %n) umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%m umin_seq ((1 + %n) umin %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -962,6 +991,7 @@ define i32 @logical_and_not_zero(i16 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_not_zero
; CHECK-NEXT: Loop %loop: backedge-taken count is ((1 + (zext i16 %n to i32))<nuw><nsw> umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65536
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((1 + (zext i16 %n to i32))<nuw><nsw> umin %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((1 + (zext i16 %n to i32))<nuw><nsw> umin %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -997,6 +1027,7 @@ define i32 @logical_and_not_zero_wrong_order(i16 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_not_zero_wrong_order
; CHECK-NEXT: Loop %loop: backedge-taken count is (%m umin_seq (1 + (zext i16 %n to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65536
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%m umin_seq (1 + (zext i16 %n to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%m umin_seq (1 + (zext i16 %n to i32))<nuw><nsw>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1028,6 +1059,7 @@ define i32 @logical_and_not_zero_needs_context(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_not_zero_needs_context
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1066,6 +1098,7 @@ define i32 @logical_and_known_smaller(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_known_smaller
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1104,6 +1137,7 @@ define i32 @logical_and_known_smaller_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_known_smaller_equal
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1142,6 +1176,7 @@ define i32 @logical_and_not_known_smaller_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_not_known_smaller_equal
; CHECK-NEXT: Loop %loop: backedge-taken count is ((zext i16 %n to i32) umin_seq (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((zext i16 %n to i32) umin_seq (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((zext i16 %n to i32) umin_seq (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1180,6 +1215,7 @@ define i32 @logical_and_known_greater(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_known_greater
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1218,6 +1254,7 @@ define i32 @logical_and_known_greater_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_known_greater_equal
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1256,6 +1293,7 @@ define i32 @logical_and_not_known_greater_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_not_known_greater_equal
; CHECK-NEXT: Loop %loop: backedge-taken count is ((zext i16 %n to i32) umin (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 65535
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((zext i16 %n to i32) umin (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((zext i16 %n to i32) umin (65534 + (zext i16 %m to i32))<nuw><nsw>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1288,6 +1326,7 @@ define i32 @logical_and_zero_arg1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_zero_arg1
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1317,6 +1356,7 @@ define i32 @logical_and_zero_arg2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_zero_arg2
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/exit-count-select.ll b/llvm/test/Analysis/ScalarEvolution/exit-count-select.ll
index bd56099da9b3..7bdb7c6d045c 100644
--- a/llvm/test/Analysis/ScalarEvolution/exit-count-select.ll
+++ b/llvm/test/Analysis/ScalarEvolution/exit-count-select.ll
@@ -15,6 +15,7 @@ define void @logical_and_m_const(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_m_const
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (2 umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -46,6 +47,7 @@ define void @logical_and_nonzero(i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_nonzero
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (2 umin %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -78,6 +80,7 @@ define void @logical_and_zero(i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_zero
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -111,6 +114,7 @@ define void @logical_and_inversed(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_and_inversed
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -140,6 +144,7 @@ define void @logical_or_m_const(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_m_const
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (2 umin %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -171,6 +176,7 @@ define void @logical_or_nonzero(i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_nonzero
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (2 umin %m)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -203,6 +209,7 @@ define void @logical_or_zero(i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_zero
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -236,6 +243,7 @@ define void @logical_or_inversed(i32 %n, i32 %m) {
; CHECK-NEXT: Determining loop execution counts for: @logical_or_inversed
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll b/llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll
index 07f004e9e8ee..9eefbd7e2dc4 100644
--- a/llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll
+++ b/llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll
@@ -11,8 +11,10 @@ define void @SLE(i32 %len) willreturn {
; CHECK-NEXT: Determining loop execution counts for: @SLE
; CHECK-NEXT: Loop %for.body: backedge-taken count is (0 smax (1 + %len)<nsw>)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (0 smax (1 + %len)<nsw>)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (0 smax (1 + %len)<nsw>)
; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -33,6 +35,8 @@ define void @SLE_infinite(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @SLE_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
@@ -53,8 +57,10 @@ define void @ULE(i32 %len) willreturn {
; CHECK-NEXT: Determining loop execution counts for: @ULE
; CHECK-NEXT: Loop %for.body: backedge-taken count is (1 + %len)<nuw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (1 + %len)<nuw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (1 + %len)<nuw>
; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -75,6 +81,8 @@ define void @ULE_infinite(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @ULE_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
@@ -93,10 +101,12 @@ for.end:
define void @SGE(i32 %end) willreturn {
; CHECK-LABEL: 'SGE'
; CHECK-NEXT: Determining loop execution counts for: @SGE
-; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 smin (-1 + %end)<nsw>)))
-; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2147483548
-; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 smin (-1 + %end)<nsw>)))
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 smin (-1 + %end)<nsw>)))
+; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2147483548
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (100 + (-1 * (100 smin (-1 + %end)<nsw>)))
+; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 smin (-1 + %end)<nsw>)))
; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -117,6 +127,8 @@ define void @SGE_infinite(i32 %end) {
; CHECK-NEXT: Determining loop execution counts for: @SGE_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
@@ -135,10 +147,12 @@ for.end:
define void @UGE(i32 %end) willreturn {
; CHECK-LABEL: 'UGE'
; CHECK-NEXT: Determining loop execution counts for: @UGE
-; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 umin (-1 + %end)))<nsw>)<nsw>
-; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 100
-; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 umin (-1 + %end)))<nsw>)<nsw>
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 umin (-1 + %end)))<nsw>)<nsw>
+; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 100
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (100 + (-1 * (100 umin (-1 + %end)))<nsw>)<nsw>
+; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 umin (-1 + %end)))<nsw>)<nsw>
; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
br label %for.body
@@ -159,6 +173,8 @@ define void @UGE_infinite(i32 %end) {
; CHECK-NEXT: Determining loop execution counts for: @UGE_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
diff --git a/llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll b/llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll
index 0ce974cc43cd..54652489dbd1 100644
--- a/llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll
+++ b/llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -S -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; This file is conceptually part of flags-from-poison.ll except that the
@@ -18,19 +19,19 @@ define void @subrecurrences(i32 %outer_l, i32 %inner_l, i32 %val) {
; CHECK-NEXT: %i_idx.inc = add nsw i32 %i_idx, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%inner> U: [1,0) S: [1,0) Exits: (1 + %inner_l) LoopDispositions: { %inner: Computable, %outer: Variant }
; CHECK-NEXT: %v = sub nsw i32 %i_idx, %o_idx.inc
-; CHECK-NEXT: -->
-; NOTE: Line deleted from autogen output due to format confusing regex matcher
+; CHECK-NEXT: --> {{\{}}{-1,+,-1}<nw><%outer>,+,1}<nsw><%inner> U: full-set S: full-set Exits: {(-1 + %inner_l),+,-1}<nw><%outer> LoopDispositions: { %inner: Computable, %outer: Variant }
; CHECK-NEXT: %forub = udiv i32 1, %v
-; CHECK-NEXT: -->
-; NOTE: Line deleted from autogen output due to format confusing regex matcher
+; CHECK-NEXT: --> (1 /u {{\{}}{-1,+,-1}<nw><%outer>,+,1}<nsw><%inner>) U: [0,2) S: [0,2) Exits: (1 /u {(-1 + %inner_l),+,-1}<nw><%outer>) LoopDispositions: { %inner: Computable, %outer: Variant }
; CHECK-NEXT: Determining loop execution counts for: @subrecurrences
; CHECK-NEXT: Loop %inner: backedge-taken count is %inner_l
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is %inner_l
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is %inner_l
; CHECK-NEXT: Predicates:
; CHECK: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer: backedge-taken count is %outer_l
; CHECK-NEXT: Loop %outer: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %outer: symbolic max backedge-taken count is %outer_l
; CHECK-NEXT: Loop %outer: Predicated backedge-taken count is %outer_l
; CHECK-NEXT: Predicates:
; CHECK: Loop %outer: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll b/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll
index 9f31f2e19f96..a8a831e55a33 100644
--- a/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll
+++ b/llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll
@@ -31,6 +31,7 @@ define void @test-add-nsw(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -69,6 +70,7 @@ define void @test-add-nuw(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -108,6 +110,7 @@ define void @test-add-scope-invariant(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-invariant
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %offset) + %needle)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %offset) + %needle)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %offset) + %needle)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -148,6 +151,7 @@ define void @test-add-scope-bound(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -181,6 +185,7 @@ define void @test-add-scope-bound-unkn-preheader(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-preheader
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -212,6 +217,7 @@ define void @test-add-scope-bound-unkn-preheader-neg1(i32* %input, i32 %needle)
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-preheader-neg1
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -244,6 +250,7 @@ define void @test-add-scope-bound-unkn-preheader-neg2(i32* %input, i32 %needle)
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-preheader-neg2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -279,6 +286,7 @@ define void @test-add-scope-bound-unkn-header(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-header
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -313,6 +321,7 @@ define void @test-add-scope-bound-unkn-header2(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-header2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -348,6 +357,7 @@ define void @test-add-scope-bound-unkn-header-neg(i32* %input, i32 %needle) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-scope-bound-unkn-header-neg
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -383,6 +393,7 @@ define void @test-add-nuw-from-icmp(float* %input, i32 %offset,
; CHECK-NEXT: Determining loop execution counts for: @test-add-nuw-from-icmp
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -422,6 +433,7 @@ define void @test-add-no-load(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-no-load
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -459,6 +471,7 @@ define void @test-add-not-header(float* %input, i32 %offset, i32 %numIterations)
; CHECK-NEXT: Determining loop execution counts for: @test-add-not-header
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -497,6 +510,7 @@ define void @test-add-not-header2(float* %input, i32 %offset, i32 %numIterations
; CHECK-NEXT: Determining loop execution counts for: @test-add-not-header2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -539,7 +553,9 @@ define void @test-add-not-header3(float* %input, i32 %offset, i32 %numIterations
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for loop2: (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations) symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for loop2: (-1 + %numIterations)
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
i1* %cond_buf) {
entry:
@@ -577,6 +593,7 @@ define void @test-add-not-header4(float* %input, i32 %offset, i32 %numIterations
; CHECK-NEXT: Determining loop execution counts for: @test-add-not-header4
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -618,6 +635,7 @@ define void @test-add-not-header5(float* %input, i32 %offset) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-not-header5
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -652,6 +670,7 @@ define void @test-add-call(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-call
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -689,6 +708,7 @@ define void @test-add-call2(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-call2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -725,6 +745,7 @@ define void @test-gep-propagates-poison(float* %input, i32 %offset, i32 %numIter
; CHECK-NEXT: Determining loop execution counts for: @test-gep-propagates-poison
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -763,6 +784,7 @@ define void @test-add-mul-propagates(float* %input, i32 %offset, i32 %numIterati
; CHECK-NEXT: Determining loop execution counts for: @test-add-mul-propagates
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -801,6 +823,7 @@ define void @test-mul-propagates-poison(float* %input, i32 %offset, i32 %numIter
; CHECK-NEXT: Determining loop execution counts for: @test-mul-propagates-poison
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -838,6 +861,7 @@ define void @test-mul-propagates-poison-2(float* %input, i32 %offset, i32 %numIt
; CHECK-NEXT: Determining loop execution counts for: @test-mul-propagates-poison-2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -874,6 +898,7 @@ define void @test-add-div(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-div
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -908,6 +933,7 @@ define void @test-add-div2(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-div2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -942,6 +968,7 @@ define void @test-add-store(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-store
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -984,6 +1011,7 @@ define void @test-add-twice(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-twice
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1027,6 +1055,7 @@ define void @test-mul-nsw(float* %input, i32 %stride, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-mul-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1064,6 +1093,7 @@ define void @test-mul-nuw(float* %input, i32 %stride, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-mul-nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1103,6 +1133,7 @@ define void @test-shl-nsw(float* %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-shl-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1142,6 +1173,7 @@ define void @test-shl-nuw-edgecase(float* %input, i32 %start, i32 %numIterations
; CHECK-NEXT: Determining loop execution counts for: @test-shl-nuw-edgecase
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1181,6 +1213,7 @@ define void @test-shl-nuw-nsw(float* %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-shl-nuw-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1220,6 +1253,7 @@ define void @test-shl-no-nsw(float* %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-shl-no-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1259,6 +1293,7 @@ define void @test-shl-nsw-edgecase(float* %input, i32 %start, i32 %numIterations
; CHECK-NEXT: Determining loop execution counts for: @test-shl-nsw-edgecase
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1296,6 +1331,7 @@ define void @test-shl-nuw(float* %input, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-shl-nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1336,6 +1372,7 @@ define void @test-sub-no-nsw(float* %input, i32 %start, i32 %sub, i32 %numIterat
; CHECK-NEXT: Determining loop execution counts for: @test-sub-no-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1377,6 +1414,7 @@ define void @test-sub-nsw(float* %input, i32 %start, i32 %sub, i32 %numIteration
; CHECK-NEXT: Determining loop execution counts for: @test-sub-nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1417,6 +1455,7 @@ define void @test-sub-nsw-lhs-non-negative(float* %input, i32 %sub, i32 %numIter
; CHECK-NEXT: Determining loop execution counts for: @test-sub-nsw-lhs-non-negative
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1461,7 +1500,9 @@ define void @test-sext-sub(float* %input, i32 %sub, i32 %numIterations) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for cont: (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations) symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for cont: (-1 + %numIterations)
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@@ -1511,6 +1552,7 @@ define void @test-sub-with-add(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-sub-with-add
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1578,7 +1620,9 @@ define i32 @pr28932() {
; CHECK-NEXT: exit count for if.then: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for if.else: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.cond: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %for.cond: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %for.cond: Unpredictable symbolic max backedge-taken count. symbolic max exit count for if.then: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for if.else: ***COULDNOTCOMPUTE***
+; CHECK: Loop %for.cond: Unpredictable predicated backedge-taken count.
;
entry:
%pre = load %struct.anon*, %struct.anon** @a, align 8
diff --git a/llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll b/llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll
index f202c093fa5f..5b8afd5d089f 100644
--- a/llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll
+++ b/llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll
@@ -61,18 +61,25 @@ define dso_local i32 @f() {
; CHECK-NEXT: exit count for for.cond6: 0
; CHECK-NEXT: exit count for for.end: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.cond6: constant max backedge-taken count is 0
-; CHECK-NEXT: Loop %for.cond6: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %for.cond6: symbolic max backedge-taken count is 0 symbolic max exit count for for.cond6: 0
+; CHECK-NEXT: symbolic max exit count for for.end: ***COULDNOTCOMPUTE***
+; CHECK: Loop %for.cond6: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %inner.loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: exit count for inner.loop: 0
; CHECK-NEXT: exit count for for.end.3: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %inner.loop: constant max backedge-taken count is 0
-; CHECK-NEXT: Loop %inner.loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %inner.loop: symbolic max backedge-taken count is 0 symbolic max exit count for inner.loop: 0
+; CHECK-NEXT: symbolic max exit count for for.end.3: ***COULDNOTCOMPUTE***
+; CHECK: Loop %inner.loop: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %outer.loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: exit count for for.cond6: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for inner.loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for for.inc13.3: 2
; CHECK-NEXT: Loop %outer.loop: constant max backedge-taken count is 2
-; CHECK-NEXT: Loop %outer.loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %outer.loop: symbolic max backedge-taken count is 2 symbolic max exit count for for.cond6: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for inner.loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for for.inc13.3: 2
+; CHECK: Loop %outer.loop: Unpredictable predicated backedge-taken count.
;
entry:
store i32 3, i32* @a, align 4
diff --git a/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll b/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
index e1b1110251cb..f2d0ccac329b 100644
--- a/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
+++ b/llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
@@ -19,6 +19,7 @@ define void @f0(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f0
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -86,6 +87,7 @@ define void @f1(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f1
; CHECK-NEXT: Loop %loop: backedge-taken count is 15
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 15
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 15
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 15
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 16
@@ -146,6 +148,7 @@ define void @f2(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f2
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -188,6 +191,7 @@ define void @f3(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f3
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -237,6 +241,7 @@ define void @f4(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f4
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -285,6 +290,7 @@ define void @f5(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f5
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -330,6 +336,7 @@ define void @f6(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f6
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
@@ -378,6 +385,7 @@ define void @f7(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f7
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 127
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 127
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 128
diff --git a/llvm/test/Analysis/ScalarEvolution/load.ll b/llvm/test/Analysis/ScalarEvolution/load.ll
index 66a9f4c9156a..00fc3101985e 100644
--- a/llvm/test/Analysis/ScalarEvolution/load.ll
+++ b/llvm/test/Analysis/ScalarEvolution/load.ll
@@ -32,6 +32,7 @@ define i32 @test1() nounwind readnone {
; CHECK-NEXT: Determining loop execution counts for: @test1
; CHECK-NEXT: Loop %for.body: backedge-taken count is 49
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 49
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 49
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 49
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 50
@@ -85,6 +86,7 @@ define i32 @test2() nounwind uwtable readonly {
; CHECK-NEXT: Determining loop execution counts for: @test2
; CHECK-NEXT: Loop %for.body: backedge-taken count is 4
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 5
diff --git a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
index ed3502c3ed64..6330111dce07 100644
--- a/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
+++ b/llvm/test/Analysis/ScalarEvolution/logical-operations.ll
@@ -430,6 +430,7 @@ define i8* @tautological_select_like_phi(i32 %tc) {
; CHECK-NEXT: Determining loop execution counts for: @tautological_select_like_phi
; CHECK-NEXT: Loop %loop: backedge-taken count is 100
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 100
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 100
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 100
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 101
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
index 2611b3b6c4a1..0431b4b5dcb8 100644
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
@@ -18,6 +18,7 @@ define void @rewrite_zext(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -61,6 +62,7 @@ define i32 @rewrite_zext_min_max(i32 %N, i32* %arr) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext_min_max
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((zext i32 (16 umin %N) to i64) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((zext i32 (16 umin %N) to i64) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((zext i32 (16 umin %N) to i64) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -110,6 +112,7 @@ define i32 @rewrite_zext_with_info_from_icmp_ne(i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext_with_info_from_icmp_ne
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -159,6 +162,7 @@ define i32 @rewrite_zext_no_icmp_ne(i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext_no_icmp_ne
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 1073741823
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((4 + (zext i32 (-1 + (zext i2 (trunc i32 %N to i2) to i32))<nsw> to i64))<nuw><nsw> /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -200,6 +204,7 @@ define void @rewrite_zext_and_base_1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext_and_base_1
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -244,6 +249,7 @@ define void @rewrite_zext_and_base_2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @rewrite_zext_and_base_2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-8 + (8 * ((zext i32 %n to i64) /u 8))<nuw><nsw>)<nsw> /u 8)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -286,6 +292,7 @@ define void @guard_pessimizes_analysis_step2(i1 %c, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @guard_pessimizes_analysis_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((14 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
index 93d63df5a0a2..ceefa2db3f05 100644
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
@@ -15,6 +15,7 @@ define void @test_guard_less_than_16(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 15
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -47,6 +48,7 @@ define void @test_guard_less_than_16_operands_swapped(i32* nocapture %a, i64 %i)
; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16_operands_swapped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 15
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -79,6 +81,7 @@ define void @test_guard_less_than_16_branches_flipped(i32* nocapture %a, i64 %i)
; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16_branches_flipped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -111,6 +114,7 @@ define void @test_guard_uge_16_branches_flipped(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_uge_16_branches_flipped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 15
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -143,6 +147,7 @@ define void @test_guard_eq_12(i32* nocapture %a, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_eq_12
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 12
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %N
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -175,6 +180,7 @@ define void @test_guard_ule_12(i32* nocapture %a, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ule_12
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 12
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %N
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -207,6 +213,7 @@ define void @test_guard_ule_12_step2(i32* nocapture %a, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ule_12_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%N /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -239,6 +246,7 @@ define void @test_multiple_const_guards_order1(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_multiple_const_guards_order1
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 9
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %i
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -275,6 +283,7 @@ define void @test_multiple_const_guards_order2(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_multiple_const_guards_order2
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 9
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %i
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -312,6 +321,7 @@ define void @test_multiple_var_guards_order1(i32* nocapture %a, i64 %i, i64 %N)
; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_order1
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %i
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -349,6 +359,7 @@ define void @test_multiple_var_guards_order2(i32* nocapture %a, i64 %i, i64 %N)
; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_order2
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %i
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -386,6 +397,7 @@ define void @test_multiple_var_guards_cycle(i32* nocapture %a, i64 %i, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_cycle
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %N
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -422,6 +434,7 @@ define void @test_guard_ult_ne(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ult_ne
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -458,6 +471,7 @@ define void @test_guard_ne_ult(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ne_ult
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -496,6 +510,7 @@ define void @test_guard_if_and_enter(i32* nocapture readonly %data, i64 %count)
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_and_enter
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -532,6 +547,7 @@ define void @test_guard_if_and_skip(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_and_skip
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -570,6 +586,7 @@ define void @test_guard_if_and_and(i32* nocapture readonly %data, i64 %count, i1
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_and_and
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -609,6 +626,7 @@ define void @test_guard_if_and_or(i32* nocapture readonly %data, i64 %count, i1
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_and_or
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -646,6 +664,7 @@ define void @test_guard_if_or_skip(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_or_skip
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -682,6 +701,7 @@ define void @test_guard_if_or_enter(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_or_enter
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -720,6 +740,7 @@ define void @test_guard_if_or_or(i32* nocapture readonly %data, i64 %count, i1 %
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_or_or
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -759,6 +780,7 @@ define void @test_guard_if_or_and(i32* nocapture readonly %data, i64 %count, i1
; CHECK-NEXT: Determining loop execution counts for: @test_guard_if_or_and
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -797,6 +819,7 @@ define void @test_guard_and_assume(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_and_assume
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -833,6 +856,7 @@ define void @test_guard_assume_and(i32* nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_assume_and
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -871,6 +895,7 @@ define void @guard_pessimizes_analysis_step1(i1 %c, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @guard_pessimizes_analysis_step1
; CHECK-NEXT: Loop %loop: backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 7
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -911,6 +936,7 @@ define void @guard_pessimizes_analysis_step2(i1 %c, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @guard_pessimizes_analysis_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((8 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 3
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((8 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((8 + (-1 * %init)<nsw>)<nsw> /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -952,14 +978,17 @@ define void @crash(i8* %ptr) {
; CHECK-NEXT: Determining loop execution counts for: @crash
; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoint i8* %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Loop %while.body125: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoint i8* %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Loop %while.body125: Predicated backedge-taken count is {(-2 + (-1 * (ptrtoint i8* %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Predicates:
; CHECK: Loop %while.body125: Trip multiple is 1
; CHECK-NEXT: Loop %while.cond111: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %while.cond111: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %while.cond111: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %while.cond111: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %while.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %while.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %while.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %while.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -1003,6 +1032,7 @@ define void @test_guard_uge(i32 %blockSize) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_uge
; CHECK-NEXT: Loop %while.body: backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: constant max backedge-taken count is 1073741822
+; CHECK-NEXT: Loop %while.body: symbolic max backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: Predicated backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %while.body: Trip multiple is 1
@@ -1039,6 +1069,7 @@ define void @test_guard_ugt(i32 %blockSize) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ugt
; CHECK-NEXT: Loop %while.body: backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: constant max backedge-taken count is 1073741822
+; CHECK-NEXT: Loop %while.body: symbolic max backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: Predicated backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %while.body: Trip multiple is 1
@@ -1075,6 +1106,7 @@ define void @test_guard_uge_and_ule(i32 %blockSize) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_uge_and_ule
; CHECK-NEXT: Loop %while.body: backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: constant max backedge-taken count is 255
+; CHECK-NEXT: Loop %while.body: symbolic max backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: Predicated backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %while.body: Trip multiple is 1
@@ -1115,6 +1147,7 @@ define void @test_guard_ugt_and_ult(i32 %blockSize) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_ugt_and_ult
; CHECK-NEXT: Loop %while.body: backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: constant max backedge-taken count is 255
+; CHECK-NEXT: Loop %while.body: symbolic max backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Loop %while.body: Predicated backedge-taken count is (-1 + (%blockSize /u 4))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %while.body: Trip multiple is 1
@@ -1157,6 +1190,7 @@ define void @test_guard_slt_sgt_1(i32* nocapture %a, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_slt_sgt_1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 10
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1193,6 +1227,7 @@ define void @test_guard_slt_sgt_2(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_slt_sgt_2
; CHECK-NEXT: Loop %loop: backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 12
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1229,6 +1264,7 @@ define void @test_guard_sle_sge_1(i32* nocapture %a, i64 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_sle_sge_1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 11
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1265,6 +1301,7 @@ define void @test_guard_sle_sge_2(i32* nocapture %a, i64 %i) {
; CHECK-NEXT: Determining loop execution counts for: @test_guard_sle_sge_2
; CHECK-NEXT: Loop %loop: backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 13
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1304,6 +1341,7 @@ define void @optimized_range_check_unsigned(i16* %pred, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @optimized_range_check_unsigned
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1340,6 +1378,7 @@ define void @optimized_range_check_unsigned_icmp_ops_swapped(i16* %pred, i32 %N)
; CHECK-NEXT: Determining loop execution counts for: @optimized_range_check_unsigned_icmp_ops_swapped
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1378,6 +1417,7 @@ define void @optimized_range_check_unsigned2(i16* %pred, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @optimized_range_check_unsigned2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 20
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1417,6 +1457,7 @@ define void @optimized_range_check_unsigned3(i16* %pred, i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @optimized_range_check_unsigned3
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1455,6 +1496,7 @@ define void @not_optimized_range_check_unsigned1(i16* %pred, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @not_optimized_range_check_unsigned1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1492,6 +1534,7 @@ define void @not_optimized_range_check_unsigned2(i16* %pred, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @not_optimized_range_check_unsigned2
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1523,6 +1566,7 @@ define i32 @sle_sgt_ult_umax_to_smax(i32 %num) {
; CHECK-NEXT: Determining loop execution counts for: @sle_sgt_ult_umax_to_smax
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -1560,6 +1604,7 @@ define i32 @ult_sle_sgt_umax_to_smax(i32 %num) {
; CHECK-NEXT: Determining loop execution counts for: @ult_sle_sgt_umax_to_smax
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 1073741823
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll
index e90d1503c184..45978ee35c5b 100644
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll
@@ -1,13 +1,18 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scalar-evolution-max-iterations=0 -scalar-evolution-classify-expressions=0 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define void @max_backedge_taken_count_by_wrapping1_nsw_nuw(i8 %N, i8* %ptr) {
-; CHECK-LABEL: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping1_nsw_nuw
+; CHECK-LABEL: 'max_backedge_taken_count_by_wrapping1_nsw_nuw'
+; CHECK-NEXT: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping1_nsw_nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 63
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%N /u 4)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br label %loop
@@ -25,10 +30,14 @@ exit:
}
define void @max_backedge_taken_count_by_wrapping1_nuw(i8 %N, i8* %ptr) {
-; CHECK-LABEL: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping1_nuw
+; CHECK-LABEL: 'max_backedge_taken_count_by_wrapping1_nuw'
+; CHECK-NEXT: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping1_nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 63
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%N /u 4)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br label %loop
@@ -46,10 +55,14 @@ exit:
}
define void @max_backedge_taken_count_by_wrapping2_nsw_nuw(i8 %N, i8* %ptr) {
-; CHECK-LABEL: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping2
+; CHECK-LABEL: 'max_backedge_taken_count_by_wrapping2_nsw_nuw'
+; CHECK-NEXT: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping2_nsw_nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 63
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-64 + %N) /u 4)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br label %loop
@@ -67,10 +80,14 @@ exit:
}
define void @max_backedge_taken_count_by_wrapping2_nuw(i8 %N, i8* %ptr) {
-; CHECK-LABEL: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping2
-; CHECK-NEXT: Loop %loop: backedge-taken count is ((-64 + %N) /u 4)
+; CHECK-LABEL: 'max_backedge_taken_count_by_wrapping2_nuw'
+; CHECK-NEXT: Determining loop execution counts for: @max_backedge_taken_count_by_wrapping2_nuw
+; CHECK-NEXT: Loop %loop: backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 63
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-64 + %N) /u 4)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br label %loop
diff --git a/llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll b/llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll
index 81d9e8ad3839..07d16b1342c1 100644
--- a/llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll
@@ -22,6 +22,7 @@ define void @pluto(i32 %arg) {
; CHECK-NEXT: Determining loop execution counts for: @pluto
; CHECK-NEXT: Loop %bb2: backedge-taken count is (1 /u (2 + %tmp)<nsw>)
; CHECK-NEXT: Loop %bb2: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %bb2: symbolic max backedge-taken count is (1 /u (2 + %tmp)<nsw>)
; CHECK-NEXT: Loop %bb2: Predicated backedge-taken count is (1 /u (2 + %tmp)<nsw>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb2: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll b/llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll
index 946208a36a8f..a9615aff0244 100644
--- a/llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll
+++ b/llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll
@@ -48,6 +48,7 @@ define void @f(i32* %A, i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @f
; CHECK-NEXT: Loop %bb1: backedge-taken count is (0 smax %N)
; CHECK-NEXT: Loop %bb1: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %bb1: symbolic max backedge-taken count is (0 smax %N)
; CHECK-NEXT: Loop %bb1: Predicated backedge-taken count is (0 smax %N)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb1: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/ne-overflow.ll b/llvm/test/Analysis/ScalarEvolution/ne-overflow.ll
index 0a621be31b3c..00f90033fe12 100644
--- a/llvm/test/Analysis/ScalarEvolution/ne-overflow.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ne-overflow.ll
@@ -12,6 +12,7 @@ define void @test(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-2 + %N) /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-2 + %N) /u 2)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-2 + %N) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -34,6 +35,7 @@ define void @test_preinc(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_preinc
; CHECK-NEXT: Loop %for.body: backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (%N /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -59,6 +61,7 @@ define void @test_well_defined_infinite_st(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_well_defined_infinite_st
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -80,6 +83,7 @@ define void @test_well_defined_infinite_ld(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_well_defined_infinite_ld
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -101,6 +105,7 @@ define void @test_no_mustprogress(i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @test_no_mustprogress
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -123,6 +128,7 @@ define void @test_1024(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_1024
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-1024 + %N) /u 1024)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 4194303
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-1024 + %N) /u 1024)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-1024 + %N) /u 1024)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -145,6 +151,7 @@ define void @test_uneven_divide(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_uneven_divide
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (-1431655765 * %N))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (-1431655765 * %N))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (-1431655765 * %N))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -167,6 +174,7 @@ define void @test_non_invariant_rhs() mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_non_invariant_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -190,6 +198,7 @@ define void @test_abnormal_exit(i32 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_abnormal_exit
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -214,7 +223,9 @@ define void @test_other_exit(i32 %N) mustprogress {
; CHECK-NEXT: exit count for for.body: 9
; CHECK-NEXT: exit count for for.latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 9
-; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 9 symbolic max exit count for for.body: 9
+; CHECK-NEXT: symbolic max exit count for for.latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
@@ -238,6 +249,7 @@ define void @test_zext(i64 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_zext
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (%N /u 2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {0,+,2}<nuw><%for.body> Added Flags: <nusw>
@@ -261,6 +273,7 @@ define void @test_sext(i64 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_sext
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -282,6 +295,7 @@ define void @test_zext_of_sext(i64 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_zext_of_sext
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -304,6 +318,7 @@ define void @test_zext_offset(i64 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_zext_offset
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -326,6 +341,7 @@ define void @test_sext_offset(i64 %N) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @test_sext_offset
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
index 0234609886f2..f4dbfd8224c0 100644
--- a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
+++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
@@ -305,6 +305,7 @@ define i1 @test2_a(i32 %a, i32 %b, i1 %will_overflow) {
; CHECK-NEXT: Determining loop execution counts for: @test2_a
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -341,6 +342,7 @@ define i1 @test2_b(i32 %a, i32 %b, i1 %will_overflow) {
; CHECK-NEXT: Determining loop execution counts for: @test2_b
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll
index 8f1f633a64cc..46587252cf57 100644
--- a/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll
+++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll
@@ -27,7 +27,9 @@ define i32 @test_01(i32 %start, i32* %p, i32* %q) {
; CHECK-NEXT: exit count for loop: (zext i32 %start to i64)
; CHECK-NEXT: exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %start to i64) symbolic max exit count for loop: (zext i32 %start to i64)
+; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%0 = zext i32 %start to i64
@@ -72,6 +74,7 @@ define i32 @test_02(i32 %start, i32* %p, i32* %q) {
; CHECK-NEXT: Determining loop execution counts for: @test_02
; CHECK-NEXT: Loop %loop: backedge-taken count is (9223372036854775806 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nuw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -2147483650
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (9223372036854775806 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nuw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (9223372036854775806 + (2147483648 * (zext i32 %start to i64))<nuw><nsw>)<nuw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -103,6 +106,7 @@ define void @pointer_iv_nowrap(i8* %startptr, i8* %endptr) local_unnamed_addr {
; CHECK-NEXT: Determining loop execution counts for: @pointer_iv_nowrap
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -131,6 +135,7 @@ define void @pointer_iv_nowrap_guard(i32* %startptr, i32* %endptr) local_unnamed
; CHECK-NEXT: Determining loop execution counts for: @pointer_iv_nowrap_guard
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4611686018427387903
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-8001 + (-1 * (ptrtoint i32* %startptr to i64)) + ((8004 + (ptrtoint i32* %startptr to i64)) umax (ptrtoint i32* %endptr to i64))) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll b/llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
index c17d91292268..d927e693184e 100644
--- a/llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
+++ b/llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
@@ -46,6 +46,7 @@ define void @foo(i32 %no, double* nocapture %d, double* nocapture %q) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @foo
; CHECK-NEXT: Loop %bb: backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is 1073741822
+; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/nsw-offset.ll b/llvm/test/Analysis/ScalarEvolution/nsw-offset.ll
index 48efd9668b3d..2c4eba8ac218 100644
--- a/llvm/test/Analysis/ScalarEvolution/nsw-offset.ll
+++ b/llvm/test/Analysis/ScalarEvolution/nsw-offset.ll
@@ -43,6 +43,7 @@ define void @foo(i32 %no, double* nocapture %d, double* nocapture %q) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @foo
; CHECK-NEXT: Loop %bb: backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is 1073741822
+; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is ((-1 + (2 * (%no /u 2))<nuw>) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/nsw.ll b/llvm/test/Analysis/ScalarEvolution/nsw.ll
index f5f9249de6b9..ff5282d466b9 100644
--- a/llvm/test/Analysis/ScalarEvolution/nsw.ll
+++ b/llvm/test/Analysis/ScalarEvolution/nsw.ll
@@ -29,6 +29,7 @@ define void @test1(double* %p) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @test1
; CHECK-NEXT: Loop %bb: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %bb: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb: Unpredictable predicated backedge-taken count.
;
entry:
@@ -77,6 +78,7 @@ define void @test2(i32* %begin, i32* %end) ssp {
; CHECK-NEXT: Determining loop execution counts for: @test2
; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is 4611686018427387903
+; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body.i.i: Trip multiple is 1
@@ -117,6 +119,7 @@ define void @test3(i32* %begin, i32* %end) nounwind ssp {
; CHECK-NEXT: Determining loop execution counts for: @test3
; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is 4611686018427387903
+; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %begin to i64)) + (ptrtoint i32* %end to i64)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body.i.i: Trip multiple is 1
@@ -179,6 +182,7 @@ define i32 @PR12375(i32* readnone %arg) {
; CHECK-NEXT: Determining loop execution counts for: @PR12375
; CHECK-NEXT: Loop %bb1: backedge-taken count is 1
; CHECK-NEXT: Loop %bb1: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %bb1: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %bb1: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb1: Trip multiple is 2
@@ -209,6 +213,7 @@ define void @PR12376(i32* nocapture %arg, i32* nocapture %arg1) {
; CHECK-NEXT: Determining loop execution counts for: @PR12376
; CHECK-NEXT: Loop %bb2: backedge-taken count is ((-1 + (-1 * (ptrtoint i32* %arg to i64)) + ((4 + (ptrtoint i32* %arg to i64))<nuw> umax (ptrtoint i32* %arg1 to i64))) /u 4)
; CHECK-NEXT: Loop %bb2: constant max backedge-taken count is 4611686018427387902
+; CHECK-NEXT: Loop %bb2: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoint i32* %arg to i64)) + ((4 + (ptrtoint i32* %arg to i64))<nuw> umax (ptrtoint i32* %arg1 to i64))) /u 4)
; CHECK-NEXT: Loop %bb2: Predicated backedge-taken count is ((-1 + (-1 * (ptrtoint i32* %arg to i64)) + ((4 + (ptrtoint i32* %arg to i64))<nuw> umax (ptrtoint i32* %arg1 to i64))) /u 4)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb2: Trip multiple is 1
@@ -244,6 +249,7 @@ define void @nswnowrap(i32 %v, i32* %buf) {
; CHECK-NEXT: Determining loop execution counts for: @nswnowrap
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-1 * %v) + ((1 + %v)<nsw> smax %v))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1, actual taken count either this or zero.
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-1 * %v) + ((1 + %v)<nsw> smax %v)), actual taken count either this or zero.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-1 * %v) + ((1 + %v)<nsw> smax %v))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -286,6 +292,7 @@ define void @test4(i32 %arg) {
; CHECK-NEXT: Determining loop execution counts for: @test4
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2147483638
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (-1 * %arg) + (10 smax (1 + %arg)<nsw>))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -319,6 +326,7 @@ define void @bad_postinc_nsw_a(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @bad_postinc_nsw_a
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -350,6 +358,7 @@ define void @postinc_poison_prop_through_and(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @postinc_poison_prop_through_and
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -378,6 +387,7 @@ define void @pr28012(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @pr28012
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (7 umax %n)) /u 7)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566755
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (7 umax %n)) /u 7)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (7 umax %n)) /u 7)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -410,6 +420,7 @@ define void @select_cond_poison_propagation(double* %p, i32 %x) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @select_cond_poison_propagation
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/outer_phi.ll b/llvm/test/Analysis/ScalarEvolution/outer_phi.ll
index 02511a214838..868f2b612aed 100644
--- a/llvm/test/Analysis/ScalarEvolution/outer_phi.ll
+++ b/llvm/test/Analysis/ScalarEvolution/outer_phi.ll
@@ -21,12 +21,16 @@ define i32 @test_01(i32 %a, i32 %b) {
; CHECK-NEXT: exit count for inner: %b
; CHECK-NEXT: exit count for inner.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is 2147483647
-; CHECK-NEXT: Loop %inner: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is %b symbolic max exit count for inner: %b
+; CHECK-NEXT: symbolic max exit count for inner.backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %inner: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %outer: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: exit count for inner: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for outer.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %outer: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %outer: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %outer: Unpredictable symbolic max backedge-taken count. symbolic max exit count for inner: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for outer.backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %outer: Unpredictable predicated backedge-taken count.
;
entry:
%b_is_non_negative = icmp sge i32 %b, 0
@@ -79,12 +83,16 @@ define i32 @test_02(i32 %a, i32 %b) {
; CHECK-NEXT: exit count for inner: ((-1 * %outer.iv) + (%b smax %outer.iv))
; CHECK-NEXT: exit count for inner.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is -1
-; CHECK-NEXT: Loop %inner: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ((-1 * %outer.iv) + (%b smax %outer.iv)) symbolic max exit count for inner: ((-1 * %outer.iv) + (%b smax %outer.iv))
+; CHECK-NEXT: symbolic max exit count for inner.backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %inner: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %outer: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: exit count for inner: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for outer.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %outer: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %outer: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %outer: Unpredictable symbolic max backedge-taken count. symbolic max exit count for inner: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for outer.backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %outer: Unpredictable predicated backedge-taken count.
;
entry:
%b_is_non_negative = icmp sge i32 %b, 0
diff --git a/llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll b/llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll
index 9d1c7f52af43..8725a844701a 100644
--- a/llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll
+++ b/llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll
@@ -13,6 +13,7 @@ define void @uadd_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @uadd_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 35
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 35
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 35
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 35
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 36
@@ -39,6 +40,7 @@ define void @sadd_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @sadd_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 67
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 67
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 67
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 67
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 68
@@ -65,6 +67,7 @@ define void @usub_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @usub_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 50
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 50
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 50
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 50
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 51
@@ -91,6 +94,7 @@ define void @ssub_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @ssub_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 68
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 68
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 68
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 68
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 69
@@ -117,6 +121,7 @@ define void @smul_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @smul_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 14
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 14
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 14
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 14
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 15
@@ -143,6 +148,7 @@ define void @umul_exhaustive() {
; CHECK-NEXT: Determining loop execution counts for: @umul_exhaustive
; CHECK-NEXT: Loop %for.body: backedge-taken count is 15
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 15
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 15
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 15
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 16
@@ -169,6 +175,7 @@ define void @uadd_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @uadd_symbolic_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (-1 * %start))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -195,6 +202,7 @@ define void @sadd_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @sadd_symbolic_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is (32767 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (32767 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (32767 + (-1 * %start))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -221,6 +229,7 @@ define void @sadd_symbolic_start2(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @sadd_symbolic_start2
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -246,6 +255,7 @@ define void @sadd_symbolic_swapped(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @sadd_symbolic_swapped
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -270,6 +280,7 @@ define void @usub_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @usub_symbolic_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is %start
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is %start
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is %start
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -296,6 +307,7 @@ define void @ssub_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @ssub_symbolic_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-32768 + %start)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-32768 + %start)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-32768 + %start)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -322,6 +334,7 @@ define void @smul_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @smul_symbolic_start
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -346,6 +359,7 @@ define void @umul_symbolic_start(i16 %start) {
; CHECK-NEXT: Determining loop execution counts for: @umul_symbolic_start
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -372,7 +386,9 @@ define void @sadd_symbolic_non_latch(i16 %start) {
; CHECK-NEXT: exit count for for.body: (32767 + (-1 * %start))
; CHECK-NEXT: exit count for for.latch: (230 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
-; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((230 + (-1 * %start)) umin (32767 + (-1 * %start)))
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((230 + (-1 * %start)) umin (32767 + (-1 * %start))) symbolic max exit count for for.body: (32767 + (-1 * %start))
+; CHECK-NEXT: symbolic max exit count for for.latch: (230 + (-1 * %start))
+; CHECK: Loop %for.body: Predicated backedge-taken count is ((230 + (-1 * %start)) umin (32767 + (-1 * %start)))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
diff --git a/llvm/test/Analysis/ScalarEvolution/pr48225.ll b/llvm/test/Analysis/ScalarEvolution/pr48225.ll
index cf21e6c1ad82..c25181b0e35a 100644
--- a/llvm/test/Analysis/ScalarEvolution/pr48225.ll
+++ b/llvm/test/Analysis/ScalarEvolution/pr48225.ll
@@ -25,7 +25,9 @@ define void @test_and(i1 %boolcond) {
; CHECK-NEXT: exit count for loop: 2
; CHECK-NEXT: exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2 symbolic max exit count for loop: 2
+; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%conv = zext i1 %boolcond to i32
@@ -72,7 +74,9 @@ define void @test_or(i1 %boolcond) {
; CHECK-NEXT: exit count for loop: 2
; CHECK-NEXT: exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2 symbolic max exit count for loop: 2
+; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%conv = zext i1 %boolcond to i32
diff --git a/llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll b/llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll
index e9886c39c4d5..0d2a655cebac 100644
--- a/llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll
+++ b/llvm/test/Analysis/ScalarEvolution/predicated-trip-count.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@@ -17,35 +18,45 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; throughout the execution of the loop. The resulting predicated
; backedge taken count is correct.
-; CHECK: Classifying expressions for: @test1
-; CHECK: %i.0.ext = sext i16 %i.0 to i32
-; CHECK-NEXT: --> (sext i16 {0,+,1}<%bb3> to i32)
-; CHECK: Loop %bb3: Unpredictable backedge-taken count.
-; CHECK-NEXT: Loop %bb3: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is (1 + (-1 smax %M))
-; CHECK-NEXT: Predicates:
-; CHECK-NEXT: {0,+,1}<%bb3> Added Flags: <nssw>
define void @test1(i32 %N, i32 %M) {
+; CHECK-LABEL: 'test1'
+; CHECK-NEXT: Classifying expressions for: @test1
+; CHECK-NEXT: %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0
+; CHECK-NEXT: --> ((4 * (sext i16 {0,+,1}<%bb3> to i64))<nsw> + @A) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %tmp2 = add i16 %i.0, 1
+; CHECK-NEXT: --> {1,+,1}<%bb3> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %i.0 = phi i16 [ 0, %entry ], [ %tmp2, %bb ]
+; CHECK-NEXT: --> {0,+,1}<%bb3> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %i.0.ext = sext i16 %i.0 to i32
+; CHECK-NEXT: --> (sext i16 {0,+,1}<%bb3> to i32) U: [-32768,32768) S: [-32768,32768) Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test1
+; CHECK-NEXT: Loop %bb3: Unpredictable backedge-taken count.
+; CHECK-NEXT: Loop %bb3: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %bb3: Unpredictable symbolic max backedge-taken count.
+; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is (1 + (-1 smax %M))
+; CHECK-NEXT: Predicates:
+; CHECK-NEXT: {0,+,1}<%bb3> Added Flags: <nssw>
+;
entry:
- br label %bb3
+ br label %bb3
bb: ; preds = %bb3
- %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0 ; <i32*> [#uses=1]
- store i32 123, i32* %tmp
- %tmp2 = add i16 %i.0, 1 ; <i32> [#uses=1]
- br label %bb3
+ %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0 ; <i32*> [#uses=1]
+ store i32 123, i32* %tmp
+ %tmp2 = add i16 %i.0, 1 ; <i32> [#uses=1]
+ br label %bb3
bb3: ; preds = %bb, %entry
- %i.0 = phi i16 [ 0, %entry ], [ %tmp2, %bb ] ; <i32> [#uses=3]
- %i.0.ext = sext i16 %i.0 to i32
- %tmp3 = icmp sle i32 %i.0.ext, %M ; <i1> [#uses=1]
- br i1 %tmp3, label %bb, label %bb5
+ %i.0 = phi i16 [ 0, %entry ], [ %tmp2, %bb ] ; <i32> [#uses=3]
+ %i.0.ext = sext i16 %i.0 to i32
+ %tmp3 = icmp sle i32 %i.0.ext, %M ; <i1> [#uses=1]
+ br i1 %tmp3, label %bb, label %bb5
bb5: ; preds = %bb3
- br label %return
+ br label %return
return: ; preds = %bb5
- ret void
+ ret void
}
; The predicated backedge taken count is:
@@ -74,36 +85,44 @@ return: ; preds = %bb5
; we still have an infinite loop, since icmp sge %x, MIN_INT will always return
; true.
-; CHECK: Classifying expressions for: @test2
-
-; CHECK: %i.0.ext = sext i16 %i.0 to i32
-; CHECK-NEXT: --> (sext i16 {%Start,+,-1}<%bb3> to i32)
-; CHECK: Loop %bb3: Unpredictable backedge-taken count.
+define void @test2(i32 %N, i32 %M, i16 %Start) {
+; CHECK-LABEL: 'test2'
+; CHECK-NEXT: Classifying expressions for: @test2
+; CHECK-NEXT: %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0
+; CHECK-NEXT: --> ((4 * (sext i16 {%Start,+,-1}<%bb3> to i64))<nsw> + @A) U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %tmp2 = sub i16 %i.0, 1
+; CHECK-NEXT: --> {(-1 + %Start),+,-1}<%bb3> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %i.0 = phi i16 [ %Start, %entry ], [ %tmp2, %bb ]
+; CHECK-NEXT: --> {%Start,+,-1}<%bb3> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: %i.0.ext = sext i16 %i.0 to i32
+; CHECK-NEXT: --> (sext i16 {%Start,+,-1}<%bb3> to i32) U: [-32768,32768) S: [-32768,32768) Exits: <<Unknown>> LoopDispositions: { %bb3: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test2
+; CHECK-NEXT: Loop %bb3: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb3: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %bb3: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is (1 + (sext i16 %Start to i32) + (-1 * ((1 + (sext i16 %Start to i32))<nsw> smin %M)))
-; CHECK-NEXT: Predicates:
+; CHECK-NEXT: Predicates:
; CHECK-NEXT: {%Start,+,-1}<%bb3> Added Flags: <nssw>
-
-define void @test2(i32 %N, i32 %M, i16 %Start) {
+;
entry:
- br label %bb3
+ br label %bb3
bb: ; preds = %bb3
- %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0 ; <i32*> [#uses=1]
- store i32 123, i32* %tmp
- %tmp2 = sub i16 %i.0, 1 ; <i32> [#uses=1]
- br label %bb3
+ %tmp = getelementptr [1000 x i32], [1000 x i32]* @A, i32 0, i16 %i.0 ; <i32*> [#uses=1]
+ store i32 123, i32* %tmp
+ %tmp2 = sub i16 %i.0, 1 ; <i32> [#uses=1]
+ br label %bb3
bb3: ; preds = %bb, %entry
- %i.0 = phi i16 [ %Start, %entry ], [ %tmp2, %bb ] ; <i32> [#uses=3]
- %i.0.ext = sext i16 %i.0 to i32
- %tmp3 = icmp sge i32 %i.0.ext, %M ; <i1> [#uses=1]
- br i1 %tmp3, label %bb, label %bb5
+ %i.0 = phi i16 [ %Start, %entry ], [ %tmp2, %bb ] ; <i32> [#uses=3]
+ %i.0.ext = sext i16 %i.0 to i32
+ %tmp3 = icmp sge i32 %i.0.ext, %M ; <i1> [#uses=1]
+ br i1 %tmp3, label %bb, label %bb5
bb5: ; preds = %bb3
- br label %return
+ br label %return
return: ; preds = %bb5
- ret void
+ ret void
}
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
index 07ab3c0e1604..4702f02bb958 100644
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
@@ -24,6 +24,7 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'trunc_ptr_to_i64'
@@ -41,6 +42,7 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'trunc_ptr_to_i64'
@@ -58,6 +60,7 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'trunc_ptr_to_i64'
@@ -75,6 +78,7 @@ define hidden i32* @trunc_ptr_to_i64(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i64
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
bb:
@@ -111,6 +115,7 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i32
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'trunc_ptr_to_i32'
@@ -128,6 +133,7 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i32
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'trunc_ptr_to_i32'
@@ -145,6 +151,7 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @trunc_ptr_to_i32
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'trunc_ptr_to_i32'
@@ -162,6 +169,7 @@ define hidden i32* @trunc_ptr_to_i32(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i32
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
bb:
@@ -198,6 +206,7 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'trunc_ptr_to_i128'
@@ -215,6 +224,7 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'trunc_ptr_to_i128'
@@ -232,6 +242,7 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'trunc_ptr_to_i128'
@@ -249,6 +260,7 @@ define hidden i32* @trunc_ptr_to_i128(i8* %arg, i32* %arg10) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @trunc_ptr_to_i128
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable constant max backedge-taken count.
+; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb11: Unpredictable predicated backedge-taken count.
;
bb:
@@ -280,6 +292,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'zext_ptr_to_i32'
@@ -291,6 +304,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'zext_ptr_to_i32'
@@ -302,6 +316,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'zext_ptr_to_i32'
@@ -313,6 +328,7 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @zext_ptr_to_i32
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
bb:
@@ -339,6 +355,7 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX64-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR64_IDX32-LABEL: 'sext_to_i32'
@@ -350,6 +367,7 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR64_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX16-LABEL: 'sext_to_i32'
@@ -361,6 +379,7 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX16-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
; PTR16_IDX32-LABEL: 'sext_to_i32'
@@ -372,6 +391,7 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @sext_to_i32
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable constant max backedge-taken count.
+; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable symbolic max backedge-taken count.
; PTR16_IDX32-NEXT: Loop %bb7: Unpredictable predicated backedge-taken count.
;
bb:
@@ -402,6 +422,7 @@ define i64 @sext_like_noop(i32 %n) {
; PTR64_IDX64-NEXT: Determining loop execution counts for: @sext_like_noop
; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (trunc i64 (ptrtoint i64 (i32)* @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Predicates:
; PTR64_IDX64: Loop %for.body: Trip multiple is 1
@@ -419,6 +440,7 @@ define i64 @sext_like_noop(i32 %n) {
; PTR64_IDX32-NEXT: Determining loop execution counts for: @sext_like_noop
; PTR64_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; PTR64_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Predicates:
; PTR64_IDX32: Loop %for.body: Trip multiple is 1
@@ -436,6 +458,7 @@ define i64 @sext_like_noop(i32 %n) {
; PTR16_IDX16-NEXT: Determining loop execution counts for: @sext_like_noop
; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint i64 (i32)* @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Predicates:
; PTR16_IDX16: Loop %for.body: Trip multiple is 1
@@ -453,6 +476,7 @@ define i64 @sext_like_noop(i32 %n) {
; PTR16_IDX32-NEXT: Determining loop execution counts for: @sext_like_noop
; PTR16_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
; PTR16_IDX32-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; PTR16_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
; PTR16_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (i64 (i32)* @sext_like_noop to i32))<nsw>
; PTR16_IDX32-NEXT: Predicates:
; PTR16_IDX32: Loop %for.body: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
index b647da817c55..fec5b6320e5b 100644
--- a/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
@@ -230,6 +230,7 @@ define void @ptrtoint_of_addrec(i32* %in, i32 %count) {
; X64-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec
; X64-NEXT: Loop %loop: backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X64-NEXT: Loop %loop: constant max backedge-taken count is -1
+; X64-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X64-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X64-NEXT: Predicates:
; X64: Loop %loop: Trip multiple is 1
@@ -249,6 +250,7 @@ define void @ptrtoint_of_addrec(i32* %in, i32 %count) {
; X32-NEXT: Determining loop execution counts for: @ptrtoint_of_addrec
; X32-NEXT: Loop %loop: backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X32-NEXT: Loop %loop: constant max backedge-taken count is -1
+; X32-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X32-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (zext i32 %count to i64))<nsw>
; X32-NEXT: Predicates:
; X32: Loop %loop: Trip multiple is 1
@@ -396,6 +398,7 @@ define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) {
; X64-NEXT: Determining loop execution counts for: @pr46786_c26_char
; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64))
; X64-NEXT: Loop %bb6: constant max backedge-taken count is -1
+; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64))
; X64-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i64)) + (ptrtoint i8* %arg1 to i64))
; X64-NEXT: Predicates:
; X64: Loop %bb6: Trip multiple is 1
@@ -423,6 +426,7 @@ define void @pr46786_c26_char(i8* %arg, i8* %arg1, i8* %arg2) {
; X32-NEXT: Determining loop execution counts for: @pr46786_c26_char
; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32))
; X32-NEXT: Loop %bb6: constant max backedge-taken count is -1
+; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32))
; X32-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint i8* %arg to i32)) + (ptrtoint i8* %arg1 to i32))
; X32-NEXT: Predicates:
; X32: Loop %bb6: Trip multiple is 1
@@ -483,6 +487,7 @@ define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) {
; X64-NEXT: Determining loop execution counts for: @pr46786_c26_int
; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)
; X64-NEXT: Loop %bb6: constant max backedge-taken count is 4611686018427387903
+; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)
; X64-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i64)) + (ptrtoint i32* %arg1 to i64)) /u 4)
; X64-NEXT: Predicates:
; X64: Loop %bb6: Trip multiple is 1
@@ -512,6 +517,7 @@ define void @pr46786_c26_int(i32* %arg, i32* %arg1, i32* %arg2) {
; X32-NEXT: Determining loop execution counts for: @pr46786_c26_int
; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)
; X32-NEXT: Loop %bb6: constant max backedge-taken count is 1073741823
+; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)
; X32-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint i32* %arg to i32)) + (ptrtoint i32* %arg1 to i32)) /u 4)
; X32-NEXT: Predicates:
; X32: Loop %bb6: Trip multiple is 1
@@ -559,7 +565,9 @@ define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_ad
; X64-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
; X64-NEXT: exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64))
; X64-NEXT: Loop %bb8: constant max backedge-taken count is -1
-; X64-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
+; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64)) symbolic max exit count for bb8: ***COULDNOTCOMPUTE***
+; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint i8* %arg to i64))
+; X64: Loop %bb8: Unpredictable predicated backedge-taken count.
;
; X32-LABEL: 'ptrtoint_of_integer'
; X32-NEXT: Classifying expressions for: @ptrtoint_of_integer
@@ -576,7 +584,9 @@ define void @ptrtoint_of_integer(i8* %arg, i64 %arg1, i1 %arg2) local_unnamed_ad
; X32-NEXT: exit count for bb8: ***COULDNOTCOMPUTE***
; X32-NEXT: exit count for bb10: (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1))
; X32-NEXT: Loop %bb8: constant max backedge-taken count is -1
-; X32-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
+; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1)) symbolic max exit count for bb8: ***COULDNOTCOMPUTE***
+; X32-NEXT: symbolic max exit count for bb10: (-2 + (zext i32 (ptrtoint i8* %arg to i32) to i64) + (-1 * %arg1))
+; X32: Loop %bb8: Unpredictable predicated backedge-taken count.
;
bb:
%i = icmp eq i8* %arg, null
diff --git a/llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll b/llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll
index 455a9bf231b9..4d32876de089 100644
--- a/llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll
+++ b/llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll
@@ -16,6 +16,7 @@ define void @test-add-nuw(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-add-nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -51,6 +52,7 @@ define void @test-addrec-nuw(float* %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Determining loop execution counts for: @test-addrec-nuw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -88,6 +90,7 @@ define void @test-addrec-nsw-start-neg-strip-neg(float* %input, i32 %offset, i32
; CHECK-NEXT: Determining loop execution counts for: @test-addrec-nsw-start-neg-strip-neg
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -125,6 +128,7 @@ define void @test-addrec-nsw-start-pos-strip-neg(float* %input, i32 %offset, i32
; CHECK-NEXT: Determining loop execution counts for: @test-addrec-nsw-start-pos-strip-neg
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -162,6 +166,7 @@ define void @test-addrec-nsw-start-pos-strip-pos(float* %input, i32 %offset, i32
; CHECK-NEXT: Determining loop execution counts for: @test-addrec-nsw-start-pos-strip-pos
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -199,6 +204,7 @@ define void @test-addrec-nsw-start-neg-strip-pos(float* %input, i32 %offset, i32
; CHECK-NEXT: Determining loop execution counts for: @test-addrec-nsw-start-neg-strip-pos
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/ranges.ll b/llvm/test/Analysis/ScalarEvolution/ranges.ll
index f7bfbdd2b02f..ab307000dd59 100644
--- a/llvm/test/Analysis/ScalarEvolution/ranges.ll
+++ b/llvm/test/Analysis/ScalarEvolution/ranges.ll
@@ -115,6 +115,7 @@ define i32 @phi_div() {
; CHECK-NEXT: Determining loop execution counts for: @phi_div
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/sdiv.ll b/llvm/test/Analysis/ScalarEvolution/sdiv.ll
index 9f3562bbd819..157b41c83193 100644
--- a/llvm/test/Analysis/ScalarEvolution/sdiv.ll
+++ b/llvm/test/Analysis/ScalarEvolution/sdiv.ll
@@ -32,6 +32,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-NEXT: Determining loop execution counts for: @_Z4loopi
; CHECK-NEXT: Loop %for.cond: backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.cond: symbolic max backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: Predicated backedge-taken count is %width
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.cond: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/sext-mul.ll b/llvm/test/Analysis/ScalarEvolution/sext-mul.ll
index 524cc70ba6a2..a3455aa1cac9 100644
--- a/llvm/test/Analysis/ScalarEvolution/sext-mul.ll
+++ b/llvm/test/Analysis/ScalarEvolution/sext-mul.ll
@@ -1,20 +1,41 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
-; CHECK: %tmp9 = shl i64 %tmp8, 33
-; CHECK-NEXT: --> {{.*}} Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64)))
-; CHECK: %tmp10 = ashr exact i64 %tmp9, 32
-; CHECK-NEXT: --> {{.*}} Exits: (sext i32 (-2 + (2 * %arg2)) to i64)
-; CHECK: %tmp11 = getelementptr inbounds i32, i32* %arg, i64 %tmp10
-; CHECK-NEXT: --> {{.*}} Exits: ((4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg)
-; CHECK: %tmp14 = or i64 %tmp10, 1
-; CHECK-NEXT: --> {{.*}} Exits: (1 + (sext i32 (-2 + (2 * %arg2)) to i64))<nuw><nsw>
-; CHECK: %tmp15 = getelementptr inbounds i32, i32* %arg, i64 %tmp14
-; CHECK-NEXT: --> {{.*}} Exits: (4 + (4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg)
-; CHECK:Loop %bb7: backedge-taken count is (-1 + (zext i32 %arg2 to i64))<nsw>
-; CHECK-NEXT:Loop %bb7: constant max backedge-taken count is 2147483646
-; CHECK-NEXT:Loop %bb7: Predicated backedge-taken count is (-1 + (zext i32 %arg2 to i64))<nsw>
-
define void @foo(i32* nocapture %arg, i32 %arg1, i32 %arg2) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT: Classifying expressions for: @foo
+; CHECK-NEXT: %tmp4 = zext i32 %arg2 to i64
+; CHECK-NEXT: --> (zext i32 %arg2 to i64) U: [0,4294967296) S: [0,4294967296)
+; CHECK-NEXT: %tmp8 = phi i64 [ %tmp18, %bb7 ], [ 0, %bb3 ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%bb7> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + (zext i32 %arg2 to i64))<nsw> LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp9 = shl i64 %tmp8, 33
+; CHECK-NEXT: --> {0,+,8589934592}<nuw><%bb7> U: [0,-17179869183) S: [-9223372036854775808,9223372028264841217) Exits: (-8589934592 + (8589934592 * (zext i32 %arg2 to i64))) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp10 = ashr exact i64 %tmp9, 32
+; CHECK-NEXT: --> (sext i32 {0,+,2}<%bb7> to i64) U: [0,-1) S: [-2147483648,2147483647) Exits: (sext i32 (-2 + (2 * %arg2)) to i64) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp11 = getelementptr inbounds i32, i32* %arg, i64 %tmp10
+; CHECK-NEXT: --> ((4 * (sext i32 {0,+,2}<%bb7> to i64))<nsw> + %arg) U: full-set S: full-set Exits: ((4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp12 = load i32, i32* %tmp11, align 4
+; CHECK-NEXT: --> %tmp12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %tmp13 = sub nsw i32 %tmp12, %arg1
+; CHECK-NEXT: --> ((-1 * %arg1) + %tmp12) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %tmp14 = or i64 %tmp10, 1
+; CHECK-NEXT: --> (1 + (sext i32 {0,+,2}<%bb7> to i64))<nuw><nsw> U: [1,0) S: [-2147483647,2147483648) Exits: (1 + (sext i32 (-2 + (2 * %arg2)) to i64))<nuw><nsw> LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp15 = getelementptr inbounds i32, i32* %arg, i64 %tmp14
+; CHECK-NEXT: --> (4 + (4 * (sext i32 {0,+,2}<%bb7> to i64))<nsw> + %arg) U: full-set S: full-set Exits: (4 + (4 * (sext i32 (-2 + (2 * %arg2)) to i64))<nsw> + %arg) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %tmp16 = load i32, i32* %tmp15, align 4
+; CHECK-NEXT: --> %tmp16 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %tmp17 = mul nsw i32 %tmp16, %arg1
+; CHECK-NEXT: --> (%arg1 * %tmp16) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %tmp18 = add nuw nsw i64 %tmp8, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%bb7> U: [1,2147483648) S: [1,2147483648) Exits: (zext i32 %arg2 to i64) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @foo
+; CHECK-NEXT: Loop %bb7: backedge-taken count is (-1 + (zext i32 %arg2 to i64))<nsw>
+; CHECK-NEXT: Loop %bb7: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %bb7: symbolic max backedge-taken count is (-1 + (zext i32 %arg2 to i64))<nsw>
+; CHECK-NEXT: Loop %bb7: Predicated backedge-taken count is (-1 + (zext i32 %arg2 to i64))<nsw>
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %bb7: Trip multiple is 1
+;
bb:
%tmp = icmp sgt i32 %arg2, 0
br i1 %tmp, label %bb3, label %bb6
@@ -47,15 +68,41 @@ bb7: ; preds = %bb7, %bb3
br i1 %tmp19, label %bb5, label %bb7
}
-; CHECK: %t10 = ashr exact i128 %t9, 1
-; CHECK-NEXT: --> {{.*}} Exits: (sext i127 (-633825300114114700748351602688 + (633825300114114700748351602688 * (zext i32 %arg5 to i127))) to i128)
-; CHECK: %t14 = or i128 %t10, 1
-; CHECK-NEXT: --> {{.*}} Exits: (1 + (sext i127 (-633825300114114700748351602688 + (633825300114114700748351602688 * (zext i32 %arg5 to i127))) to i128))<nuw><nsw>
-; CHECK: Loop %bb7: backedge-taken count is (-1 + (zext i32 %arg5 to i128))<nsw>
-; CHECK-NEXT: Loop %bb7: constant max backedge-taken count is 2147483646
-; CHECK-NEXT: Loop %bb7: Predicated backedge-taken count is (-1 + (zext i32 %arg5 to i128))<nsw>
-
define void @goo(i32* nocapture %arg3, i32 %arg4, i32 %arg5) {
+; CHECK-LABEL: 'goo'
+; CHECK-NEXT: Classifying expressions for: @goo
+; CHECK-NEXT: %t4 = zext i32 %arg5 to i128
+; CHECK-NEXT: --> (zext i32 %arg5 to i128) U: [0,4294967296) S: [0,4294967296)
+; CHECK-NEXT: %t8 = phi i128 [ %t18, %bb7 ], [ 0, %bb3 ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%bb7> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + (zext i32 %arg5 to i128))<nsw> LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %t9 = shl i128 %t8, 100
+; CHECK-NEXT: --> {0,+,1267650600228229401496703205376}<%bb7> U: [0,-1267650600228229401496703205375) S: [-170141183460469231731687303715884105728,170141182192818631503457902219180900353) Exits: (-1267650600228229401496703205376 + (1267650600228229401496703205376 * (zext i32 %arg5 to i128))) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %t10 = ashr exact i128 %t9, 1
+; CHECK-NEXT: --> (sext i127 {0,+,633825300114114700748351602688}<%bb7> to i128) U: [0,-633825300114114700748351602687) S: [-85070591730234615865843651857942052864,85070591096409315751728951109590450177) Exits: (sext i127 (-633825300114114700748351602688 + (633825300114114700748351602688 * (zext i32 %arg5 to i127))) to i128) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %t11 = getelementptr inbounds i32, i32* %arg3, i128 %t10
+; CHECK-NEXT: --> %arg3 U: full-set S: full-set Exits: %arg3 LoopDispositions: { %bb7: Invariant }
+; CHECK-NEXT: %t12 = load i32, i32* %t11, align 4
+; CHECK-NEXT: --> %t12 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %t13 = sub nsw i32 %t12, %arg4
+; CHECK-NEXT: --> ((-1 * %arg4) + %t12) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %t14 = or i128 %t10, 1
+; CHECK-NEXT: --> (1 + (sext i127 {0,+,633825300114114700748351602688}<%bb7> to i128))<nuw><nsw> U: [1,-633825300114114700748351602686) S: [-85070591730234615865843651857942052863,85070591096409315751728951109590450178) Exits: (1 + (sext i127 (-633825300114114700748351602688 + (633825300114114700748351602688 * (zext i32 %arg5 to i127))) to i128))<nuw><nsw> LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: %t15 = getelementptr inbounds i32, i32* %arg3, i128 %t14
+; CHECK-NEXT: --> (4 + %arg3)<nuw> U: [4,0) S: [4,0) Exits: (4 + %arg3)<nuw> LoopDispositions: { %bb7: Invariant }
+; CHECK-NEXT: %t16 = load i32, i32* %t15, align 4
+; CHECK-NEXT: --> %t16 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %t17 = mul nsw i32 %t16, %arg4
+; CHECK-NEXT: --> (%arg4 * %t16) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %bb7: Variant }
+; CHECK-NEXT: %t18 = add nuw nsw i128 %t8, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%bb7> U: [1,2147483648) S: [1,2147483648) Exits: (zext i32 %arg5 to i128) LoopDispositions: { %bb7: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @goo
+; CHECK-NEXT: Loop %bb7: backedge-taken count is (-1 + (zext i32 %arg5 to i128))<nsw>
+; CHECK-NEXT: Loop %bb7: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %bb7: symbolic max backedge-taken count is (-1 + (zext i32 %arg5 to i128))<nsw>
+; CHECK-NEXT: Loop %bb7: Predicated backedge-taken count is (-1 + (zext i32 %arg5 to i128))<nsw>
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %bb7: Trip multiple is 1
+;
bb:
%t = icmp sgt i32 %arg5, 0
br i1 %t, label %bb3, label %bb6
diff --git a/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll b/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
index a0409b0e1c25..645bc23f2e39 100644
--- a/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
+++ b/llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
@@ -21,6 +21,7 @@ define void @f(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @f
; CHECK-NEXT: Loop %loop: backedge-taken count is 99
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 99
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 99
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 99
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 100
diff --git a/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll b/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
index b9bebff28146..b1cdd3b062fa 100644
--- a/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
+++ b/llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
@@ -11,6 +11,7 @@ define void @test_lshr() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -34,6 +35,7 @@ define void @test_lshr2() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -57,6 +59,7 @@ define void @test_ashr_zeros() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_zeros
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -79,6 +82,7 @@ define void @test_ashr_ones() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_ones
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -102,6 +106,7 @@ define void @test_ashr_ones2() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_ones2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -126,6 +131,7 @@ define void @test_ashr_unknown(i64 %start) {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_unknown
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -150,6 +156,7 @@ define void @test_ashr_wrong_op(i64 %start) {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_wrong_op
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -173,6 +180,7 @@ define void @test_shl() {
; CHECK-NEXT: Determining loop execution counts for: @test_shl
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -200,6 +208,7 @@ define void @test_shl2() {
; CHECK-NEXT: Determining loop execution counts for: @test_shl2
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -234,6 +243,7 @@ define void @test_shl3(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @test_shl3
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -267,6 +277,7 @@ define void @test_shl4() {
; CHECK-NEXT: Determining loop execution counts for: @test_shl4
; CHECK-NEXT: Loop %loop: backedge-taken count is 60
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 60
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 60
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 60
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 61
@@ -299,6 +310,7 @@ define void @test_shl5() {
; CHECK-NEXT: Determining loop execution counts for: @test_shl5
; CHECK-NEXT: Loop %loop: backedge-taken count is 61
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 61
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 61
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 61
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 62
@@ -333,6 +345,7 @@ define void @test_shl6(i1 %c) {
; CHECK-NEXT: Determining loop execution counts for: @test_shl6
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -366,6 +379,7 @@ define void @test_shl7(i1 %c, i64 %shiftamt) {
; CHECK-NEXT: Determining loop execution counts for: @test_shl7
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -419,6 +433,7 @@ define void @unreachable_binop() {
; CHECK-NEXT: Determining loop execution counts for: @unreachable_binop
; CHECK-NEXT: Loop %header: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %header: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %header: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %header: Unpredictable predicated backedge-taken count.
;
entry:
@@ -476,6 +491,7 @@ define void @nonloop_recurrence_2() {
; CHECK-NEXT: Determining loop execution counts for: @nonloop_recurrence_2
; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
bb:
@@ -510,6 +526,7 @@ define void @test_ashr_tc_positive() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_positive
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -541,6 +558,7 @@ define void @test_ashr_tc_negative() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_negative
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -574,6 +592,7 @@ define void @test_ashr_tc_either(i1 %a) {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_either
; CHECK-NEXT: Loop %loop: backedge-taken count is 60
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 60
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 60
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 60
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 61
@@ -606,6 +625,7 @@ define void @test_ashr_zero_shift() {
; CHECK-NEXT: Determining loop execution counts for: @test_ashr_zero_shift
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -637,6 +657,7 @@ define void @test_lshr_tc_positive() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_positive
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -668,6 +689,7 @@ define void @test_lshr_tc_negative() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_negative
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -701,6 +723,7 @@ define void @test_lshr_tc_either(i1 %a) {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_either
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -733,6 +756,7 @@ define void @test_lshr_zero_shift() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_zero_shift
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -765,6 +789,7 @@ define void @test_lshr_power_of_2_start() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_power_of_2_start
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -797,6 +822,7 @@ define void @test_lshr_arbitrary_start() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_arbitrary_start
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
@@ -828,6 +854,7 @@ define void @test_lshr_start_power_of_2_plus_one() {
; CHECK-NEXT: Determining loop execution counts for: @test_lshr_start_power_of_2_plus_one
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 5
diff --git a/llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll b/llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll
index 559306f41b70..57395a6a6cc2 100644
--- a/llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll
+++ b/llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll
@@ -6,9 +6,13 @@
; Test case from PR1614.
define i32 @test_PR1614(i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: 'test_PR1614'
-; CHECK: --> (%a smax %b)
-; CHECK: --> (%a smax %b smax %c)
-; CHECK-NOT: smax
+; CHECK-NEXT: Classifying expressions for: @test_PR1614
+; CHECK-NEXT: %B = select i1 %A, i32 %a, i32 %b
+; CHECK-NEXT: --> (%a smax %b) U: full-set S: full-set
+; CHECK-NEXT: %D = select i1 %C, i32 %B, i32 %c
+; CHECK-NEXT: --> (%a smax %b smax %c) U: full-set S: full-set
+; CHECK-NEXT: Determining loop execution counts for: @test_PR1614
+;
%A = icmp sgt i32 %a, %b
%B = select i1 %A, i32 %a, i32 %b
@@ -31,6 +35,7 @@ define void @smin_simplify_with_guard(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @smin_simplify_with_guard
; CHECK-NEXT: Loop %for.body: backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -58,7 +63,6 @@ for.cond.cleanup:
define void @smin_to_smax(i32 %n) {
; FIXME: ((-1 * (0 smin %n)) + %n) is actually just (0 smax %n)
-
; CHECK-LABEL: 'smin_to_smax'
; CHECK-NEXT: Classifying expressions for: @smin_to_smax
; CHECK-NEXT: %i.011 = phi i32 [ %n, %for.body.lr.ph ], [ %dec, %for.body ]
@@ -68,6 +72,7 @@ define void @smin_to_smax(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @smin_to_smax
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-1 * (0 smin %n)) + %n)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483647
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-1 * (0 smin %n)) + %n)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-1 * (0 smin %n)) + %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -94,18 +99,20 @@ for.cond.cleanup:
; The information from the loop guard can be used to simplify the trip count expression.
define void @smax_simplify_with_guard(i32 %start, i32 %n) {
-; CHECK-LABEL: 'smax_simplify_with_guard'
+; CHECK-LABEL: 'smax_simplify_with_guard'
; CHECK-NEXT: Classifying expressions for: @smax_simplify_with_guard
; CHECK-NEXT: %k.0.i26 = phi i32 [ %start, %loop.ph ], [ %inc.i, %loop ]
-; CHECK-NEXT: --> {%start,+,1}<nsw><%loop> U: full-set S: full-set Exits: %n LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {%start,+,1}<nsw><%loop> U: full-set S: full-set Exits: %n LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %inc.i = add nsw i32 %k.0.i26, 1
-; CHECK-NEXT: --> {(1 + %start),+,1}<nw><%loop> U: full-set S: full-set Exits: (1 + %n) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: --> {(1 + %start),+,1}<nw><%loop> U: full-set S: full-set Exits: (1 + %n) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @smax_simplify_with_guard
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 * %start) + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
-; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 * %start) + %n)
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 * %start) + %n)
+; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 * %start) + %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
+;
entry:
%guard = icmp sge i32 %n, %start
br i1 %guard, label %loop.ph, label %exit
diff --git a/llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll b/llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll
index b104766b4004..a21ed0bfdb21 100644
--- a/llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll
+++ b/llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll
@@ -19,6 +19,7 @@ define void @f0() {
; CHECK-NEXT: Determining loop execution counts for: @f0
; CHECK-NEXT: Loop %b1: backedge-taken count is 1
; CHECK-NEXT: Loop %b1: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %b1: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %b1: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %b1: Trip multiple is 2
@@ -65,9 +66,11 @@ define void @f1() #0 {
; CHECK-NEXT: Determining loop execution counts for: @f1
; CHECK-NEXT: Loop %b3: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %b3: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %b3: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %b3: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %b1: backedge-taken count is 2
; CHECK-NEXT: Loop %b1: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %b1: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %b1: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
; CHECK: Loop %b1: Trip multiple is 3
diff --git a/llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll b/llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll
index 6bd197e9bb9f..9af15ab823a0 100644
--- a/llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll
+++ b/llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll
@@ -1,35 +1,35 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -disable-output "-passes=print<scalar-evolution>" -S < %s 2>&1 | FileCheck %s
; The exit value from this loop was originally calculated as 0.
; The actual exit condition is 256*256 == 0 (in i16).
-; CHECK: Printing analysis 'Scalar Evolution Analysis' for function 'f0':
-; CHECK-NEXT: Classifying expressions for: @f0
-; CHECK-NEXT: %v1 = phi i16 [ 0, %b0 ], [ %v2, %b1 ]
-; CHECK-NEXT: --> {0,+,-1}<%b1> U: [-255,1) S: [-255,1) Exits: -255 LoopDispositions: { %b1: Computable }
-; CHECK-NEXT: %v2 = add i16 %v1, -1
-; CHECK-NEXT: --> {-1,+,-1}<%b1> U: [-256,0) S: [-256,0) Exits: -256 LoopDispositions: { %b1: Computable }
-; CHECK-NEXT: %v3 = mul i16 %v2, %v2
-; CHECK-NEXT: --> {1,+,3,+,2}<%b1> U: full-set S: full-set Exits: 0 LoopDispositions: { %b1: Computable }
-; CHECK-NEXT: %v5 = phi i16 [ %v2, %b1 ]
-; CHECK-NEXT: --> {-1,+,-1}<%b1> U: [-256,0) S: [-256,0) --> -256 U: [-256,-255) S: [-256,-255)
-; CHECK-NEXT: %v6 = phi i16 [ %v3, %b1 ]
-; CHECK-NEXT: --> {1,+,3,+,2}<%b1> U: full-set S: full-set --> 0 U: [0,1) S: [0,1)
-; CHECK-NEXT: %v7 = sext i16 %v5 to i32
-; CHECK-NEXT: --> {-1,+,-1}<nsw><%b1> U: [-256,0) S: [-256,0) --> -256 U: [-256,-255) S: [-256,-255)
-; CHECK-NEXT: Determining loop execution counts for: @f0
-; CHECK-NEXT: Loop %b1: backedge-taken count is 255
-; CHECK-NEXT: Loop %b1: constant max backedge-taken count is 255
-; CHECK-NEXT: Loop %b1: Predicated backedge-taken count is 255
-; CHECK-NEXT: Predicates:
-; CHECK-EMPTY:
-; CHECK-NEXT: Loop %b1: Trip multiple is 256
-
-
@g0 = global i32 0, align 4
@g1 = global i16 0, align 2
define signext i32 @f0() {
+; CHECK-LABEL: 'f0'
+; CHECK-NEXT: Classifying expressions for: @f0
+; CHECK-NEXT: %v1 = phi i16 [ 0, %b0 ], [ %v2, %b1 ]
+; CHECK-NEXT: --> {0,+,-1}<%b1> U: [-255,1) S: [-255,1) Exits: -255 LoopDispositions: { %b1: Computable }
+; CHECK-NEXT: %v2 = add i16 %v1, -1
+; CHECK-NEXT: --> {-1,+,-1}<%b1> U: [-256,0) S: [-256,0) Exits: -256 LoopDispositions: { %b1: Computable }
+; CHECK-NEXT: %v3 = mul i16 %v2, %v2
+; CHECK-NEXT: --> {1,+,3,+,2}<%b1> U: full-set S: full-set Exits: 0 LoopDispositions: { %b1: Computable }
+; CHECK-NEXT: %v5 = phi i16 [ %v2, %b1 ]
+; CHECK-NEXT: --> {-1,+,-1}<%b1> U: [-256,0) S: [-256,0) --> -256 U: [-256,-255) S: [-256,-255)
+; CHECK-NEXT: %v6 = phi i16 [ %v3, %b1 ]
+; CHECK-NEXT: --> {1,+,3,+,2}<%b1> U: full-set S: full-set --> 0 U: [0,1) S: [0,1)
+; CHECK-NEXT: %v7 = sext i16 %v5 to i32
+; CHECK-NEXT: --> {-1,+,-1}<nsw><%b1> U: [-256,0) S: [-256,0) --> -256 U: [-256,-255) S: [-256,-255)
+; CHECK-NEXT: Determining loop execution counts for: @f0
+; CHECK-NEXT: Loop %b1: backedge-taken count is 255
+; CHECK-NEXT: Loop %b1: constant max backedge-taken count is 255
+; CHECK-NEXT: Loop %b1: symbolic max backedge-taken count is 255
+; CHECK-NEXT: Loop %b1: Predicated backedge-taken count is 255
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %b1: Trip multiple is 256
+;
b0:
br label %b1
diff --git a/llvm/test/Analysis/ScalarEvolution/srem.ll b/llvm/test/Analysis/ScalarEvolution/srem.ll
index 0004d4d3cead..cc9bb7f9a723 100644
--- a/llvm/test/Analysis/ScalarEvolution/srem.ll
+++ b/llvm/test/Analysis/ScalarEvolution/srem.ll
@@ -32,6 +32,7 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-NEXT: Determining loop execution counts for: @_Z4loopi
; CHECK-NEXT: Loop %for.cond: backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.cond: symbolic max backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: Predicated backedge-taken count is %width
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.cond: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll
index 6dd14e6c5077..6cf57f5afbbb 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll
@@ -9,6 +9,7 @@ define void @unsimplified_and1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and1
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -32,6 +33,7 @@ define void @unsimplified_and2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and2
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -55,6 +57,7 @@ define void @unsimplified_and3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and3
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -78,6 +81,7 @@ define void @unsimplified_and4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and4
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -101,6 +105,7 @@ define void @unsimplified_or1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or1
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -122,6 +127,7 @@ define void @unsimplified_or2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -143,6 +149,7 @@ define void @unsimplified_or3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or3
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -166,6 +173,7 @@ define void @unsimplified_or4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or4
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -189,6 +197,7 @@ define void @reversed_and1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and1
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -212,6 +221,7 @@ define void @reversed_and2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and2
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -235,6 +245,7 @@ define void @reversed_and3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and3
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -256,6 +267,7 @@ define void @reversed_and4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and4
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -277,6 +289,7 @@ define void @reversed_or1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or1
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -300,6 +313,7 @@ define void @reversed_or2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or2
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -323,6 +337,7 @@ define void @reversed_or3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or3
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -346,6 +361,7 @@ define void @reversed_or4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or4
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll
index fa0aa36d43c8..bb91e842446b 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll
@@ -9,6 +9,7 @@ define void @unsimplified_and1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and1
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -32,6 +33,7 @@ define void @unsimplified_and2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and2
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -55,6 +57,7 @@ define void @unsimplified_and3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and3
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -78,6 +81,7 @@ define void @unsimplified_and4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_and4
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -101,6 +105,7 @@ define void @unsimplified_or1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or1
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -122,6 +127,7 @@ define void @unsimplified_or2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -143,6 +149,7 @@ define void @unsimplified_or3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or3
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -166,6 +173,7 @@ define void @unsimplified_or4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @unsimplified_or4
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -189,6 +197,7 @@ define void @reversed_and1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and1
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -212,6 +221,7 @@ define void @reversed_and2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and2
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -235,6 +245,7 @@ define void @reversed_and3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and3
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -256,6 +267,7 @@ define void @reversed_and4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_and4
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -277,6 +289,7 @@ define void @reversed_or1(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or1
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -300,6 +313,7 @@ define void @reversed_or2(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or2
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -323,6 +337,7 @@ define void @reversed_or3(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or3
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -346,6 +361,7 @@ define void @reversed_or4(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @reversed_or4
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll
index 1276c48f1c2c..dfbcd98ff465 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll
@@ -14,6 +14,7 @@ define void @nw_implies_nuw(i16 %n) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @nw_implies_nuw
; CHECK-NEXT: Loop %for.body: backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is %n
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -37,6 +38,7 @@ define void @neg_nw_nuw(i16 %n) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @neg_nw_nuw
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -58,6 +60,7 @@ define void @nw_implies_nsw(i16 %n) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @nw_implies_nsw
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (128 + (-128 smax %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {-128,+,1}<%for.body> Added Flags: <nssw>
@@ -81,6 +84,7 @@ define void @neg_nw_nsw(i16 %n) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @neg_nw_nsw
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -103,6 +107,7 @@ define void @actually_infinite() {
; CHECK-NEXT: Determining loop execution counts for: @actually_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 257
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {0,+,1}<%for.body> Added Flags: <nusw>
@@ -127,6 +132,7 @@ define void @rhs_mustexit_1(i16 %n.raw) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @rhs_mustexit_1
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax (-1 + (zext i8 (trunc i16 %n.raw to i8) to i16))<nsw>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {1,+,1}<nw><%for.body> Added Flags: <nusw>
@@ -153,6 +159,7 @@ define void @rhs_mustexit_3(i16 %n.raw) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @rhs_mustexit_3
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -178,6 +185,7 @@ define void @rhs_mustexit_nonzero_step(i16 %n.raw, i8 %step.raw) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @rhs_mustexit_nonzero_step
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -203,6 +211,7 @@ define void @neg_maybe_zero_step(i16 %n.raw, i8 %step) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @neg_maybe_zero_step
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -227,6 +236,7 @@ define void @neg_rhs_wrong_range(i16 %n.raw) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @neg_rhs_wrong_range
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-1 + (2 umax (-1 + (zext i8 (trunc i16 %n.raw to i8) to i16))<nsw>)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {2,+,2}<nw><%for.body> Added Flags: <nusw>
@@ -253,6 +263,7 @@ define void @neg_rhs_maybe_infinite(i16 %n.raw) {
; CHECK-NEXT: Determining loop execution counts for: @neg_rhs_maybe_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax (-1 + (zext i8 (trunc i16 %n.raw to i8) to i16))<nsw>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {1,+,1}<%for.body> Added Flags: <nusw>
@@ -281,6 +292,7 @@ define void @rhs_narrow_range(i16 %n.raw) {
; CHECK-NEXT: Determining loop execution counts for: @rhs_narrow_range
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 umax (2 * (zext i7 (trunc i16 (%n.raw /u 2) to i7) to i16))<nuw><nsw>))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 253
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (1 umax (2 * (zext i7 (trunc i16 (%n.raw /u 2) to i7) to i16))<nuw><nsw>))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax (2 * (zext i7 (trunc i16 (%n.raw /u 2) to i7) to i16))<nuw><nsw>))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -307,6 +319,7 @@ define void @ugt_constant_rhs(i16 %n.raw, i8 %start) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @ugt_constant_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -329,6 +342,7 @@ define void @ult_constant_rhs(i16 %n.raw, i8 %start) {
; CHECK-NEXT: Determining loop execution counts for: @ult_constant_rhs
; CHECK-NEXT: Loop %for.body: backedge-taken count is (255 + (-1 * (zext i8 (1 + %start) to i16))<nsw>)<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 255
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (255 + (-1 * (zext i8 (1 + %start) to i16))<nsw>)<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (255 + (-1 * (zext i8 (1 + %start) to i16))<nsw>)<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -353,6 +367,7 @@ define void @ult_constant_rhs_stride2(i16 %n.raw, i8 %start) {
; CHECK-NEXT: Determining loop execution counts for: @ult_constant_rhs_stride2
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((1 + (-1 * (zext i8 (2 + %start) to i16))<nsw> + (254 umax (zext i8 (2 + %start) to i16))) /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 127
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((1 + (-1 * (zext i8 (2 + %start) to i16))<nsw> + (254 umax (zext i8 (2 + %start) to i16))) /u 2)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((1 + (-1 * (zext i8 (2 + %start) to i16))<nsw> + (254 umax (zext i8 (2 + %start) to i16))) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -377,6 +392,7 @@ define void @ult_constant_rhs_stride2_neg(i16 %n.raw, i8 %start) {
; CHECK-NEXT: Determining loop execution counts for: @ult_constant_rhs_stride2_neg
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((256 + (-1 * (zext i8 (2 + %start) to i16))<nsw>)<nsw> /u 2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: {(2 + %start),+,2}<%for.body> Added Flags: <nusw>
@@ -401,6 +417,7 @@ define void @ult_restricted_rhs(i16 %n.raw) {
; CHECK-NEXT: Determining loop execution counts for: @ult_restricted_rhs
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 umax (zext i8 (trunc i16 %n.raw to i8) to i16)))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 254
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (1 umax (zext i8 (trunc i16 %n.raw to i8) to i16)))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax (zext i8 (trunc i16 %n.raw to i8) to i16)))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -425,6 +442,7 @@ define void @ult_guarded_rhs(i16 %n) {;
; CHECK-NEXT: Determining loop execution counts for: @ult_guarded_rhs
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 umax %n))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (1 umax %n))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
index 412d0b43732f..5a0f7f2a74b7 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
@@ -14,6 +14,7 @@ define void @ult_wrap() {
; CHECK-NEXT: Determining loop execution counts for: @ult_wrap
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -36,6 +37,7 @@ define void @ult_infinite() {
; CHECK-NEXT: Determining loop execution counts for: @ult_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -58,6 +60,7 @@ define void @ult_infinite_ub() mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @ult_infinite_ub
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
@@ -82,6 +85,7 @@ define void @ult_129_not_taken() {
; CHECK-NEXT: Determining loop execution counts for: @ult_129_not_taken
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -104,6 +108,7 @@ define void @ult_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @ult_129_unknown_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -128,6 +133,7 @@ define void @ult_not_taken(i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @ult_not_taken
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -154,6 +160,7 @@ define void @ult_ub1() {
; CHECK-NEXT: Determining loop execution counts for: @ult_ub1
; CHECK-NEXT: Loop %for.body: backedge-taken count is 2
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 3
@@ -178,6 +185,7 @@ define void @ult_ub2() {
; CHECK-NEXT: Determining loop execution counts for: @ult_ub2
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -202,6 +210,7 @@ define void @ult_129_preinc() {
; CHECK-NEXT: Determining loop execution counts for: @ult_129_preinc
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
@@ -224,6 +233,7 @@ define void @ult_preinc(i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @ult_preinc
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
@@ -248,6 +258,7 @@ define void @ult_129_varying_rhs(i8* %n_p) {
; CHECK-NEXT: Determining loop execution counts for: @ult_129_varying_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -269,6 +280,7 @@ define void @ult_symbolic_varying_rhs(i8* %n_p, i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @ult_symbolic_varying_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -298,6 +310,7 @@ define void @slt_wrap() {
; CHECK-NEXT: Determining loop execution counts for: @slt_wrap
; CHECK-NEXT: Loop %for.body: backedge-taken count is 63
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 63
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 63
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 63
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 64
@@ -322,6 +335,7 @@ define void @slt_infinite() {
; CHECK-NEXT: Determining loop execution counts for: @slt_infinite
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -344,6 +358,7 @@ define void @slt_infinite_ub() mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @slt_infinite_ub
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -368,6 +383,7 @@ define void @slt_129_not_taken() {
; CHECK-NEXT: Determining loop execution counts for: @slt_129_not_taken
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -391,6 +407,7 @@ define void @slt_not_taken(i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @slt_not_taken
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -413,6 +430,7 @@ define void @slt_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Determining loop execution counts for: @slt_129_unknown_start
; CHECK-NEXT: Loop %for.body: backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (((127 + (-1 * (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))<nuw><nsw> + (-1 * %start) + (0 smax (-127 + %start)<nsw>)) /u -127) + (1 umin (127 + (-1 * %start) + (0 smax (-127 + %start)<nsw>))))
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -438,6 +456,7 @@ define void @slt_ub1() {
; CHECK-NEXT: Determining loop execution counts for: @slt_ub1
; CHECK-NEXT: Loop %for.body: backedge-taken count is false
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -462,6 +481,7 @@ define void @slt_ub2() {
; CHECK-NEXT: Determining loop execution counts for: @slt_ub2
; CHECK-NEXT: Loop %for.body: backedge-taken count is false
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
@@ -486,6 +506,7 @@ define void @slt_129_preinc() {
; CHECK-NEXT: Determining loop execution counts for: @slt_129_preinc
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
@@ -508,6 +529,7 @@ define void @slt_preinc(i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @slt_preinc
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
@@ -532,6 +554,7 @@ define void @slt_129_varying_rhs(i8* %n_p) {
; CHECK-NEXT: Determining loop execution counts for: @slt_129_varying_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -553,6 +576,7 @@ define void @slt_symbolic_varying_rhs(i8* %n_p, i8 %step) {
; CHECK-NEXT: Determining loop execution counts for: @slt_symbolic_varying_rhs
; CHECK-NEXT: Loop %for.body: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %for.body: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
@@ -579,11 +603,13 @@ define void @step_is_neg_addrec_slt_8(i64 %n) {
; CHECK-NEXT: Determining loop execution counts for: @step_is_neg_addrec_slt_8
; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is -2147483640
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<nuw><nsw><%outer.header>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %outer.header: Trip multiple is 1
@@ -619,11 +645,13 @@ define void @step_is_neg_addrec_slt_var(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @step_is_neg_addrec_slt_var
; CHECK-NEXT: Loop %inner: backedge-taken count is ((((-1 * (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))<nuw><nsw> + {0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n)) /u (1 umax {0,+,-1}<nuw><nsw><%outer.header>)) + (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ((((-1 * (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))<nuw><nsw> + {0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n)) /u (1 umax {0,+,-1}<nuw><nsw><%outer.header>)) + (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ((((-1 * (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))<nuw><nsw> + {0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n)) /u (1 umax {0,+,-1}<nuw><nsw><%outer.header>)) + (1 umin ({0,+,1}<nuw><%outer.header> + ({0,+,-1}<nuw><nsw><%outer.header> smax %n))))
; CHECK-NEXT: Predicates:
; CHECK: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %outer.header: Trip multiple is 1
@@ -659,11 +687,13 @@ define void @step_is_neg_addrec_unknown_start(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @step_is_neg_addrec_unknown_start
; CHECK-NEXT: Loop %inner: backedge-taken count is ((((-1 * (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))<nuw><nsw> + {(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>)) /u (1 umax {0,+,-1}<%outer.header>)) + (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is -2147483640
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ((((-1 * (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))<nuw><nsw> + {(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>)) /u (1 umax {0,+,-1}<%outer.header>)) + (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ((((-1 * (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))<nuw><nsw> + {(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>)) /u (1 umax {0,+,-1}<%outer.header>)) + (1 umin ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nuw><nsw><%outer.header>))))
; CHECK-NEXT: Predicates:
; CHECK: Loop %inner: Trip multiple is 1
; CHECK-NEXT: Loop %outer.header: backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: constant max backedge-taken count is 0
+; CHECK-NEXT: Loop %outer.header: symbolic max backedge-taken count is 0
; CHECK-NEXT: Loop %outer.header: Predicated backedge-taken count is 0
; CHECK-NEXT: Predicates:
; CHECK: Loop %outer.header: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll b/llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll
index d3b419b5b765..1fe828f58231 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll
@@ -16,7 +16,9 @@ define void @test_preinc_ult(i64 %len) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@@ -49,7 +51,9 @@ define void @test_postinc_ult(i64 %len) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@@ -81,7 +85,9 @@ define void @test_preinc_slt(i64 %len) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@@ -114,7 +120,9 @@ define void @test_postinc_slt(i64 %len) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@@ -146,7 +154,9 @@ define void @test_preinc_sgt(i64 %lim) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@@ -179,7 +189,9 @@ define void @test_postinc_sgt(i64 %lim) {
; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
-; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. symbolic max exit count for loop: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
+; CHECK: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count.ll b/llvm/test/Analysis/ScalarEvolution/trip-count.ll
index 9546a49a4a59..5c8dfd6603c5 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count.ll
@@ -11,6 +11,7 @@ define void @PR1101(i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @PR1101
; CHECK-NEXT: Loop %bb3: backedge-taken count is 10000
; CHECK-NEXT: Loop %bb3: constant max backedge-taken count is 10000
+; CHECK-NEXT: Loop %bb3: symbolic max backedge-taken count is 10000
; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is 10000
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb3: Trip multiple is 10001
@@ -41,6 +42,7 @@ define i32 @PR22795() {
; CHECK-NEXT: Determining loop execution counts for: @PR22795
; CHECK-NEXT: Loop %preheader: backedge-taken count is 7
; CHECK-NEXT: Loop %preheader: constant max backedge-taken count is 7
+; CHECK-NEXT: Loop %preheader: symbolic max backedge-taken count is 7
; CHECK-NEXT: Loop %preheader: Predicated backedge-taken count is 7
; CHECK-NEXT: Predicates:
; CHECK: Loop %preheader: Trip multiple is 8
@@ -104,6 +106,7 @@ define void @pr28012(i32 %n) {
; CHECK-NEXT: Determining loop execution counts for: @pr28012
; CHECK-NEXT: Loop %loop: backedge-taken count is -1431655751
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1431655751
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is -1431655751
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is -1431655751
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 2863311546
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count10.ll b/llvm/test/Analysis/ScalarEvolution/trip-count10.ll
index 2f5c5992d070..825455c4b2a0 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count10.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count10.ll
@@ -8,6 +8,7 @@ define void @a(i64 %n) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @a
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -28,6 +29,7 @@ define void @b(i64 %n) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @b
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -50,6 +52,7 @@ define void @c(i64 %n) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @c
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is false
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is false
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -72,6 +75,7 @@ define void @d(i64 %n) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @d
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -100,6 +104,7 @@ define void @nonpolynomial() {
; CHECK-NEXT: Determining loop execution counts for: @nonpolynomial
; CHECK-NEXT: Loop %loophead: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loophead: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loophead: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loophead: Unpredictable predicated backedge-taken count.
;
entry:
@@ -128,6 +133,7 @@ define void @constant_phi_operands() nounwind {
; CHECK-NEXT: Determining loop execution counts for: @constant_phi_operands
; CHECK-NEXT: Loop %loop: backedge-taken count is 1
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 2
@@ -153,6 +159,7 @@ define void @exit_orcond_nsw(i32 *%a) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @exit_orcond_nsw
; CHECK-NEXT: Loop %for.body.i: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body.i: constant max backedge-taken count is 1
+; CHECK-NEXT: Loop %for.body.i: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %for.body.i: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count14.ll b/llvm/test/Analysis/ScalarEvolution/trip-count14.ll
index 500c59417489..768a5afd7c8b 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count14.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count14.ll
@@ -6,6 +6,7 @@ define void @s32_max1(i32 %n, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @s32_max1
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((1 + %n) smax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 1, actual taken count either this or zero.
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((1 + %n) smax %n)), actual taken count either this or zero.
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((1 + %n) smax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -31,6 +32,7 @@ define void @s32_max2(i32 %n, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @s32_max2
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((2 + %n) smax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 2, actual taken count either this or zero.
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((2 + %n) smax %n)), actual taken count either this or zero.
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((2 + %n) smax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -56,6 +58,7 @@ define void @s32_maxx(i32 %n, i32 %x, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @s32_maxx
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((%n + %x) smax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((%n + %x) smax %n))
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((%n + %x) smax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -83,7 +86,9 @@ define void @s32_max2_unpredictable_exit(i32 %n, i32 %x, i32* %p) {
; CHECK-NEXT: exit count for do.body: ((-1 * %n) + %x)
; CHECK-NEXT: exit count for if.end: ((-1 * %n) + ((2 + %n) smax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 2
-; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) smax %n)) umin ((-1 * %n) + %x))
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is (((-1 * %n) + ((2 + %n) smax %n)) umin ((-1 * %n) + %x)) symbolic max exit count for do.body: ((-1 * %n) + %x)
+; CHECK-NEXT: symbolic max exit count for if.end: ((-1 * %n) + ((2 + %n) smax %n))
+; CHECK: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) smax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
;
@@ -112,6 +117,7 @@ define void @u32_max1(i32 %n, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @u32_max1
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((1 + %n) umax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 1, actual taken count either this or zero.
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((1 + %n) umax %n)), actual taken count either this or zero.
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((1 + %n) umax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -137,6 +143,7 @@ define void @u32_max2(i32 %n, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @u32_max2
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((2 + %n) umax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 2, actual taken count either this or zero.
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((2 + %n) umax %n)), actual taken count either this or zero.
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((2 + %n) umax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -162,6 +169,7 @@ define void @u32_maxx(i32 %n, i32 %x, i32* %p) {
; CHECK-NEXT: Determining loop execution counts for: @u32_maxx
; CHECK-NEXT: Loop %do.body: backedge-taken count is ((-1 * %n) + ((%n + %x) umax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is ((-1 * %n) + ((%n + %x) umax %n))
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is ((-1 * %n) + ((%n + %x) umax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
@@ -189,7 +197,9 @@ define void @u32_max2_unpredictable_exit(i32 %n, i32 %x, i32* %p) {
; CHECK-NEXT: exit count for do.body: ((-1 * %n) + %x)
; CHECK-NEXT: exit count for if.end: ((-1 * %n) + ((2 + %n) umax %n))
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is 2
-; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) umax %n)) umin ((-1 * %n) + %x))
+; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is (((-1 * %n) + ((2 + %n) umax %n)) umin ((-1 * %n) + %x)) symbolic max exit count for do.body: ((-1 * %n) + %x)
+; CHECK-NEXT: symbolic max exit count for if.end: ((-1 * %n) + ((2 + %n) umax %n))
+; CHECK: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) umax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: Predicates:
; CHECK: Loop %do.body: Trip multiple is 1
;
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count15.ll b/llvm/test/Analysis/ScalarEvolution/trip-count15.ll
index dcfe9668aef5..028b1b44b093 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count15.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count15.ll
@@ -13,6 +13,7 @@ define void @umin_unsigned_check(i64 %n) {
; CHECK-NEXT: Determining loop execution counts for: @umin_unsigned_check
; CHECK-NEXT: Loop %loop: backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4097
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -43,6 +44,7 @@ define void @umin_signed_check(i64 %n) {
; CHECK-NEXT: Determining loop execution counts for: @umin_signed_check
; CHECK-NEXT: Loop %loop: backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4097
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -73,6 +75,7 @@ define void @smin_signed_check(i64 %n) {
; CHECK-NEXT: Determining loop execution counts for: @smin_signed_check
; CHECK-NEXT: Loop %loop: backedge-taken count is (0 smax (1 + (4096 smin %n))<nsw>)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4097
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (0 smax (1 + (4096 smin %n))<nsw>)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (0 smax (1 + (4096 smin %n))<nsw>)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -103,6 +106,7 @@ define void @smin_unsigned_check(i64 %n) {
; CHECK-NEXT: Determining loop execution counts for: @smin_unsigned_check
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count2.ll b/llvm/test/Analysis/ScalarEvolution/trip-count2.ll
index ec54907cb15e..df6ab7cbcfdb 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count2.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count2.ll
@@ -8,6 +8,7 @@ define void @PR1101(i32 %N) {
; CHECK-NEXT: Determining loop execution counts for: @PR1101
; CHECK-NEXT: Loop %bb3: backedge-taken count is 4
; CHECK-NEXT: Loop %bb3: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %bb3: symbolic max backedge-taken count is 4
; CHECK-NEXT: Loop %bb3: Predicated backedge-taken count is 4
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb3: Trip multiple is 5
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count3.ll b/llvm/test/Analysis/ScalarEvolution/trip-count3.ll
index d34fe7248d0c..c0a29d88575e 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count3.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count3.ll
@@ -41,6 +41,7 @@ define void @sha_stream_bb3_2E_i(%struct.SHA_INFO* %sha_info, i8* %data1, i32, i
; CHECK-NEXT: Determining loop execution counts for: @sha_stream_bb3_2E_i
; CHECK-NEXT: Loop %bb3.i: backedge-taken count is ((63 + (-1 * (63 smin %0)) + %0) /u 64)
; CHECK-NEXT: Loop %bb3.i: constant max backedge-taken count is 33554431
+; CHECK-NEXT: Loop %bb3.i: symbolic max backedge-taken count is ((63 + (-1 * (63 smin %0)) + %0) /u 64)
; CHECK-NEXT: Loop %bb3.i: Predicated backedge-taken count is ((63 + (-1 * (63 smin %0)) + %0) /u 64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %bb3.i: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count4.ll b/llvm/test/Analysis/ScalarEvolution/trip-count4.ll
index 6a36eaa2abaf..634ea554a3dc 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count4.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count4.ll
@@ -8,6 +8,7 @@ define void @another_count_down_signed(double* %d, i64 %n) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @another_count_down_signed
; CHECK-NEXT: Loop %loop: backedge-taken count is (-11 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-11 + %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-11 + %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count6.ll b/llvm/test/Analysis/ScalarEvolution/trip-count6.ll
index f8397aaa78d1..2796ec68ac45 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count6.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count6.ll
@@ -10,7 +10,9 @@ define i8 @f() {
; CHECK-NEXT: exit count for bb: ***COULDNOTCOMPUTE***
; CHECK-NEXT: exit count for bb2: 1
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is 1
-; CHECK-NEXT: Loop %bb: Unpredictable predicated backedge-taken count.
+; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is 1 symbolic max exit count for bb: ***COULDNOTCOMPUTE***
+; CHECK-NEXT: symbolic max exit count for bb2: 1
+; CHECK: Loop %bb: Unpredictable predicated backedge-taken count.
;
entry:
tail call i32 @fegetround( ) ; <i32>:0 [#uses=1]
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count7.ll b/llvm/test/Analysis/ScalarEvolution/trip-count7.ll
index 52b4bea68fc8..054a7ce91272 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count7.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count7.ll
@@ -65,6 +65,7 @@ define void @Doit_bb7_2E_i([9 x i32]* %x1, [15 x i32]* %c, [17 x i32]* %b, [9 x
; CHECK-NEXT: Determining loop execution counts for: @Doit_bb7_2E_i
; CHECK-NEXT: Loop %bb7.i: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb7.i: constant max backedge-taken count is 8
+; CHECK-NEXT: Loop %bb7.i: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb7.i: Unpredictable predicated backedge-taken count.
;
newFuncRoot:
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count8.ll b/llvm/test/Analysis/ScalarEvolution/trip-count8.ll
index 5e20ab25b18b..cc4ee5b5a3a3 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count8.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count8.ll
@@ -9,6 +9,7 @@ define i32 @foo(i32 %ecx) nounwind {
; CHECK-NEXT: Determining loop execution counts for: @foo
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %ecx)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %ecx)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %ecx)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-count9.ll b/llvm/test/Analysis/ScalarEvolution/trip-count9.ll
index 9593b48ed5e3..232c5a8b6c84 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-count9.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-count9.ll
@@ -14,6 +14,7 @@ define void @foo(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @foo
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -35,6 +36,7 @@ define void @step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @step2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -54,6 +56,7 @@ define void @start1(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @start1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 5
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -75,6 +78,7 @@ define void @start1_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @start1_step2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -94,6 +98,7 @@ define void @startx(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @startx
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -115,6 +120,7 @@ define void @startx_step2(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @startx_step2
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
@@ -134,6 +140,7 @@ define void @nsw(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 6
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %n)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -163,6 +170,7 @@ define void @nsw_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @nsw_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + %n) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + %n) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + %n) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -184,6 +192,7 @@ define void @nsw_start1(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @nsw_start1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 5
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -205,6 +214,7 @@ define void @nsw_start1_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @nsw_start1_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + (3 smax %n))<nsw> /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-2 + (3 smax %n))<nsw> /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-2 + (3 smax %n))<nsw> /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -226,6 +236,7 @@ define void @nsw_startx(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @nsw_startx
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -247,6 +258,7 @@ define void @nsw_startx_step2(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @nsw_startx_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 7
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax %n)) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax %n)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -268,6 +280,7 @@ define void @even(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 5
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 2
@@ -290,6 +303,7 @@ define void @even_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -312,6 +326,7 @@ define void @even_start1(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_start1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -334,6 +349,7 @@ define void @even_start1_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_start1_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -356,6 +372,7 @@ define void @even_startx(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @even_startx
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -378,6 +395,7 @@ define void @even_startx_step2(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @even_startx_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 7
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -400,6 +418,7 @@ define void @even_nsw(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 5
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 2
@@ -422,6 +441,7 @@ define void @even_nsw_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -444,6 +464,7 @@ define void @even_nsw_start1(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw_start1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -466,6 +487,7 @@ define void @even_nsw_start1_step2(i4 %n) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw_start1_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -488,6 +510,7 @@ define void @even_nsw_startx(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw_startx
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -510,6 +533,7 @@ define void @even_nsw_startx_step2(i4 %n, i4 %x) {
; CHECK-NEXT: Determining loop execution counts for: @even_nsw_startx_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 7
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
index 9c31ab59fa32..f16e73c68fff 100644
--- a/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
+++ b/llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
@@ -4,10 +4,20 @@
; Tests for PR47904.
define void @test_trip_multiple_4(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -30,10 +40,20 @@ exit:
define void @test_trip_multiple_4_ugt_5(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4_ugt_5
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_ugt_5'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_ugt_5
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_ugt_5
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -56,10 +76,20 @@ exit:
define void @test_trip_multiple_4_ugt_5_order_swapped(i32 %num) {
; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
-; CHECK-LABEL: @test_trip_multiple_4_ugt_5_order_swapped
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_ugt_5_order_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_ugt_5_order_swapped
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_ugt_5_order_swapped
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
;
entry:
@@ -81,10 +111,20 @@ exit:
}
define void @test_trip_multiple_4_sgt_5(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4_sgt_5
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_sgt_5'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_sgt_5
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_sgt_5
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -107,10 +147,20 @@ exit:
define void @test_trip_multiple_4_sgt_5_order_swapped(i32 %num) {
; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
-; CHECK-LABEL: @test_trip_multiple_4_sgt_5_order_swapped
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_sgt_5_order_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_sgt_5_order_swapped
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_sgt_5_order_swapped
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 2
;
entry:
@@ -132,10 +182,20 @@ exit:
}
define void @test_trip_multiple_4_uge_5(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4_uge_5
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_uge_5'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_uge_5
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_uge_5
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -158,10 +218,20 @@ exit:
define void @test_trip_multiple_4_uge_5_order_swapped(i32 %num) {
; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
-; CHECK-LABEL: @test_trip_multiple_4_uge_5_order_swapped
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_uge_5_order_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_uge_5_order_swapped
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_uge_5_order_swapped
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
@@ -184,10 +254,20 @@ exit:
define void @test_trip_multiple_4_sge_5(i32 %num) {
; TODO: Trip multiple can be 4, it is missed due to the processing order of the assumes.
-; CHECK-LABEL: @test_trip_multiple_4_sge_5
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_sge_5'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_sge_5
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_sge_5
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -209,10 +289,20 @@ exit:
}
define void @test_trip_multiple_4_sge_5_order_swapped(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4_sge_5_order_swapped
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_sge_5_order_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_sge_5_order_swapped
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,2147483647) S: [0,2147483647) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_sge_5_order_swapped
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is 2147483646
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
@@ -235,10 +325,20 @@ exit:
; Same as @test_trip_multiple_4 but with the icmp operands swapped.
define void @test_trip_multiple_4_icmp_ops_swapped(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_4_icmp_ops_swapped
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_4_icmp_ops_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_4_icmp_ops_swapped
+; CHECK-NEXT: %u = urem i32 %num, 4
+; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_4_icmp_ops_swapped
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 4
;
entry:
@@ -260,10 +360,20 @@ exit:
}
define void @test_trip_multiple_5(i32 %num) {
-; CHECK-LABEL: @test_trip_multiple_5
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %num)
+; CHECK-LABEL: 'test_trip_multiple_5'
+; CHECK-NEXT: Classifying expressions for: @test_trip_multiple_5
+; CHECK-NEXT: %u = urem i32 %num, 5
+; CHECK-NEXT: --> ((-5 * (%num /u 5)) + %num) U: full-set S: full-set
+; CHECK-NEXT: %i.010 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-2147483648) S: [0,-2147483648) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %inc = add nuw nsw i32 %i.010, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-2147483648) S: [1,-2147483648) Exits: %num LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trip_multiple_5
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
+; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
@@ -285,10 +395,23 @@ exit:
}
define void @test_trunc_operand_larger_than_urem_expr(i64 %N) {
-; CHECK-LABEL: @test_trunc_operand_larger_than_urem_expr
-; CHECK: Loop %for.body: backedge-taken count is (-1 + %N)
+; CHECK-LABEL: 'test_trunc_operand_larger_than_urem_expr'
+; CHECK-NEXT: Classifying expressions for: @test_trunc_operand_larger_than_urem_expr
+; CHECK-NEXT: %conv = trunc i64 %N to i32
+; CHECK-NEXT: --> (trunc i64 %N to i32) U: full-set S: full-set
+; CHECK-NEXT: %and = and i32 %conv, 1
+; CHECK-NEXT: --> (zext i1 (trunc i64 %N to i1) to i32) U: [0,2) S: [0,2)
+; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: (-1 + %N) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,-9223372036854775808) S: [1,-9223372036854775808) Exits: %N LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_trunc_operand_larger_than_urem_expr
+; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %N)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 1
;
entry:
%conv = trunc i64 %N to i32
diff --git a/llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll b/llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll
index 83708493cc64..8e72000ee434 100644
--- a/llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll
+++ b/llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll
@@ -17,6 +17,7 @@ define void @umin_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @umin_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -52,6 +53,7 @@ define void @ule_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @ule_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -87,6 +89,7 @@ define void @uge_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @uge_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -122,6 +125,7 @@ define void @ult_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @ult_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -157,6 +161,7 @@ define void @ugt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @ugt_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -192,6 +197,7 @@ define void @sle_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @sle_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -227,6 +233,7 @@ define void @sge_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @sge_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -262,6 +269,7 @@ define void @slt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @slt_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is -1
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
@@ -297,6 +305,7 @@ define void @sgt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Determining loop execution counts for: @sgt_sext_x_zext_x
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 4294967295
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
diff --git a/llvm/test/Analysis/ScalarEvolution/unknown_phis.ll b/llvm/test/Analysis/ScalarEvolution/unknown_phis.ll
index 48a206156112..34e488bb2766 100644
--- a/llvm/test/Analysis/ScalarEvolution/unknown_phis.ll
+++ b/llvm/test/Analysis/ScalarEvolution/unknown_phis.ll
@@ -49,6 +49,7 @@ define void @merge_values_with_ranges_looped(i32 *%a_len_ptr, i32 *%b_len_ptr) {
; CHECK-NEXT: Determining loop execution counts for: @merge_values_with_ranges_looped
; CHECK-NEXT: Loop %loop: backedge-taken count is 99
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 99
+; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 99
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 99
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 100
diff --git a/llvm/test/Analysis/ScalarEvolution/widenable-condition.ll b/llvm/test/Analysis/ScalarEvolution/widenable-condition.ll
index 9189eda4619b..71c87b49465d 100644
--- a/llvm/test/Analysis/ScalarEvolution/widenable-condition.ll
+++ b/llvm/test/Analysis/ScalarEvolution/widenable-condition.ll
@@ -24,6 +24,7 @@ define i32 @wc_max() {
; CHECK-NEXT: Determining loop execution counts for: @wc_max
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 1999
+; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
diff --git a/llvm/test/Transforms/LoopDeletion/invalidate-scev-after-hoisting.ll b/llvm/test/Transforms/LoopDeletion/invalidate-scev-after-hoisting.ll
index a63280e87532..d2d085b8c7ad 100644
--- a/llvm/test/Transforms/LoopDeletion/invalidate-scev-after-hoisting.ll
+++ b/llvm/test/Transforms/LoopDeletion/invalidate-scev-after-hoisting.ll
@@ -7,6 +7,7 @@
; CHECK: Determining loop execution counts for: @test
; CHECK-NEXT: Loop %inner: backedge-taken count is (405 + %invar)<nuw><nsw>
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is 405
+; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (405 + %invar)<nuw><nsw>
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (405 + %invar)<nuw><nsw>
define void @test_pr57837() {
More information about the llvm-commits
mailing list