shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[SCEV] Print predicate backedge count only if new information available

Browse Source 
When printing the result of SCEV's analysis, we can avoid printing
the predicated backedge taken count and the predicates if the predicates
are empty and no new information is provided.  This helps to reduce the
verbosity of the output.
This commit is contained in:
Philip Reames 2024-03-06 09:22:52 -08:00 committed by Philip Reames
parent 2542d34522
commit 8b5b294ec2
97 changed files with 12 additions and 1110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
llvm/lib/Analysis/ScalarEvolution.cpp
View File

@ -13484,8 +13484,9 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
if (ExitingBlocks.size() != 1)
OS << "<multiple exits> ";
if (SE->hasLoopInvariantBackedgeTakenCount(L))
OS << "backedge-taken count is " << *SE->getBackedgeTakenCount(L) << "\n";
auto *BTC = SE->getBackedgeTakenCount(L);
if (!isa<SCEVCouldNotCompute>(BTC))
OS << "backedge-taken count is " << *BTC << "\n";
else
OS << "Unpredictable backedge-taken count.\n";
@ -13531,19 +13532,19 @@ static void PrintLoopInfo(raw_ostream &OS, ScalarEvolution *SE,
<< "\n";
}
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
SmallVector<const SCEVPredicate *, 4> Preds;
auto PBT = SE->getPredicatedBackedgeTakenCount(L, Preds);
if (!isa<SCEVCouldNotCompute>(PBT)) {
OS << "Predicated backedge-taken count is " << *PBT << "\n";
auto *PBT = SE->getPredicatedBackedgeTakenCount(L, Preds);
if (PBT != BTC || !Preds.empty()) {
OS << "Loop ";
L->getHeader()->printAsOperand(OS, /*PrintType=*/false);
OS << ": ";
if (!isa<SCEVCouldNotCompute>(PBT))
OS << "Predicated backedge-taken count is " << *PBT << "\n";
else
OS << "Unpredictable predicated backedge-taken count.\n";
OS << " Predicates:\n";
for (const auto *P : Preds)
P->print(OS, 4);
} else {
OS << "Unpredictable predicated backedge-taken count.\n";
}
if (SE->hasLoopInvariantBackedgeTakenCount(L)) {

2
llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride1.ll
View File

@ -13,8 +13,6 @@ define i32 @f(i32 %x) nounwind readnone {
; CHECK-NEXT: Loop %bb: backedge-taken count is ((-5 + %x) /u 3)
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is i32 1431655764
; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is ((-5 + %x) /u 3)
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is ((-5 + %x) /u 3)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/2008-11-18-Stride2.ll
View File

@ -11,8 +11,6 @@ define i32 @f(i32 %x) nounwind readnone {
; CHECK-NEXT: Loop %bb: backedge-taken count is (((-3 + (-1 * (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))<nuw><nsw> + (-1 * %x) + (1000 umax (3 + %x))) /u 3) + (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is i32 334
; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is (((-3 + (-1 * (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))<nuw><nsw> + (-1 * %x) + (1000 umax (3 + %x))) /u 3) + (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is (((-3 + (-1 * (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))<nuw><nsw> + (-1 * %x) + (1000 umax (3 + %x))) /u 3) + (1 umin (-3 + (-1 * %x) + (1000 umax (3 + %x)))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb: Trip multiple is 1
;
entry:

1
llvm/test/Analysis/ScalarEvolution/ZeroStep.ll
View File

@ -16,7 +16,6 @@ define void @foo() {
; 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:
br label %loop

1
llvm/test/Analysis/ScalarEvolution/add-expr-pointer-operand-sorting.ll
View File

@ -49,7 +49,6 @@ define i32 @d(i32 %base) {
; 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:
%e = alloca [1 x [1 x i8]], align 1

2
llvm/test/Analysis/ScalarEvolution/add-like-or.ll
View File

@ -68,8 +68,6 @@ define void @mask-high(i64 %arg, ptr dereferenceable(4) %arg1) {
; CHECK-NEXT: Loop %bb6: backedge-taken count is (-1 + (-16 * (%arg /u 16)) + ((sext i32 %i to i64) smax (1 + (16 * (%arg /u 16))<nuw>)<nuw><nsw>))
; CHECK-NEXT: Loop %bb6: constant max backedge-taken count is i64 -9223372034707292162
; CHECK-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-16 * (%arg /u 16)) + ((sext i32 %i to i64) smax (1 + (16 * (%arg /u 16))<nuw>)<nuw><nsw>))
; CHECK-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-16 * (%arg /u 16)) + ((sext i32 %i to i64) smax (1 + (16 * (%arg /u 16))<nuw>)<nuw><nsw>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb6: Trip multiple is 1
;
bb:

4
llvm/test/Analysis/ScalarEvolution/addrec-computed-during-addrec-calculation.ll
View File

@ -29,17 +29,13 @@ define void @test(ptr %p) {
; CHECK-NEXT: Loop %loop2: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop2: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %loop2: symbolic max backedge-taken count is -1
; 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 i1 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-NEXT: 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:
br label %loop.header

4
llvm/test/Analysis/ScalarEvolution/addrec-sub-nsw.ll
View File

@ -14,8 +14,6 @@ define i32 @test_1_non_negative(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -53,8 +51,6 @@ define i32 @test_2_non_positive(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (1 smax %n))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/alloca.ll
View File

@ -46,8 +46,6 @@ define void @alloca_icmp_null_exit_count() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 2
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 3
;
entry:

4
llvm/test/Analysis/ScalarEvolution/backedge-taken-count-guard-info.ll
View File

@ -16,8 +16,6 @@ define void @loop_guard_improves_exact_backedge_taken_count_1(i32 %conv) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -52,8 +50,6 @@ define void @loop_guard_improves_exact_backedge_taken_count_2(i32 %conv) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i1 (trunc i32 %conv to i1) to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 1
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i1 (trunc i32 %conv to i1) to i64)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (zext i1 (trunc i32 %conv to i1) to i64)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 2
;
entry:

2
llvm/test/Analysis/ScalarEvolution/becount-invalidation.ll
View File

@ -34,11 +34,9 @@ define void @test(ptr %arg) {
; CHECK-NEXT: Loop %loop2.header: symbolic max backedge-taken count is false
; CHECK-NEXT: symbolic max exit count for loop2.header: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for loop2.latch: false
; CHECK-NEXT: 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:
br label %loop.header

5
llvm/test/Analysis/ScalarEvolution/cycled_phis.ll
View File

@ -17,7 +17,6 @@ define void @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:
br label %loop
@ -54,11 +53,9 @@ define void @test_02(ptr %p, ptr %q) {
; 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:
%start = load i32, ptr %p, !range !0
@ -107,11 +104,9 @@ define void @test_03(ptr %p, ptr %q) {
; 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:
%start_1 = load i32, ptr %p, !range !0

4
llvm/test/Analysis/ScalarEvolution/decrementing_addrecs.ll
View File

@ -49,8 +49,6 @@ define i32 @test_step_1_flags(i32 %n) {
; DEFAULT-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; DEFAULT-NEXT: Loop %loop: constant max backedge-taken count is i32 2147483646
; DEFAULT-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %n)
; DEFAULT-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %n)
; DEFAULT-NEXT: Predicates:
; DEFAULT-NEXT: Loop %loop: Trip multiple is 1
;
; EXPENSIVE_SHARPENING-LABEL: 'test_step_1_flags'
@ -75,8 +73,6 @@ define i32 @test_step_1_flags(i32 %n) {
; EXPENSIVE_SHARPENING-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; EXPENSIVE_SHARPENING-NEXT: Loop %loop: constant max backedge-taken count is i32 2147483646
; EXPENSIVE_SHARPENING-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %n)
; EXPENSIVE_SHARPENING-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %n)
; EXPENSIVE_SHARPENING-NEXT: Predicates:
; EXPENSIVE_SHARPENING-NEXT: Loop %loop: Trip multiple is 1
;
entry:

5
llvm/test/Analysis/ScalarEvolution/exact-exit-count-more-precise.ll
View File

@ -16,13 +16,10 @@ define void @test_and(i16 %in) {
; CHECK-NEXT: Loop %bb1.i: backedge-taken count is (1 + (-1 * %in))
; CHECK-NEXT: Loop %bb1.i: constant max backedge-taken count is i16 -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-NEXT: 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
@ -58,8 +55,6 @@ define void @test_or() {
; CHECK-NEXT: Loop %BB: backedge-taken count is undef
; CHECK-NEXT: Loop %BB: constant max backedge-taken count is i32 -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-NEXT: Loop %BB: Trip multiple is 1
;
%C10 = icmp slt i1 undef, undef

2
llvm/test/Analysis/ScalarEvolution/exhaustive-trip-counts.ll
View File

@ -11,8 +11,6 @@ define void @f_0() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 5
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 5
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 5
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 5
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 6
;
entry:

79
llvm/test/Analysis/ScalarEvolution/exit-count-select-safe.ll
View File

@ -14,8 +14,6 @@ define i32 @logical_and_2ops(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -44,8 +42,6 @@ define i32 @logical_or_2ops(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -76,8 +72,6 @@ define i32 @logical_and_3ops(i32 %n, i32 %m, i32 %k) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -110,8 +104,6 @@ define i32 @logical_or_3ops(i32 %n, i32 %m, i32 %k) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -146,8 +138,6 @@ define i32 @logical_or_3ops_duplicate(i32 %n, i32 %m, i32 %k) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -184,8 +174,6 @@ define i32 @logical_or_3ops_redundant_uminseq_operand(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -221,8 +209,6 @@ define i32 @logical_or_3ops_redundant_umin_operand(i32 %n, i32 %m, i32 %k) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -260,8 +246,6 @@ define i32 @logical_or_4ops_redundant_operand_across_umins(i32 %n, i32 %m, i32 %
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -300,8 +284,6 @@ define i32 @logical_or_3ops_operand_wise_redundant_umin(i32 %n, i32 %m, i32 %k)
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n umin %m) umin_seq %k)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -338,8 +320,6 @@ define i32 @logical_or_3ops_partially_redundant_umin(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq (%m umin %k))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -384,14 +364,10 @@ define i32 @logical_or_5ops_redundant_opearand_of_inner_uminseq(i32 %a, i32 %b,
; 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 i32 -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-NEXT: 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 i32 -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-NEXT: Loop %first.loop: Trip multiple is 1
;
entry:
@ -437,8 +413,6 @@ define i32 @logical_and_2ops_and_constant(i32 %n, i32 %m, i32 %k) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (42 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -476,19 +450,14 @@ define i32 @computeSCEVAtScope(i32 %d.0) {
; CHECK-NEXT: Loop %for.cond: backedge-taken count is (-1 * %d.0)
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is i32 -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-NEXT: 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 i32 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-NEXT: 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:
br label %while.cond
@ -545,8 +514,6 @@ define i64 @uminseq_vs_ptrtoint_complexity(i64 %n, i64 %m, ptr %ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -579,8 +546,6 @@ define i32 @logical_and_implies_poison1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -612,8 +577,6 @@ define i32 @logical_and_implies_poison2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((1 + %n) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -645,8 +608,6 @@ define i32 @logical_and_implies_poison3(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -678,8 +639,6 @@ define i32 @logical_and_implies_poison_wrong_direction(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq (%n + %m))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -709,8 +668,6 @@ define i32 @logical_and_implies_poison_noundef(i32 %n, i32 noundef %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -739,8 +696,6 @@ define i32 @logical_and_implies_poison_noundef_wrong_direction(i32 %n, i32 nound
; CHECK-NEXT: Loop %loop: backedge-taken count is (%m umin_seq %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -773,8 +728,6 @@ define i32 @logical_and_implies_poison_complex1(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin (1 + %n + %m))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -809,8 +762,6 @@ define i32 @logical_and_implies_poison_complex2(i32 %n, i32 %m, i32 %l) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((%n + %m) umin (%n + %m + %l))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -845,8 +796,6 @@ define i32 @logical_and_implies_poison_complex_wrong_direction(i32 %n, i32 %m, i
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -881,8 +830,6 @@ define i32 @logical_and_implies_multiple_ops(i32 %n, i32 %m) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -918,8 +865,6 @@ define i32 @logical_and_implies_multiple_ops2(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq ((1 + %n) umin %m))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%n umin_seq ((1 + %n) umin %m))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%n umin_seq ((1 + %n) umin %m))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -955,8 +900,6 @@ define i32 @logical_and_implies_multiple_ops3(i32 %n, i32 %m) {
; 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 i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -992,8 +935,6 @@ define i32 @logical_and_not_zero(i16 %n, i32 %m) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1028,8 +969,6 @@ define i32 @logical_and_not_zero_wrong_order(i16 %n, i32 %m) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1060,8 +999,6 @@ define i32 @logical_and_not_zero_needs_context(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%n umin_seq %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1099,8 +1036,6 @@ define i32 @logical_and_known_smaller(i16 %n, i16 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1138,8 +1073,6 @@ define i32 @logical_and_known_smaller_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1177,8 +1110,6 @@ define i32 @logical_and_not_known_smaller_equal(i16 %n, i16 %m) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1216,8 +1147,6 @@ define i32 @logical_and_known_greater(i16 %n, i16 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1255,8 +1184,6 @@ define i32 @logical_and_known_greater_equal(i16 %n, i16 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i16 %n to i32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1294,8 +1221,6 @@ define i32 @logical_and_not_known_greater_equal(i16 %n, i16 %m) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1327,8 +1252,6 @@ define i32 @logical_and_zero_arg1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1357,8 +1280,6 @@ define i32 @logical_and_zero_arg2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

14
llvm/test/Analysis/ScalarEvolution/exit-count-select.ll
View File

@ -16,8 +16,6 @@ define void @logical_and_m_const(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -48,8 +46,6 @@ define void @logical_and_nonzero(i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -81,8 +77,6 @@ define void @logical_and_zero(i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -115,7 +109,6 @@ define void @logical_and_inversed(i32 %n, i32 %m) {
; 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:
br label %loop
@ -145,8 +138,6 @@ define void @logical_or_m_const(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -177,8 +168,6 @@ define void @logical_or_nonzero(i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (2 umin %m)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -210,8 +199,6 @@ define void @logical_or_zero(i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -244,7 +231,6 @@ define void @logical_or_inversed(i32 %n, i32 %m) {
; 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:
br label %loop

1
llvm/test/Analysis/ScalarEvolution/exponential-behavior.ll
View File

@ -12,7 +12,6 @@ define void @f(i32 %n, ptr %ptr) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: symbolic max exit count for loop: 0
; CHECK-NEXT: symbolic max exit count for be: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop

22
llvm/test/Analysis/ScalarEvolution/finite-trip-count.ll
View File

@ -12,8 +12,6 @@ define void @sle_pre_inc(i32 %len) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (0 smax (1 + %len))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483647
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (0 smax (1 + %len))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (0 smax (1 + %len))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -36,8 +34,6 @@ define void @sle_post_inc(i32 %len) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 smax (1 + %len)))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (1 smax (1 + %len)))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 smax (1 + %len)))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -60,7 +56,6 @@ define void @sle_pre_inc_infinite(i32 %len) {
; 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
@ -82,8 +77,6 @@ define void @ule_pre_inc(i32 %len) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (1 + %len)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (1 + %len)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (1 + %len)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -106,8 +99,6 @@ define void @ule_post_inc(i32 %len) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 umax (1 + %len)))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (1 umax (1 + %len)))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (1 umax (1 + %len)))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -130,7 +121,6 @@ define void @ule_pre_inc_infinite(i32 %len) {
; 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
@ -152,8 +142,6 @@ define void @sge_pre_inc(i32 %end) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -2147483548
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -176,8 +164,6 @@ define void @sge_post_inc(i32 %end) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -2147483548
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (100 + (-1 * (100 smin (-1 + %end))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -200,7 +186,6 @@ define void @sge_pre_inc_infinite(i32 %end) {
; 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
@ -222,8 +207,6 @@ define void @use_pre_inc(i32 %end) willreturn {
; 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 i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -246,8 +229,6 @@ define void @use_post_inc(i32 %end) willreturn {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (99 + (-1 * (99 umin (-1 + %end)))<nsw>)<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 99
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (99 + (-1 * (99 umin (-1 + %end)))<nsw>)<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (99 + (-1 * (99 umin (-1 + %end)))<nsw>)<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -270,7 +251,6 @@ define void @uge_pre_inc_infinite(i32 %end) {
; 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
@ -292,8 +272,6 @@ define void @pr54191(i64 %n) mustprogress {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + %n) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387902
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-2 + %n) /u 2)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-2 + %n) /u 2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

4
llvm/test/Analysis/ScalarEvolution/flags-from-poison-noautogen.ll
View File

@ -26,14 +26,10 @@ define void @subrecurrences(i32 %outer_l, i32 %inner_l, i32 %val) {
; CHECK-NEXT: Loop %inner: backedge-taken count is %inner_l
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is i32 -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-NEXT: 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 i32 -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-NEXT: Loop %outer: Trip multiple is 1
;
entry:

77
llvm/test/Analysis/ScalarEvolution/flags-from-poison.ll
View File

@ -32,8 +32,6 @@ define void @test-add-nsw(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -71,8 +69,6 @@ define void @test-add-nuw(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -111,8 +107,6 @@ define void @test-add-scope-invariant(ptr %input, i32 %needle) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %offset) + %needle)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -152,7 +146,6 @@ define void @test-add-scope-bound(ptr %input, i32 %needle) {
; 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:
br label %loop
@ -186,7 +179,6 @@ define void @test-add-scope-bound-unkn-preheader(ptr %input, i32 %needle) {
; 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:
%offset = load i32, ptr %input
@ -218,7 +210,6 @@ define void @test-add-scope-bound-unkn-preheader-neg1(ptr %input, i32 %needle) {
; 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:
%offset = load i32, ptr %input
@ -251,7 +242,6 @@ define void @test-add-scope-bound-unkn-preheader-neg2(ptr %input, i32 %needle) {
; 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:
%offset = load i32, ptr %input
@ -287,7 +277,6 @@ define void @test-add-scope-bound-unkn-header(ptr %input, i32 %needle) {
; 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:
br label %loop
@ -322,7 +311,6 @@ define void @test-add-scope-bound-unkn-header2(ptr %input, i32 %needle) {
; 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:
br label %loop
@ -358,7 +346,6 @@ define void @test-add-scope-bound-unkn-header-neg(ptr %input, i32 %needle) {
; 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:
br label %loop
@ -394,8 +381,6 @@ define void @test-add-nuw-from-icmp(ptr %input, i32 %offset,
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
i32 %numIterations) {
@ -434,8 +419,6 @@ define void @test-add-no-load(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -472,8 +455,6 @@ define void @test-add-not-header(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -511,8 +492,6 @@ define void @test-add-not-header2(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -556,7 +535,6 @@ define void @test-add-not-header3(ptr %input, i32 %offset, i32 %numIterations,
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for loop2: (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
ptr %cond_buf) {
entry:
@ -595,8 +573,6 @@ define void @test-add-not-header4(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -637,7 +613,6 @@ define void @test-add-not-header5(ptr %input, i32 %offset) {
; 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:
br label %loop
@ -672,8 +647,6 @@ define void @test-add-not-header6(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -711,8 +684,6 @@ define void @test-add-not-header7(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -752,8 +723,6 @@ define void @test-add-not-header8(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -793,8 +762,6 @@ define void @test-add-call(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -831,8 +798,6 @@ define void @test-add-call2(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -868,8 +833,6 @@ define void @test-gep-propagates-poison(ptr %input, i32 %offset, i32 %numIterati
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -907,8 +870,6 @@ define void @test-add-mul-propagates(ptr %input, i32 %offset, i32 %numIterations
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -946,8 +907,6 @@ define void @test-mul-propagates-poison(ptr %input, i32 %offset, i32 %numIterati
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -984,8 +943,6 @@ define void @test-mul-propagates-poison-2(ptr %input, i32 %offset, i32 %numItera
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1021,8 +978,6 @@ define void @test-add-div(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1056,8 +1011,6 @@ define void @test-add-div2(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1091,8 +1044,6 @@ define void @test-add-store(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1134,8 +1085,6 @@ define void @test-add-twice(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1178,8 +1127,6 @@ define void @test-mul-nsw(ptr %input, i32 %stride, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1216,8 +1163,6 @@ define void @test-mul-nuw(ptr %input, i32 %stride, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1256,8 +1201,6 @@ define void @test-shl-nsw(ptr %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1296,8 +1239,6 @@ define void @test-shl-nuw-edgecase(ptr %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1336,8 +1277,6 @@ define void @test-shl-nuw-nsw(ptr %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1376,8 +1315,6 @@ define void @test-shl-no-nsw(ptr %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1416,8 +1353,6 @@ define void @test-shl-nsw-edgecase(ptr %input, i32 %start, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1454,8 +1389,6 @@ define void @test-shl-nuw(ptr %input, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1495,8 +1428,6 @@ define void @test-sub-no-nsw(ptr %input, i32 %start, i32 %sub, i32 %numIteration
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1537,8 +1468,6 @@ define void @test-sub-nsw(ptr %input, i32 %start, i32 %sub, i32 %numIterations)
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %start) + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1578,8 +1507,6 @@ define void @test-sub-nsw-lhs-non-negative(ptr %input, i32 %sub, i32 %numIterati
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1625,7 +1552,6 @@ define void @test-sext-sub(ptr %input, i32 %sub, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for cont: (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -1676,8 +1602,6 @@ define void @test-sub-with-add(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1744,7 +1668,6 @@ define i32 @pr28932() {
; CHECK-NEXT: Loop %for.cond: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for if.then: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for if.else: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.cond: Unpredictable predicated backedge-taken count.
;
entry:
%pre = load ptr, ptr @a, align 8

2
llvm/test/Analysis/ScalarEvolution/fold.ll
View File

@ -80,8 +80,6 @@ define void @test4(i32 %x, i32 %y) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 20
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 20
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 20
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 20
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 21
;
entry:

10
llvm/test/Analysis/ScalarEvolution/huge-trip-multiple.ll
View File

@ -17,8 +17,6 @@ define void @trip_count_4294967295() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 4294967294
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 4294967294
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 4294967294
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 4294967294
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 4294967295
;
entry:
@ -46,8 +44,6 @@ define void @trip_count_4294967296() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 4294967295
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 4294967295
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 4294967295
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 4294967295
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 2147483648
;
entry:
@ -75,8 +71,6 @@ define void @trip_count_8589935692() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 8589934591
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 8589934591
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 8589934591
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 8589934591
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 2147483648
;
entry:
@ -104,8 +98,6 @@ define void @trip_count_9223372036854775808() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 9223372036854775807
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 9223372036854775807
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 9223372036854775807
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 9223372036854775807
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 2147483648
;
entry:
@ -133,8 +125,6 @@ define void @trip_count_18446744073709551615() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

3
llvm/test/Analysis/ScalarEvolution/incorrect-exit-count.ll
View File

@ -64,7 +64,6 @@ define dso_local i32 @f() {
; CHECK-NEXT: Loop %for.cond6: symbolic max backedge-taken count is 0
; CHECK-NEXT: symbolic max exit count for for.cond6: 0
; CHECK-NEXT: symbolic max exit count for for.end: ***COULDNOTCOMPUTE***
; CHECK-NEXT: 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***
@ -72,7 +71,6 @@ define dso_local i32 @f() {
; CHECK-NEXT: Loop %inner.loop: symbolic max backedge-taken count is 0
; CHECK-NEXT: symbolic max exit count for inner.loop: 0
; CHECK-NEXT: symbolic max exit count for for.end.3: ***COULDNOTCOMPUTE***
; CHECK-NEXT: 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***
@ -82,7 +80,6 @@ define dso_local i32 @f() {
; CHECK-NEXT: 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-NEXT: Loop %outer.loop: Unpredictable predicated backedge-taken count.
;
entry:
store i32 3, ptr @a, align 4

16
llvm/test/Analysis/ScalarEvolution/increasing-or-decreasing-iv.ll
View File

@ -20,8 +20,6 @@ define void @f0(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:
@ -88,8 +86,6 @@ define void @f1(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 15
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 16
;
entry:
@ -149,8 +145,6 @@ define void @f2(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:
@ -192,8 +186,6 @@ define void @f3(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:
@ -242,8 +234,6 @@ define void @f4(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 128
;
@ -286,8 +276,6 @@ define void @f5(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:
@ -332,8 +320,6 @@ define void @f6(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:
@ -381,8 +367,6 @@ define void @f7(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 127
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 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-NEXT: Loop %loop: Trip multiple is 128
;
entry:

1
llvm/test/Analysis/ScalarEvolution/invalidation.ll
View File

@ -41,7 +41,6 @@ define void @test(i32 %n) {
; CHECK-LABEL: Classifying expressions for: @test
; CHECK: Loop %loop: backedge-taken count is 14
; CHECK: Loop %loop: constant max backedge-taken count is i32 14
; CHECK: Loop %loop: Predicated backedge-taken count is 14
entry:
br label %loop

12
llvm/test/Analysis/ScalarEvolution/iv-poison.ll
View File

@ -17,7 +17,6 @@ define i2 @iv_nsw_poison(i2 %arg) {
; CHECK-NEXT: Loop %bb1: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable predicated backedge-taken count.
;
bb:
br label %bb1
@ -49,7 +48,6 @@ define i4 @iv_nsw_poison2(i4 %0, i4 %end, i4 %start) {
; 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:
br label %loop
@ -81,7 +79,6 @@ define i2 @iv_both_adds_nsw(i2 %arg) {
; 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.
;
bb:
br label %loop
@ -113,7 +110,6 @@ define i4 @iv_both_adds_nsw_extra_use(i4 %arg) {
; 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.
;
bb:
br label %loop
@ -147,7 +143,6 @@ define i4 @iv_both_adds_nsw_extra_use_incs_reordered(i4 %arg) {
; 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.
;
bb:
br label %loop
@ -181,7 +176,6 @@ define i4 @iv_nsw_poison_extra_use(i4 %0, i4 %end, i4 %start) {
; 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:
br label %loop
@ -216,7 +210,6 @@ define i2 @iv_nuw_poison(i2 %arg, i2 %start) {
; CHECK-NEXT: Loop %bb1: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb1: Unpredictable predicated backedge-taken count.
;
bb:
br label %bb1
@ -248,7 +241,6 @@ define i4 @iv_nuw_poison2(i4 %0, i4 %end, i4 %start) {
; 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:
br label %loop
@ -280,7 +272,6 @@ define i2 @iv_both_adds_nuw(i2 %arg, i2 %start) {
; 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.
;
bb:
br label %loop
@ -312,7 +303,6 @@ define i4 @iv_both_adds_nuw_extra_use(i4 %arg, i4 %start) {
; 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.
;
bb:
br label %loop
@ -346,7 +336,6 @@ define i4 @iv_both_adds_nuw_extra_use_incs_reordered(i4 %arg, i4 %start) {
; 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.
;
bb:
br label %loop
@ -380,7 +369,6 @@ define i4 @iv_nuw_poison_extra_use(i4 %0, i4 %end, i4 %start) {
; 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:
br label %loop

4
llvm/test/Analysis/ScalarEvolution/load-with-range-metadata.ll
View File

@ -8,8 +8,6 @@ define i32 @slt_trip_count_with_range(ptr %ptr0, ptr %ptr1) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 98
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -33,8 +31,6 @@ define i32 @ult_trip_count_with_range(ptr %ptr0, ptr %ptr1) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 98
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %limit)<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

4
llvm/test/Analysis/ScalarEvolution/load.ll
View File

@ -33,8 +33,6 @@ define i32 @test1() nounwind readnone {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 49
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 50
;
entry:
@ -87,8 +85,6 @@ define i32 @test2() nounwind uwtable readonly {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 4
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 5
;
entry:

2
llvm/test/Analysis/ScalarEvolution/logical-operations.ll
View File

@ -434,8 +434,6 @@ define ptr @tautological_select_like_phi(i32 %tc) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 100
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 101
;
entry:

36
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info-rewrite-expressions.ll
View File

@ -19,8 +19,6 @@ define void @rewrite_zext(i32 %n) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -63,8 +61,6 @@ define i32 @rewrite_zext_min_max(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -111,8 +107,6 @@ define i32 @rewrite_min_max_zext(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -159,8 +153,6 @@ define i32 @rewrite_sext_min_max(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -207,8 +199,6 @@ define i32 @rewrite_min_max_sext(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -257,8 +247,6 @@ define i32 @rewrite_zext_with_info_from_icmp_ne(i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -307,8 +295,6 @@ define i32 @rewrite_zext_no_icmp_ne(i32 %N) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -349,8 +335,6 @@ define void @rewrite_zext_and_base_1(i32 %n) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -394,8 +378,6 @@ define void @rewrite_zext_and_base_2(i32 %n) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -437,8 +419,6 @@ define void @guard_pessimizes_analysis_step2(i1 %c, i32 %N) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -485,8 +465,6 @@ define i32 @rewrite_sext_slt_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -531,8 +509,6 @@ define i32 @rewrite_zext_ult_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -577,8 +553,6 @@ define i32 @rewrite_zext_ule_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((4 umax (zext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -623,8 +597,6 @@ define i32 @rewrite_zext_sle_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((zext i32 (4 smax %N) to i64) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -669,8 +641,6 @@ define i32 @rewrite_zext_uge_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -715,8 +685,6 @@ define i32 @rewrite_sext_sge_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -761,8 +729,6 @@ define i32 @rewrite_zext_ugt_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * ((16 umin (zext i32 %N to i64)) /u 4))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -807,8 +773,6 @@ define i32 @rewrite_sext_sgt_narrow_check(i32 %N, ptr %arr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 3
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * (zext i3 (trunc i64 ((16 smin (sext i32 %N to i64)) /u 4) to i3) to i64))<nuw><nsw>)<nsw> /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

93
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
View File

@ -16,8 +16,6 @@ define void @test_guard_less_than_16(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -49,8 +47,6 @@ define void @test_guard_less_than_16_operands_swapped(ptr nocapture %a, i64 %i)
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -82,8 +78,6 @@ define void @test_guard_less_than_16_branches_flipped(ptr nocapture %a, i64 %i)
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -115,8 +109,6 @@ define void @test_guard_uge_16_branches_flipped(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -148,8 +140,6 @@ define void @test_guard_eq_12(ptr nocapture %a, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 13
;
entry:
@ -181,8 +171,6 @@ define void @test_guard_ule_12(ptr nocapture %a, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -214,8 +202,6 @@ define void @test_guard_ule_12_step2(ptr nocapture %a, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -247,8 +233,6 @@ define void @test_multiple_const_guards_order1(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -284,8 +268,6 @@ define void @test_multiple_const_guards_order2(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -321,8 +303,6 @@ define void @test_multiple_var_guards_order1(ptr nocapture %a, i64 %i, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 10
; 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -358,8 +338,6 @@ define void @test_multiple_var_guards_order2(ptr nocapture %a, i64 %i, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 10
; 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -396,8 +374,6 @@ define void @test_multiple_var_guards_cycle(ptr nocapture %a, i64 %i, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -3
; 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -433,8 +409,6 @@ define void @test_guard_ult_ne(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -470,8 +444,6 @@ define void @test_guard_ne_ult(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -509,8 +481,6 @@ define void @test_guard_if_and_enter(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -546,8 +516,6 @@ define void @test_guard_if_and_skip(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -585,8 +553,6 @@ define void @test_guard_if_and_and(ptr nocapture readonly %data, i64 %count, i1
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -625,8 +591,6 @@ define void @test_guard_if_and_or(ptr nocapture readonly %data, i64 %count, i1 %
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -663,8 +627,6 @@ define void @test_guard_if_or_skip(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -700,8 +662,6 @@ define void @test_guard_if_or_enter(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -739,8 +699,6 @@ define void @test_guard_if_or_or(ptr nocapture readonly %data, i64 %count, i1 %c
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -779,8 +737,6 @@ define void @test_guard_if_or_and(ptr nocapture readonly %data, i64 %count, i1 %
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -818,8 +774,6 @@ define void @test_guard_and_assume(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -855,8 +809,6 @@ define void @test_guard_assume_and(ptr nocapture readonly %data, i64 %count) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -894,8 +846,6 @@ define void @guard_pessimizes_analysis_step1(i1 %c, i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -935,8 +885,6 @@ define void @guard_pessimizes_analysis_step2(i1 %c, i32 %N) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -977,17 +925,13 @@ define void @crash(ptr %ptr) {
; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Loop %while.body125: constant max backedge-taken count is i64 -2
; CHECK-NEXT: Loop %while.body125: symbolic max backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Loop %while.body125: Predicated backedge-taken count is {(-2 + (-1 * (ptrtoint ptr %ptr to i64))),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: 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:
br label %while.body
@ -1031,8 +975,6 @@ define void @test_guard_uge(i32 %blockSize) {
; 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 i32 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-NEXT: Loop %while.body: Trip multiple is 1
;
%shr = lshr i32 %blockSize, 2
@ -1068,8 +1010,6 @@ define void @test_guard_ugt(i32 %blockSize) {
; 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 i32 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-NEXT: Loop %while.body: Trip multiple is 1
;
%shr = lshr i32 %blockSize, 2
@ -1105,8 +1045,6 @@ define void @test_guard_uge_and_ule(i32 %blockSize) {
; 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 i32 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-NEXT: Loop %while.body: Trip multiple is 1
;
%shr = lshr i32 %blockSize, 2
@ -1146,8 +1084,6 @@ define void @test_guard_ugt_and_ult(i32 %blockSize) {
; 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 i32 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-NEXT: Loop %while.body: Trip multiple is 1
;
%shr = lshr i32 %blockSize, 2
@ -1189,8 +1125,6 @@ define void @test_guard_slt_sgt_1(ptr nocapture %a, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1226,8 +1160,6 @@ define void @test_guard_slt_sgt_2(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1263,8 +1195,6 @@ define void @test_guard_sle_sge_1(ptr nocapture %a, i64 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1300,8 +1230,6 @@ define void @test_guard_sle_sge_2(ptr nocapture %a, i64 %i) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (17 + (-1 * %i))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1340,8 +1268,6 @@ define void @optimized_range_check_unsigned(ptr %pred, i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1377,8 +1303,6 @@ define void @optimized_range_check_unsigned_icmp_ops_swapped(ptr %pred, i32 %N)
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1416,8 +1340,6 @@ define void @optimized_range_check_unsigned2(ptr %pred, i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1456,8 +1378,6 @@ define void @optimized_range_check_unsigned3(ptr %pred, i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1495,8 +1415,6 @@ define void @not_optimized_range_check_unsigned1(ptr %pred, i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1533,8 +1451,6 @@ define void @not_optimized_range_check_unsigned2(ptr %pred, i32 %N) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1565,8 +1481,6 @@ define i32 @sle_sgt_ult_umax_to_smax(i32 %num) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
guard.1:
@ -1603,8 +1517,6 @@ define i32 @ult_sle_sgt_umax_to_smax(i32 %num) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + %num) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
guard.1:
@ -1640,8 +1552,6 @@ define i32 @ptr_induction_ult_1(ptr %a, ptr %b) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -1670,7 +1580,6 @@ define i32 @ptr_induction_ult_2(ptr %a, ptr %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:
%cmp.6 = icmp ult ptr %a, %b
@ -1701,8 +1610,6 @@ define void @gep_addrec_nw(ptr %a) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 378
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 378
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 378
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 378
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 379
;
entry:

8
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-limit-by-wrapping.ll
View File

@ -10,8 +10,6 @@ define void @max_backedge_taken_count_by_wrapping1_nsw_nuw(i8 %N, ptr %ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -35,8 +33,6 @@ define void @max_backedge_taken_count_by_wrapping1_nuw(i8 %N, ptr %ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -60,8 +56,6 @@ define void @max_backedge_taken_count_by_wrapping2_nsw_nuw(i8 %N, ptr %ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -85,8 +79,6 @@ define void @max_backedge_taken_count_by_wrapping2_nuw(i8 %N, ptr %ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-64 + %N) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/max-be-count-not-constant.ll
View File

@ -23,8 +23,6 @@ define void @pluto(i32 %arg) {
; CHECK-NEXT: Loop %bb2: backedge-taken count is (1 /u (2 + %tmp)<nsw>)
; CHECK-NEXT: Loop %bb2: constant max backedge-taken count is i32 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-NEXT: Loop %bb2: Trip multiple is 1
;
bb:

6
llvm/test/Analysis/ScalarEvolution/max-expr-cache.ll
View File

@ -90,13 +90,10 @@ define void @smax(i32 %tmp3) {
; CHECK-NEXT: Loop %bb53: backedge-taken count is (-1 + (zext i32 (0 smax %tmp49) to i64) + (-1 * undef))
; CHECK-NEXT: Loop %bb53: constant max backedge-taken count is i64 -1
; CHECK-NEXT: Loop %bb53: symbolic max backedge-taken count is (-1 + (zext i32 (0 smax %tmp49) to i64) + (-1 * undef))
; CHECK-NEXT: Loop %bb53: Predicated backedge-taken count is (-1 + (zext i32 (0 smax %tmp49) to i64) + (-1 * undef))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb53: Trip multiple is 1
; CHECK-NEXT: Loop %bb4: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable predicated backedge-taken count.
;
entry:
br label %bb4
@ -252,13 +249,10 @@ define void @umax(i32 %tmp3) {
; CHECK-NEXT: Loop %bb53: backedge-taken count is (-1 + (zext i32 %tmp49 to i64) + (-1 * undef))
; CHECK-NEXT: Loop %bb53: constant max backedge-taken count is i64 -1
; CHECK-NEXT: Loop %bb53: symbolic max backedge-taken count is (-1 + (zext i32 %tmp49 to i64) + (-1 * undef))
; CHECK-NEXT: Loop %bb53: Predicated backedge-taken count is (-1 + (zext i32 %tmp49 to i64) + (-1 * undef))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb53: Trip multiple is 1
; CHECK-NEXT: Loop %bb4: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable predicated backedge-taken count.
;
entry:
br label %bb4

4
llvm/test/Analysis/ScalarEvolution/max-trip-count-address-space.ll
View File

@ -12,8 +12,6 @@ define void @foo(ptr addrspace(1) nocapture %d, i32 %n) nounwind {
; CHECK-NEXT: Loop %bb: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is (-1 + %n)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb: Trip multiple is 1
;
entry:
@ -52,8 +50,6 @@ define void @test(ptr addrspace(1) %a, i32 %n) nounwind {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

32
llvm/test/Analysis/ScalarEvolution/max-trip-count.ll
View File

@ -10,8 +10,6 @@ define void @foo(ptr nocapture %d, i32 %n) nounwind {
; CHECK-NEXT: Loop %bb: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %bb: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %bb: Predicated backedge-taken count is (-1 + %n)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb: Trip multiple is 1
;
entry:
@ -61,7 +59,6 @@ define i32 @main() nounwind {
; CHECK-NEXT: Loop %for.cond: symbolic max backedge-taken count is 5
; CHECK-NEXT: symbolic max exit count for for.cond: 5
; CHECK-NEXT: symbolic max exit count for for.body: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.cond: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.cond
@ -95,8 +92,6 @@ define void @test(ptr %a, i32 %n) nounwind {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (zext i32 %n to i64))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -136,7 +131,6 @@ define i32 @pr19799() {
; CHECK-NEXT: Loop %for.body.i: symbolic max backedge-taken count is 1
; CHECK-NEXT: symbolic max exit count for for.body.i: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for for.cond.i: 1
; CHECK-NEXT: Loop %for.body.i: Unpredictable predicated backedge-taken count.
;
entry:
store i32 -1, ptr @a, align 4
@ -170,7 +164,6 @@ define i32 @pr18886() {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 3
; CHECK-NEXT: symbolic max exit count for for.body: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for for.cond: 3
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
store i64 -21, ptr @aa, align 8
@ -208,7 +201,6 @@ define i32 @cannot_compute_mustexit() {
; CHECK-NEXT: Loop %for.body.i: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for for.body.i: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for for.cond.i: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.body.i: Unpredictable predicated backedge-taken count.
;
entry:
store i32 -1, ptr @a, align 4
@ -243,8 +235,6 @@ define i32 @two_mustexit() {
; CHECK-NEXT: Loop %for.body.i: symbolic max backedge-taken count is 1
; CHECK-NEXT: symbolic max exit count for for.body.i: 1
; CHECK-NEXT: symbolic max exit count for for.cond.i: 2
; CHECK-NEXT: Loop %for.body.i: Predicated backedge-taken count is 1
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body.i: Trip multiple is 1
;
entry:
@ -272,8 +262,6 @@ define i32 @ne_max_trip_count_1(i32 %n) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (zext i3 (trunc i32 %n to i3) to i32)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 7
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (zext i3 (trunc i32 %n to i3) to i32)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (zext i3 (trunc i32 %n to i3) to i32)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -296,8 +284,6 @@ define i32 @ne_max_trip_count_2(i32 %n) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -320,8 +306,6 @@ define i32 @ne_max_trip_count_3(i32 %n) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 6
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (zext i3 (trunc i32 %n to i3) to i32))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -351,8 +335,6 @@ define i32 @ne_max_trip_count_4(i32 %n) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -2
; 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -383,7 +365,6 @@ define void @changing_end_bound(ptr %n_addr, ptr %addr) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2147483646
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -412,7 +393,6 @@ define void @changing_end_bound2(i32 %start, ptr %n_addr, ptr %addr) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is -1
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -439,7 +419,6 @@ define void @changing_end_bound3(i32 %start, ptr %n_addr, ptr %addr) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 1073741823
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 1073741823
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -467,7 +446,6 @@ define void @changing_end_bound4(i32 %start, ptr %n_addr, ptr %addr) {
; 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:
br label %loop
@ -495,7 +473,6 @@ define void @changing_end_bound5(i32 %stride, i32 %start, ptr %n_addr, ptr %addr
; 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:
br label %loop
@ -522,7 +499,6 @@ define void @changing_end_bound6(i32 %start, ptr %n_addr, ptr %addr) {
; 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:
br label %loop
@ -549,7 +525,6 @@ define void @changing_end_bound7(i32 %start, ptr %n_addr, ptr %addr) {
; 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:
br label %loop
@ -575,8 +550,6 @@ define void @max_overflow_se(i8 %n) mustprogress {
; CHECK-NEXT: Loop %loop: backedge-taken count is 0
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -604,7 +577,6 @@ define void @max_overflow_me(i8 %n) mustprogress {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 1
; CHECK-NEXT: symbolic max exit count for loop: 1
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -632,8 +604,6 @@ define void @bool_stride(i1 %s, i1 %n) mustprogress {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -658,8 +628,6 @@ define void @ne_zero_max_btc(i32 %a) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/min-max-exprs.ll
View File

@ -49,8 +49,6 @@ define void @f(ptr %A, i32 %N) {
; CHECK-NEXT: Loop %bb1: backedge-taken count is (0 smax %N)
; CHECK-NEXT: Loop %bb1: constant max backedge-taken count is i32 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-NEXT: Loop %bb1: Trip multiple is 1
;
bb:

18
llvm/test/Analysis/ScalarEvolution/ne-overflow.ll
View File

@ -13,8 +13,6 @@ define void @test(i32 %N) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-2 + %N) /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -36,8 +34,6 @@ define void @test_preinc(i32 %N) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -62,7 +58,6 @@ define void @test_well_defined_infinite_st(i32 %N) 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:
br label %for.body
@ -84,7 +79,6 @@ define void @test_well_defined_infinite_ld(i32 %N) 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:
br label %for.body
@ -106,7 +100,6 @@ define void @test_no_mustprogress(i32 %N) {
; 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
@ -129,8 +122,6 @@ define void @test_1024(i32 %N) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-1024 + %N) /u 1024)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -152,8 +143,6 @@ define void @test_uneven_divide(i32 %N) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (-1431655765 * %N))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -175,7 +164,6 @@ define void @test_non_invariant_rhs() 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:
br label %for.body
@ -199,7 +187,6 @@ define void @test_abnormal_exit(i32 %N) 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:
br label %for.body
@ -226,7 +213,6 @@ define void @test_other_exit(i32 %N) mustprogress {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 9
; CHECK-NEXT: symbolic max exit count for for.body: 9
; CHECK-NEXT: symbolic max exit count for for.latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %for.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body
@ -275,7 +261,6 @@ define void @test_sext(i64 %N) 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:
br label %for.body
@ -297,7 +282,6 @@ define void @test_zext_of_sext(i64 %N) 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:
br label %for.body
@ -320,7 +304,6 @@ define void @test_zext_offset(i64 %N) 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:
br label %for.body
@ -343,7 +326,6 @@ define void @test_sext_offset(i64 %N) 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:
br label %for.body

2
llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
View File

@ -306,7 +306,6 @@ define i1 @test2_a(i32 %a, i32 %b, i1 %will_overflow) {
; 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:
br i1 %will_overflow, label %exit1, label %loop
@ -343,7 +342,6 @@ define i1 @test2_b(i32 %a, i32 %b, i1 %will_overflow) {
; 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:
br i1 %will_overflow, label %exit1, label %loop

6
llvm/test/Analysis/ScalarEvolution/no-wrap-symbolic-becount.ll
View File

@ -30,7 +30,6 @@ define i32 @test_01(i32 %start, ptr %p, ptr %q) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (zext i32 %start to i64)
; CHECK-NEXT: symbolic max exit count for loop: (zext i32 %start to i64)
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%0 = zext i32 %start to i64
@ -76,8 +75,6 @@ define i32 @test_02(i32 %start, ptr %p, ptr %q) {
; 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 i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -108,7 +105,6 @@ define void @pointer_iv_nowrap(ptr %startptr, ptr %endptr) local_unnamed_addr {
; 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:
%init = getelementptr inbounds i8, ptr %startptr, i64 2000
@ -137,8 +133,6 @@ define void @pointer_iv_nowrap_guard(ptr %startptr, ptr %endptr) local_unnamed_a
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 4611686018427387903
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-8001 + (-1 * (ptrtoint ptr %startptr to i64)) + ((8004 + (ptrtoint ptr %startptr to i64)) umax (ptrtoint ptr %endptr to i64))) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
View File

@ -47,8 +47,6 @@ define void @foo(i32 %no, ptr nocapture %d, ptr nocapture %q) nounwind {
; 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 i32 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-NEXT: Loop %bb: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/nsw-offset.ll
View File

@ -44,8 +44,6 @@ define void @foo(i32 %no, ptr nocapture %d, ptr nocapture %q) nounwind {
; 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 i32 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-NEXT: Loop %bb: Trip multiple is 1
;
entry:

21
llvm/test/Analysis/ScalarEvolution/nsw.ll
View File

@ -30,7 +30,6 @@ define void @test1(ptr %p) nounwind {
; 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:
%tmp = load double, ptr %p, align 8 ; <double> [#uses=1]
@ -79,8 +78,6 @@ define void @test2(ptr %begin, ptr %end) ssp {
; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903
; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body.i.i: Trip multiple is 1
;
entry:
@ -120,8 +117,6 @@ define void @test3(ptr %begin, ptr %end) nounwind ssp {
; CHECK-NEXT: Loop %for.body.i.i: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: constant max backedge-taken count is i64 4611686018427387903
; CHECK-NEXT: Loop %for.body.i.i: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Loop %for.body.i.i: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %begin to i64)) + (ptrtoint ptr %end to i64)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body.i.i: Trip multiple is 1
;
entry:
@ -183,8 +178,6 @@ define i32 @PR12375(ptr readnone %arg) {
; CHECK-NEXT: Loop %bb1: backedge-taken count is 1
; CHECK-NEXT: Loop %bb1: constant max backedge-taken count is i64 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-NEXT: Loop %bb1: Trip multiple is 2
;
bb:
@ -214,8 +207,6 @@ define void @PR12376(ptr nocapture %arg, ptr nocapture %arg1) {
; CHECK-NEXT: Loop %bb2: backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4)
; CHECK-NEXT: Loop %bb2: constant max backedge-taken count is i64 4611686018427387902
; CHECK-NEXT: Loop %bb2: symbolic max backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4)
; CHECK-NEXT: Loop %bb2: Predicated backedge-taken count is ((-1 + (-1 * (ptrtoint ptr %arg to i64)) + ((4 + (ptrtoint ptr %arg to i64))<nuw> umax (ptrtoint ptr %arg1 to i64))) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb2: Trip multiple is 1
;
bb:
@ -250,8 +241,6 @@ define void @nswnowrap(i32 %v, ptr %buf) {
; 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 i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -293,8 +282,6 @@ define void @test4(i32 %arg) {
; 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 i32 -2147483639
; 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -327,8 +314,6 @@ define void @bad_postinc_nsw_a(i32 %n) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -359,7 +344,6 @@ define void @postinc_poison_prop_through_and(i32 %n) {
; 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:
br label %loop
@ -388,8 +372,6 @@ define void @pr28012(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (7 umax %n)) /u 7)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -421,7 +403,6 @@ define void @select_cond_poison_propagation(ptr %p, i32 %x) nounwind {
; 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:
br label %loop
@ -453,8 +434,6 @@ define void @pr66066() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 1
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 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-NEXT: Loop %loop: Trip multiple is 2
;
entry:

4
llvm/test/Analysis/ScalarEvolution/outer_phi.ll
View File

@ -24,7 +24,6 @@ define i32 @test_01(i32 %a, i32 %b) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is %b
; CHECK-NEXT: symbolic max exit count for inner: %b
; CHECK-NEXT: symbolic max exit count for inner.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: 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***
@ -32,7 +31,6 @@ define i32 @test_01(i32 %a, i32 %b) {
; CHECK-NEXT: Loop %outer: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for inner: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for outer.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %outer: Unpredictable predicated backedge-taken count.
;
entry:
%b_is_non_negative = icmp sge i32 %b, 0
@ -88,7 +86,6 @@ define i32 @test_02(i32 %a, i32 %b) {
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ((-1 * %outer.iv) + (%b smax %outer.iv))
; CHECK-NEXT: symbolic max exit count for inner: ((-1 * %outer.iv) + (%b smax %outer.iv))
; CHECK-NEXT: symbolic max exit count for inner.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: 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***
@ -96,7 +93,6 @@ define i32 @test_02(i32 %a, i32 %b) {
; CHECK-NEXT: Loop %outer: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for inner: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for outer.backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %outer: Unpredictable predicated backedge-taken count.
;
entry:
%b_is_non_negative = icmp sge i32 %b, 0

26
llvm/test/Analysis/ScalarEvolution/overflow-intrinsics-trip-count.ll
View File

@ -14,8 +14,6 @@ define void @uadd_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 35
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 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-NEXT: Loop %for.body: Trip multiple is 36
;
entry:
@ -41,8 +39,6 @@ define void @sadd_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 67
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 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-NEXT: Loop %for.body: Trip multiple is 68
;
entry:
@ -68,8 +64,6 @@ define void @usub_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 50
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 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-NEXT: Loop %for.body: Trip multiple is 51
;
entry:
@ -95,8 +89,6 @@ define void @ssub_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 68
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 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-NEXT: Loop %for.body: Trip multiple is 69
;
entry:
@ -122,8 +114,6 @@ define void @smul_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 14
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 15
;
entry:
@ -149,8 +139,6 @@ define void @umul_exhaustive() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 15
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 16
;
entry:
@ -176,8 +164,6 @@ define void @uadd_symbolic_start(i16 %start) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -203,8 +189,6 @@ define void @sadd_symbolic_start(i16 %start) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (32767 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -230,7 +214,6 @@ define void @sadd_symbolic_start2(i16 %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:
br i1 undef, label %for.end, label %for.body.preheader
@ -256,7 +239,6 @@ define void @sadd_symbolic_swapped(i16 %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:
br i1 undef, label %for.end, label %for.body.preheader
@ -281,8 +263,6 @@ define void @usub_symbolic_start(i16 %start) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is %start
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -308,8 +288,6 @@ define void @ssub_symbolic_start(i16 %start) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-32768 + %start)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -335,7 +313,6 @@ define void @smul_symbolic_start(i16 %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:
br i1 undef, label %for.end, label %for.body.preheader
@ -360,7 +337,6 @@ define void @umul_symbolic_start(i16 %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:
br i1 undef, label %for.end, label %for.body.preheader
@ -389,8 +365,6 @@ define void @sadd_symbolic_non_latch(i16 %start) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((230 + (-1 * %start)) umin (32767 + (-1 * %start)))
; CHECK-NEXT: symbolic max exit count for for.body: (32767 + (-1 * %start))
; CHECK-NEXT: symbolic max exit count for for.latch: (230 + (-1 * %start))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((230 + (-1 * %start)) umin (32767 + (-1 * %start)))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

9
llvm/test/Analysis/ScalarEvolution/pr25369.ll
View File

@ -11,19 +11,14 @@ define void @hoge1() {
; CHECK-NEXT: Loop %bb13: backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Loop %bb13: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %bb13: symbolic max backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Loop %bb13: Predicated backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb13: Trip multiple is 1
; CHECK-NEXT: Loop %bb4: backedge-taken count is 20
; CHECK-NEXT: Loop %bb4: constant max backedge-taken count is i64 20
; CHECK-NEXT: Loop %bb4: symbolic max backedge-taken count is 20
; CHECK-NEXT: Loop %bb4: Predicated backedge-taken count is 20
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb4: Trip multiple is 21
; CHECK-NEXT: Loop %bb2: 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.
;
bb:
br i1 undef, label %bb4, label %bb2
@ -65,17 +60,13 @@ define void @hoge2() {
; CHECK-NEXT: Loop %bb13: backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Loop %bb13: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %bb13: symbolic max backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Loop %bb13: Predicated backedge-taken count is (-2 + (2 * undef) + %tmp7 + %tmp6)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %bb13: Trip multiple is 1
; CHECK-NEXT: Loop %bb4: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %bb4: Unpredictable predicated backedge-taken count.
; CHECK-NEXT: Loop %bb2: 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.
;
bb:
br i1 undef, label %bb4, label %bb2

4
llvm/test/Analysis/ScalarEvolution/pr34538.ll
View File

@ -7,8 +7,6 @@ define i32 @pr34538() local_unnamed_addr #0 {
; CHECK-NEXT: Loop %do.body: backedge-taken count is 10000
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is i32 10000
; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is 10000
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is 10000
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %do.body: Trip multiple is 10001
;
entry:
@ -32,8 +30,6 @@ define i32 @foo() {
; CHECK-NEXT: Loop %do.body: backedge-taken count is 5000
; CHECK-NEXT: Loop %do.body: constant max backedge-taken count is i32 5000
; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is 5000
; CHECK-NEXT: Loop %do.body: Predicated backedge-taken count is 5000
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %do.body: Trip multiple is 5001
;
entry:

2
llvm/test/Analysis/ScalarEvolution/pr48225.ll
View File

@ -28,7 +28,6 @@ define void @test_and(i1 %boolcond) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2
; CHECK-NEXT: symbolic max exit count for loop: 2
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%conv = zext i1 %boolcond to i32
@ -78,7 +77,6 @@ define void @test_or(i1 %boolcond) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 2
; CHECK-NEXT: symbolic max exit count for loop: 2
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%conv = zext i1 %boolcond to i32

1
llvm/test/Analysis/ScalarEvolution/pr58402-large-number-of-zext-exprs.ll
View File

@ -82,7 +82,6 @@ define i32 @pr58402_large_number_of_zext(ptr %dst) {
; CHECK-NEXT: Loop %header: <multiple exits> 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:
br label %header

1
llvm/test/Analysis/ScalarEvolution/pr76234.ll
View File

@ -13,7 +13,6 @@ define i32 @PR76234() {
; CHECK-NEXT: Loop %1: <multiple exits> Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %1: Unpredictable constant max backedge-taken count.
; CHECK-NEXT: Loop %1: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: Loop %1: Unpredictable predicated backedge-taken count.
;
%B9 = shl i896 0, -264147265567832623176169892458258303259423663018060761063980354513336951278362429737208627943828593947337197496628564339441173779751342768625269489231469788454193341999502542084365758838213220526512116454105594202074014146375780869419198449383518238244769290448868999168
br label %1

21
llvm/test/Analysis/ScalarEvolution/ptrtoint-constantexpr-loop.ll
View File

@ -24,7 +24,6 @@ define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) {
; 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'
; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i64
@ -42,7 +41,6 @@ define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) {
; 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'
; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i64
@ -60,7 +58,6 @@ define hidden ptr @trunc_ptr_to_i64(ptr %arg, ptr %arg10) {
; 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.
;
bb:
br label %bb11
@ -97,7 +94,6 @@ define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) {
; 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'
; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i32
@ -115,7 +111,6 @@ define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) {
; 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'
; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i32
@ -133,7 +128,6 @@ define hidden ptr @trunc_ptr_to_i32(ptr %arg, ptr %arg10) {
; 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.
;
bb:
br label %bb11
@ -170,7 +164,6 @@ define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) {
; 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'
; PTR64_IDX32-NEXT: Classifying expressions for: @trunc_ptr_to_i128
@ -188,7 +181,6 @@ define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) {
; 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'
; PTR16_IDX16-NEXT: Classifying expressions for: @trunc_ptr_to_i128
@ -206,7 +198,6 @@ define hidden ptr @trunc_ptr_to_i128(ptr %arg, ptr %arg10) {
; 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.
;
bb:
br label %bb11
@ -238,7 +229,6 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; 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'
; PTR64_IDX32-NEXT: Classifying expressions for: @zext_ptr_to_i32
@ -250,7 +240,6 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; 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'
; PTR16_IDX16-NEXT: Classifying expressions for: @zext_ptr_to_i32
@ -262,7 +251,6 @@ define void @zext_ptr_to_i32(i32 %arg, i32 %arg6) {
; 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.
;
bb:
br label %bb7
@ -291,7 +279,6 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; 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'
; PTR64_IDX32-NEXT: Classifying expressions for: @sext_to_i32
@ -305,7 +292,6 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; 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'
; PTR16_IDX16-NEXT: Classifying expressions for: @sext_to_i32
@ -319,7 +305,6 @@ define void @sext_to_i32(i32 %arg, i32 %arg6) {
; 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.
;
bb:
br label %bb7
@ -351,8 +336,6 @@ define i64 @sext_like_noop(i32 %n) {
; PTR64_IDX64-NEXT: Loop %for.body: backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; PTR64_IDX64-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (trunc i64 (ptrtoint ptr @sext_like_noop to i64) to i32))
; PTR64_IDX64-NEXT: Predicates:
; PTR64_IDX64-NEXT: Loop %for.body: Trip multiple is 1
;
; PTR64_IDX32-LABEL: 'sext_like_noop'
@ -369,8 +352,6 @@ define i64 @sext_like_noop(i32 %n) {
; PTR64_IDX32-NEXT: Loop %for.body: backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; PTR64_IDX32-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + ptrtoint (ptr @sext_like_noop to i32))
; PTR64_IDX32-NEXT: Predicates:
; PTR64_IDX32-NEXT: Loop %for.body: Trip multiple is 1
;
; PTR16_IDX16-LABEL: 'sext_like_noop'
@ -387,8 +368,6 @@ define i64 @sext_like_noop(i32 %n) {
; PTR16_IDX16-NEXT: Loop %for.body: backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; PTR16_IDX16-NEXT: Loop %for.body: symbolic max backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Loop %for.body: Predicated backedge-taken count is (-2 + (zext i16 (ptrtoint ptr @sext_like_noop to i16) to i32))<nsw>
; PTR16_IDX16-NEXT: Predicates:
; PTR16_IDX16-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

14
llvm/test/Analysis/ScalarEvolution/ptrtoint.ll
View File

@ -231,8 +231,6 @@ define void @ptrtoint_of_addrec(ptr %in, i32 %count) {
; 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 i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
; X32-LABEL: 'ptrtoint_of_addrec'
@ -251,8 +249,6 @@ define void @ptrtoint_of_addrec(ptr %in, i32 %count) {
; 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 i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -399,8 +395,6 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; X64-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64))
; X64-NEXT: Loop %bb6: constant max backedge-taken count is i64 -1
; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64))
; X64-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64))
; X64-NEXT: Predicates:
; X64-NEXT: Loop %bb6: Trip multiple is 1
;
; X32-LABEL: 'pr46786_c26_char'
@ -427,8 +421,6 @@ define void @pr46786_c26_char(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: Loop %bb6: backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32))
; X32-NEXT: Loop %bb6: constant max backedge-taken count is i32 -1
; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32))
; X32-NEXT: Loop %bb6: Predicated backedge-taken count is (-1 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32))
; X32-NEXT: Predicates:
; X32-NEXT: Loop %bb6: Trip multiple is 1
;
%i = icmp eq ptr %arg, %arg1
@ -488,8 +480,6 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; X64-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)
; X64-NEXT: Loop %bb6: constant max backedge-taken count is i64 4611686018427387903
; X64-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)
; X64-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i64)) + (ptrtoint ptr %arg1 to i64)) /u 4)
; X64-NEXT: Predicates:
; X64-NEXT: Loop %bb6: Trip multiple is 1
;
; X32-LABEL: 'pr46786_c26_int'
@ -518,8 +508,6 @@ define void @pr46786_c26_int(ptr %arg, ptr %arg1, ptr %arg2) {
; X32-NEXT: Loop %bb6: backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)
; X32-NEXT: Loop %bb6: constant max backedge-taken count is i32 1073741823
; X32-NEXT: Loop %bb6: symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)
; X32-NEXT: Loop %bb6: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %arg to i32)) + (ptrtoint ptr %arg1 to i32)) /u 4)
; X32-NEXT: Predicates:
; X32-NEXT: Loop %bb6: Trip multiple is 1
;
%i = icmp eq ptr %arg, %arg1
@ -568,7 +556,6 @@ define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_ad
; X64-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64))
; X64-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE***
; X64-NEXT: symbolic max exit count for bb10: (-2 + (-1 * %arg1) + (ptrtoint ptr %arg to i64))
; X64-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
;
; X32-LABEL: 'ptrtoint_of_integer'
; X32-NEXT: Classifying expressions for: @ptrtoint_of_integer
@ -588,7 +575,6 @@ define void @ptrtoint_of_integer(ptr %arg, i64 %arg1, i1 %arg2) local_unnamed_ad
; X32-NEXT: Loop %bb8: symbolic max backedge-taken count is (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1))
; X32-NEXT: symbolic max exit count for bb8: ***COULDNOTCOMPUTE***
; X32-NEXT: symbolic max exit count for bb10: (-2 + (zext i32 (ptrtoint ptr %arg to i32) to i64) + (-1 * %arg1))
; X32-NEXT: Loop %bb8: Unpredictable predicated backedge-taken count.
;
bb:
%i = icmp eq ptr %arg, null

3
llvm/test/Analysis/ScalarEvolution/range-signedness.ll
View File

@ -14,7 +14,6 @@ define void @x(ptr %cond) {
; 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:
br label %loop
@ -42,8 +41,6 @@ define void @y(ptr %addr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 10
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 10
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 10
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 10
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 11
;
entry:

12
llvm/test/Analysis/ScalarEvolution/range_nw_flag.ll
View File

@ -17,8 +17,6 @@ define void @test-add-nuw(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -53,8 +51,6 @@ define void @test-addrec-nuw(ptr %input, i32 %offset, i32 %numIterations) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -91,8 +87,6 @@ define void @test-addrec-nsw-start-neg-strip-neg(ptr %input, i32 %offset, i32 %n
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -129,8 +123,6 @@ define void @test-addrec-nsw-start-pos-strip-neg(ptr %input, i32 %offset, i32 %n
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (-1 * %numIterations))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -167,8 +159,6 @@ define void @test-addrec-nsw-start-pos-strip-pos(ptr %input, i32 %offset, i32 %n
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -205,8 +195,6 @@ define void @test-addrec-nsw-start-neg-strip-pos(ptr %input, i32 %offset, i32 %n
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %numIterations)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

22
llvm/test/Analysis/ScalarEvolution/ranges.ll
View File

@ -116,7 +116,6 @@ define i32 @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:
br label %loop
@ -138,8 +137,6 @@ define void @add_6(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 715827882
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -165,8 +162,6 @@ define void @add_7(i32 %n) {
; 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 i32 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -192,8 +187,6 @@ define void @add_8(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((7 + %n) /u 8)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 536870911
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((7 + %n) /u 8)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((7 + %n) /u 8)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -220,8 +213,6 @@ define void @add_9(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 477218588
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -248,8 +239,6 @@ define void @add_10(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 429496729
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -276,7 +265,6 @@ define void @add_8_wrap(i32 %n) {
; 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:
br label %loop
@ -302,7 +290,6 @@ define void @add_10_wrap(i32 %n) {
; 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:
br label %loop
@ -328,7 +315,6 @@ define void @mul_6(i32 %n) {
; 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:
br label %loop
@ -354,7 +340,6 @@ define void @mul_7(i32 %n) {
; 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:
br label %loop
@ -380,7 +365,6 @@ define void @mul_8(i32 %n) {
; 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:
br label %loop
@ -406,7 +390,6 @@ define void @mul_9(i32 %n) {
; 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:
br label %loop
@ -432,7 +415,6 @@ define void @mul_10(i32 %n) {
; 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:
br label %loop
@ -458,7 +440,6 @@ define void @mul_8_wrap(i32 %n) {
; 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:
br label %loop
@ -484,7 +465,6 @@ define void @mul_10_wrap(i32 %n) {
; 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:
br label %loop
@ -513,8 +493,6 @@ define void @truncate(i16 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 7281
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/sdiv.ll
View File

@ -33,8 +33,6 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-NEXT: Loop %for.cond: backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is i32 -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-NEXT: Loop %for.cond: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/sext-add-inreg-loop.ll
View File

@ -26,8 +26,6 @@ define dso_local i32 @test_loop(ptr nocapture noundef readonly %x) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 8
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 8
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is 8
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 8
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 9
;
entry:

4
llvm/test/Analysis/ScalarEvolution/sext-mul.ll
View File

@ -32,8 +32,6 @@ define void @foo(ptr nocapture %arg, i32 %arg1, i32 %arg2) {
; 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 i64 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-NEXT: Loop %bb7: Trip multiple is 1
;
bb:
@ -99,8 +97,6 @@ define void @goo(ptr nocapture %arg3, i32 %arg4, i32 %arg5) {
; 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 i128 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-NEXT: Loop %bb7: Trip multiple is 1
;
bb:

2
llvm/test/Analysis/ScalarEvolution/sext-to-zext.ll
View File

@ -22,8 +22,6 @@ define void @f(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 99
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 100
;
entry:

10
llvm/test/Analysis/ScalarEvolution/shift-op.ll
View File

@ -8,7 +8,6 @@ define void @test0(i32 %init) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 32
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 32
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -30,7 +29,6 @@ define void @test1(i32 %init) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 32
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 32
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -54,7 +52,6 @@ define void @test2(i32 %init) {
; 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:
br label %loop
@ -76,7 +73,6 @@ define void @test3(ptr %init.ptr) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 32
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 32
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%init = load i32, ptr %init.ptr, !range !0
@ -99,7 +95,6 @@ define void @test4(ptr %init.ptr) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 32
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 32
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
%init = load i32, ptr %init.ptr, !range !1
@ -123,7 +118,6 @@ define void @test5(ptr %init.ptr) {
; 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:
%init = load i32, ptr %init.ptr, !range !1
@ -147,7 +141,6 @@ define void @test6(i32 %init, i32 %shift.amt) {
; 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:
br label %loop
@ -169,7 +162,6 @@ define void @test7(i32 %init) {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 32
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 32
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -193,7 +185,6 @@ define void @test8(i32 %init) {
; 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:
br label %loop
@ -217,7 +208,6 @@ define void @test9() {
; 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:
br label %loop

44
llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll
View File

@ -12,7 +12,6 @@ define void @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:
br label %loop
@ -36,7 +35,6 @@ define void @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:
br label %loop
@ -60,7 +58,6 @@ define void @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:
br label %loop
@ -83,7 +80,6 @@ define void @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:
br label %loop
@ -107,7 +103,6 @@ define void @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:
br label %loop
@ -132,7 +127,6 @@ define void @test_ashr_unknown(i64 %start) {
; 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:
br label %loop
@ -157,7 +151,6 @@ define void @test_ashr_wrong_op(i64 %start) {
; 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:
br label %loop
@ -181,7 +174,6 @@ define void @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:
br label %loop
@ -209,8 +201,6 @@ define void @test_shl2() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -244,8 +234,6 @@ define void @test_shl3(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -278,8 +266,6 @@ define void @test_shl4() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 60
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 61
;
entry:
@ -311,8 +297,6 @@ define void @test_shl5() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 61
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 62
;
entry:
@ -346,8 +330,6 @@ define void @test_shl6(i1 %c) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -380,8 +362,6 @@ define void @test_shl7(i1 %c, i64 %shiftamt) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -434,7 +414,6 @@ define void @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:
br label %header
@ -492,7 +471,6 @@ define void @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:
br label %loop
@ -527,8 +505,6 @@ define void @test_ashr_tc_positive() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -559,8 +535,6 @@ define void @test_ashr_tc_negative() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -593,8 +567,6 @@ define void @test_ashr_tc_either(i1 %a) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 60
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 61
;
entry:
@ -626,8 +598,6 @@ define void @test_ashr_zero_shift() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -658,8 +628,6 @@ define void @test_lshr_tc_positive() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -690,8 +658,6 @@ define void @test_lshr_tc_negative() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -724,8 +690,6 @@ define void @test_lshr_tc_either(i1 %a) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -757,8 +721,6 @@ define void @test_lshr_zero_shift() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -790,8 +752,6 @@ define void @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 i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -823,8 +783,6 @@ define void @test_lshr_arbitrary_start() {
; CHECK-NEXT: Loop %loop: backedge-taken count is 4
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:
@ -855,8 +813,6 @@ define void @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 i64 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-NEXT: Loop %loop: Trip multiple is 5
;
entry:

2
llvm/test/Analysis/ScalarEvolution/sle.ll
View File

@ -10,8 +10,6 @@ define void @le(i64 %n, ptr nocapture %p) nounwind {
; CHECK-NEXT: Loop %for.body: backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 9223372036854775807
; 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

4
llvm/test/Analysis/ScalarEvolution/smax-br-phi-idioms.ll
View File

@ -82,7 +82,6 @@ define i32 @f3(i32 %x, i32 %init, i32 %lim) {
; 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:
br label %loop
@ -121,7 +120,6 @@ define i32 @f4(i32 %x, i32 %init, i32 %lim) {
; 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:
%c = icmp sge i32 %init, 0
@ -161,8 +159,6 @@ define i32 @f5(ptr %val) {
; CHECK-NEXT: Loop %for.end: symbolic max backedge-taken count is false
; CHECK-NEXT: symbolic max exit count for for.end: false
; CHECK-NEXT: symbolic max exit count for for.condt: false
; CHECK-NEXT: Loop %for.end: Predicated backedge-taken count is false
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.end: Trip multiple is 1
;
entry:

6
llvm/test/Analysis/ScalarEvolution/smin-smax-folds.ll
View File

@ -36,8 +36,6 @@ define void @smin_simplify_with_guard(i32 %n) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -73,8 +71,6 @@ define void @smin_to_smax(i32 %n) {
; 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 i32 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -109,8 +105,6 @@ define void @smax_simplify_with_guard(i32 %start, i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 * %start) + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -1
; 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

5
llvm/test/Analysis/ScalarEvolution/solve-quadratic-i1.ll
View File

@ -20,8 +20,6 @@ define void @f0() {
; CHECK-NEXT: Loop %b1: backedge-taken count is 1
; CHECK-NEXT: Loop %b1: constant max backedge-taken count is i6 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-NEXT: Loop %b1: Trip multiple is 2
;
b0:
@ -67,12 +65,9 @@ define void @f1() #0 {
; 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 i6 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-NEXT: Loop %b1: Trip multiple is 3
;
b0:

2
llvm/test/Analysis/ScalarEvolution/solve-quadratic-overflow.ll
View File

@ -26,8 +26,6 @@ define signext i32 @f0() {
; CHECK-NEXT: Loop %b1: backedge-taken count is 255
; CHECK-NEXT: Loop %b1: constant max backedge-taken count is i16 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-NEXT: Loop %b1: Trip multiple is 256
;
b0:

2
llvm/test/Analysis/ScalarEvolution/srem.ll
View File

@ -33,8 +33,6 @@ define dso_local void @_Z4loopi(i32 %width) local_unnamed_addr #0 {
; CHECK-NEXT: Loop %for.cond: backedge-taken count is %width
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is i32 -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-NEXT: Loop %for.cond: Trip multiple is 1
;
entry:

12
llvm/test/Analysis/ScalarEvolution/symbolic_max_exit_count.ll
View File

@ -24,7 +24,6 @@ define i32 @test_simple_case(i32 %start, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: %start
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -83,7 +82,6 @@ define i32 @test_litter_conditions(i32 %start, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: %start
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -146,7 +144,6 @@ define i32 @test_litter_conditions_bad_context(i32 %start, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: %start
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -201,7 +198,6 @@ define i32 @test_and_conditions(i32 %start, i32 %len) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is %start
; CHECK-NEXT: symbolic max exit count for loop: %start
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -245,7 +241,6 @@ define i32 @test_mixup_constant_symbolic(i32 %end, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: %end
; CHECK-NEXT: symbolic max exit count for range_check_block: 1000
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -293,7 +288,6 @@ define i32 @test_mixup_constant_symbolic_merged(i32 %end, i32 %len) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (1000 umin %end)
; CHECK-NEXT: symbolic max exit count for loop: (1000 umin %end)
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -352,7 +346,6 @@ define i32 @test_two_phis(i32 %start_1, i32 %start_2, i32 %len) {
; CHECK-NEXT: symbolic max exit count for zero_check_block: %start_2
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -411,8 +404,6 @@ define i32 @test_two_phis_simple(i32 %start_1, i32 %start_2, i32 %len) {
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (%start_1 umin_seq %start_2)
; CHECK-NEXT: symbolic max exit count for loop: %start_1
; CHECK-NEXT: symbolic max exit count for backedge: %start_2
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%start_1 umin_seq %start_2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -469,7 +460,6 @@ define i32 @test_two_phis_arithmetic_and(i32 %start_1, i32 %start_2, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: (%start_1 umin %start_2)
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -543,7 +533,6 @@ define i32 @test_two_phis_logical_or(i32 %start_1, i32 %start_2, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop
@ -616,7 +605,6 @@ define i32 @test_two_phis_logical_and(i32 %start_1, i32 %start_2, i32 %len) {
; CHECK-NEXT: symbolic max exit count for loop: (%start_1 umin_seq %start_2)
; CHECK-NEXT: symbolic max exit count for range_check_block: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for backedge: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop

28
llvm/test/Analysis/ScalarEvolution/trip-count-andor-selectform.ll
View File

@ -10,8 +10,6 @@ define void @unsimplified_and1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -34,8 +32,6 @@ define void @unsimplified_and2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -58,8 +54,6 @@ define void @unsimplified_and3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -82,8 +76,6 @@ define void @unsimplified_and4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -106,7 +98,6 @@ define void @unsimplified_or1(i32 %n) {
; 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:
br label %loop
@ -128,7 +119,6 @@ define void @unsimplified_or2(i32 %n) {
; 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:
br label %loop
@ -150,8 +140,6 @@ define void @unsimplified_or3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -174,8 +162,6 @@ define void @unsimplified_or4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -198,8 +184,6 @@ define void @reversed_and1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -222,8 +206,6 @@ define void @reversed_and2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -246,7 +228,6 @@ define void @reversed_and3(i32 %n) {
; 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:
br label %loop
@ -268,7 +249,6 @@ define void @reversed_and4(i32 %n) {
; 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:
br label %loop
@ -290,8 +270,6 @@ define void @reversed_or1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -314,8 +292,6 @@ define void @reversed_or2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -338,8 +314,6 @@ define void @reversed_or3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -362,8 +336,6 @@ define void @reversed_or4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

28
llvm/test/Analysis/ScalarEvolution/trip-count-andor.ll
View File

@ -10,8 +10,6 @@ define void @unsimplified_and1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -34,8 +32,6 @@ define void @unsimplified_and2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -58,8 +54,6 @@ define void @unsimplified_and3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -82,8 +76,6 @@ define void @unsimplified_and4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -106,7 +98,6 @@ define void @unsimplified_or1(i32 %n) {
; 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:
br label %loop
@ -128,7 +119,6 @@ define void @unsimplified_or2(i32 %n) {
; 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:
br label %loop
@ -150,8 +140,6 @@ define void @unsimplified_or3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -174,8 +162,6 @@ define void @unsimplified_or4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -198,8 +184,6 @@ define void @reversed_and1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -222,8 +206,6 @@ define void @reversed_and2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -246,7 +228,6 @@ define void @reversed_and3(i32 %n) {
; 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:
br label %loop
@ -268,7 +249,6 @@ define void @reversed_and4(i32 %n) {
; 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:
br label %loop
@ -290,8 +270,6 @@ define void @reversed_or1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -314,8 +292,6 @@ define void @reversed_or2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -338,8 +314,6 @@ define void @reversed_or3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -362,8 +336,6 @@ define void @reversed_or4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is %n
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

18
llvm/test/Analysis/ScalarEvolution/trip-count-implied-addrec.ll
View File

@ -15,8 +15,6 @@ define void @nw_implies_nuw(i16 %n) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is %n
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -39,7 +37,6 @@ define void @neg_nw_nuw(i16 %n) 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:
br label %for.body
@ -85,7 +82,6 @@ define void @neg_nw_nsw(i16 %n) 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:
br label %for.body
@ -160,7 +156,6 @@ define void @rhs_mustexit_3(i16 %n.raw) 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:
%n.and = and i16 %n.raw, 255
@ -186,7 +181,6 @@ define void @rhs_mustexit_nonzero_step(i16 %n.raw, i8 %step.raw) 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:
%n.and = and i16 %n.raw, 255
@ -212,7 +206,6 @@ define void @neg_maybe_zero_step(i16 %n.raw, i8 %step) 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:
%n.and = and i16 %n.raw, 255
@ -293,8 +286,6 @@ define void @rhs_narrow_range(i16 %n.raw) {
; 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 i16 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -320,7 +311,6 @@ define void @ugt_constant_rhs(i16 %n.raw, i8 %start) 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:
br label %for.body
@ -343,8 +333,6 @@ define void @ult_constant_rhs(i16 %n.raw, i8 %start) {
; 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 i16 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -368,8 +356,6 @@ define void @ult_constant_rhs_stride2(i16 %n.raw, i8 %start) {
; 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 i16 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -418,8 +404,6 @@ define void @ult_restricted_rhs(i16 %n.raw) {
; 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 i16 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -443,8 +427,6 @@ define void @ult_guarded_rhs(i16 %n) {;
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (1 umax %n))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i16 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

14
llvm/test/Analysis/ScalarEvolution/trip-count-minmax.ll
View File

@ -17,8 +17,6 @@ define void @nomulitply(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + (%a umin %b))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + (%a umin %b))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + (%a umin %b))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
; No information about a or b. Trip multiple is 1.
@ -63,8 +61,6 @@ define void @umin(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + ((2 * %a) umin (4 * %b)))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + ((2 * %a) umin (4 * %b)))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + ((2 * %a) umin (4 * %b)))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
; void umin(unsigned a, unsigned b) {
@ -113,8 +109,6 @@ define void @umax(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + ((2 * %a) umax (4 * %b)))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -3
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + ((2 * %a) umax (4 * %b)))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + ((2 * %a) umax (4 * %b)))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
@ -163,8 +157,6 @@ define void @smin(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + ((2 * %a)<nsw> smin (4 * %b)<nsw>))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + ((2 * %a)<nsw> smin (4 * %b)<nsw>))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + ((2 * %a)<nsw> smin (4 * %b)<nsw>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
; void smin(signed a, signed b) {
@ -212,8 +204,6 @@ define void @smax(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + ((2 * %a)<nsw> smax (4 * %b)<nsw>))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -3
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + ((2 * %a)<nsw> smax (4 * %b)<nsw>))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + ((2 * %a)<nsw> smax (4 * %b)<nsw>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 2
;
; void smax(signed a, signed b) {
@ -261,8 +251,6 @@ define void @umin_seq2(i32 %n, i32 %m) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (1 umax (2 * %n))) umin_seq (-1 + (1 umax (16 * %m))))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -17
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 + (1 umax (2 * %n))) umin_seq (-1 + (1 umax (16 * %m))))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 + (1 umax (2 * %n))) umin_seq (-1 + (1 umax (16 * %m))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
; Can't find that trip multiple is 2 for this case of umin_seq
@ -299,8 +287,6 @@ define void @umin-3and6(i32 noundef %a, i32 noundef %b) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + ((3 * %a) umin (6 * %b)))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 2147483646
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + ((3 * %a) umin (6 * %b)))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + ((3 * %a) umin (6 * %b)))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
; Trip multiple is 1 because we use GetMinTrailingZeros() to compute trip multiples.

51
llvm/test/Analysis/ScalarEvolution/trip-count-negative-stride.ll
View File

@ -15,7 +15,6 @@ define void @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:
br label %for.body
@ -38,7 +37,6 @@ define void @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:
br label %for.body
@ -61,8 +59,6 @@ define void @ult_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
@ -86,8 +82,6 @@ define void @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 i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -109,8 +103,6 @@ define void @ult_129_unknown_start(i8 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -134,7 +126,6 @@ define void @ult_not_taken(i8 %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:
%assume = icmp ult i8 128, %step
@ -161,8 +152,6 @@ define void @ult_ub1() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 2
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 3
;
entry:
@ -186,8 +175,6 @@ define void @ult_ub2() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -211,8 +198,6 @@ define void @ult_129_preinc() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
@ -234,8 +219,6 @@ define void @ult_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
@ -259,7 +242,6 @@ define void @ult_129_varying_rhs(ptr %n_p) {
; 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
@ -281,7 +263,6 @@ define void @ult_symbolic_varying_rhs(ptr %n_p, i8 %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:
%assume = icmp ult i8 128, %step
@ -311,8 +292,6 @@ define void @slt_wrap() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 63
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 64
;
entry:
@ -336,7 +315,6 @@ define void @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:
br label %for.body
@ -359,8 +337,6 @@ define void @slt_infinite_ub() mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 0
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -384,8 +360,6 @@ define void @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 i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -408,7 +382,6 @@ define void @slt_not_taken(i8 %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:
%assume = icmp ult i8 128, %step
@ -431,8 +404,6 @@ define void @slt_129_unknown_start(i8 %start) mustprogress {
; 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 i8 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -457,8 +428,6 @@ define void @slt_ub1() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is false
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i1 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -482,8 +451,6 @@ define void @slt_ub2() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is false
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i1 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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -507,8 +474,6 @@ define void @slt_129_preinc() {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
@ -530,8 +495,6 @@ define void @slt_preinc(i8 %step) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is 1
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i8 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-NEXT: Loop %for.body: Trip multiple is 2
;
entry:
@ -555,7 +518,6 @@ define void @slt_129_varying_rhs(ptr %n_p) {
; 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
@ -577,7 +539,6 @@ define void @slt_symbolic_varying_rhs(ptr %n_p, i8 %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:
%assume = icmp ult i8 128, %step
@ -604,14 +565,10 @@ define void @step_is_neg_addrec_slt_8(i64 %n) {
; CHECK-NEXT: Loop %inner: backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is i32 8
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is (7 /u {0,+,-1}<%outer.header>)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: 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 i64 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-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
@ -646,14 +603,10 @@ define void @step_is_neg_addrec_slt_var(i32 %n) {
; CHECK-NEXT: Loop %inner: backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is i32 2147483647
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({0,+,1}<nuw><nsw><%outer.header> + ({0,+,-1}<nsw><%outer.header> smax %n))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: 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 i64 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-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:
@ -688,14 +641,10 @@ define void @step_is_neg_addrec_unknown_start(i32 %n) {
; CHECK-NEXT: Loop %inner: backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Loop %inner: constant max backedge-taken count is i32 -2147483640
; CHECK-NEXT: Loop %inner: symbolic max backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Loop %inner: Predicated backedge-taken count is ({(-1 * %n),+,1}<nw><%outer.header> + (8 smax {%n,+,-1}<nsw><%outer.header>))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: 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 i64 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-NEXT: Loop %outer.header: Trip multiple is 1
;
entry:

6
llvm/test/Analysis/ScalarEvolution/trip-count-non-unit-stride.ll
View File

@ -19,7 +19,6 @@ define void @test_preinc_ult(i64 %len) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@ -55,7 +54,6 @@ define void @test_postinc_ult(i64 %len) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@ -90,7 +88,6 @@ define void @test_preinc_slt(i64 %len) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@ -126,7 +123,6 @@ define void @test_postinc_slt(i64 %len) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@ -161,7 +157,6 @@ define void @test_preinc_sgt(i64 %lim) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop
@ -197,7 +192,6 @@ define void @test_postinc_sgt(i64 %lim) {
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for latch: ***COULDNOTCOMPUTE***
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
start:
br label %loop

10
llvm/test/Analysis/ScalarEvolution/trip-count-pow2.ll
View File

@ -7,8 +7,6 @@ define void @test1(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-32 + (96 * %n)) /u 32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 134217727
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-32 + (96 * %n)) /u 32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-32 + (96 * %n)) /u 32)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -31,8 +29,6 @@ define i32 @test2(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-32 + (32 * (%n /u 32))<nuw>) /u 32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 134217727
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-32 + (32 * (%n /u 32))<nuw>) /u 32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-32 + (32 * (%n /u 32))<nuw>) /u 32)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -54,8 +50,6 @@ define void @test3(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-32 + (32 * %n)) /u 32)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 134217727
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-32 + (32 * %n)) /u 32)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-32 + (32 * %n)) /u 32)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -77,8 +71,6 @@ define void @test4(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (-1431655764 * %n)) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 1073741823
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (-1431655764 * %n)) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1431655764 * %n)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -100,8 +92,6 @@ define void @test5(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-4 + (4 * %n)) /u 4)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 1073741823
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-4 + (4 * %n)) /u 4)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (4 * %n)) /u 4)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/trip-count-switch.ll
View File

@ -10,8 +10,6 @@ define void @test1() nounwind {
; CHECK-NEXT: Loop %for.cond: backedge-taken count is 2
; CHECK-NEXT: Loop %for.cond: constant max backedge-taken count is i32 2
; CHECK-NEXT: Loop %for.cond: symbolic max backedge-taken count is 2
; CHECK-NEXT: Loop %for.cond: Predicated backedge-taken count is 2
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.cond: Trip multiple is 3
;
entry:

14
llvm/test/Analysis/ScalarEvolution/trip-count-unknown-stride.ll
View File

@ -17,8 +17,6 @@ define void @foo1(ptr nocapture %A, i32 %n, i32 %s) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-1 + (%n smax %s)) /u %s)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-1 + (%n smax %s)) /u %s)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-1 + (%n smax %s)) /u %s)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -52,8 +50,6 @@ define void @foo2(ptr nocapture %A, i32 %n, i32 %s) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -83,7 +79,6 @@ define void @foo3(ptr nocapture %A, i32 %n, i32 %s) {
; 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
@ -111,8 +106,6 @@ define void @foo4(ptr nocapture %A, i32 %n, i32 %s) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((((-1 * (1 umin ((-1 * %s) + (%n smax %s))))<nuw><nsw> + (-1 * %s) + (%n smax %s)) /u (1 umax %s)) + (1 umin ((-1 * %s) + (%n smax %s))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -144,8 +137,6 @@ define void @foo5(ptr nocapture %A, i32 %n, i32 %s, i32 %start) mustprogress {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((((-1 * (1 umin ((-1 * %start) + (%n smax %start))))<nuw><nsw> + (-1 * %start) + (%n smax %start)) /u (1 umax %s)) + (1 umin ((-1 * %start) + (%n smax %start))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((((-1 * (1 umin ((-1 * %start) + (%n smax %start))))<nuw><nsw> + (-1 * %start) + (%n smax %start)) /u (1 umax %s)) + (1 umin ((-1 * %start) + (%n smax %start))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((((-1 * (1 umin ((-1 * %start) + (%n smax %start))))<nuw><nsw> + (-1 * %start) + (%n smax %start)) /u (1 umax %s)) + (1 umin ((-1 * %start) + (%n smax %start))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -175,7 +166,6 @@ define void @zero_stride(ptr nocapture %A, i32 %n) {
; 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
@ -203,7 +193,6 @@ define void @zero_stride_ub(ptr nocapture %A) {
; 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
@ -231,8 +220,6 @@ define void @zero_stride_symbolic(ptr nocapture %A, i32 %n, i32 %zero) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((((-1 * (1 umin ((-1 * %zero) + (%n smax %zero))))<nuw><nsw> + (-1 * %zero) + (%n smax %zero)) /u (1 umax %zero)) + (1 umin ((-1 * %zero) + (%n smax %zero))))
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -1
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((((-1 * (1 umin ((-1 * %zero) + (%n smax %zero))))<nuw><nsw> + (-1 * %zero) + (%n smax %zero)) /u (1 umax %zero)) + (1 umin ((-1 * %zero) + (%n smax %zero))))
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((((-1 * (1 umin ((-1 * %zero) + (%n smax %zero))))<nuw><nsw> + (-1 * %zero) + (%n smax %zero)) /u (1 umax %zero)) + (1 umin ((-1 * %zero) + (%n smax %zero))))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -261,7 +248,6 @@ define void @zero_stride_varying_rhs(ptr nocapture %A, ptr %n_p, i32 %zero) {
; 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

8
llvm/test/Analysis/ScalarEvolution/trip-count.ll
View File

@ -12,8 +12,6 @@ define void @PR1101(i32 %N) {
; CHECK-NEXT: Loop %bb3: backedge-taken count is 10000
; CHECK-NEXT: Loop %bb3: constant max backedge-taken count is i32 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-NEXT: Loop %bb3: Trip multiple is 10001
;
entry:
@ -43,8 +41,6 @@ define i32 @PR22795() {
; CHECK-NEXT: Loop %preheader: backedge-taken count is 7
; CHECK-NEXT: Loop %preheader: constant max backedge-taken count is i64 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-NEXT: Loop %preheader: Trip multiple is 8
;
entry:
@ -106,8 +102,6 @@ define void @pr28012(i32 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is -1431655751
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 -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-NEXT: Loop %loop: Trip multiple is 2863311546
;
entry:
@ -130,8 +124,6 @@ define void @non_zero_from_loop_guard(i16 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (%n /u 2))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i16 32766
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-1 + (%n /u 2))<nsw>
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + (%n /u 2))<nsw>
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

10
llvm/test/Analysis/ScalarEvolution/trip-count10.ll
View File

@ -9,7 +9,6 @@ define void @a(i64 %n) nounwind {
; 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:
%t0 = icmp sgt i64 %n, 0
@ -30,8 +29,6 @@ define void @b(i64 %n) nounwind {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -53,8 +50,6 @@ define void @c(i64 %n) nounwind {
; CHECK-NEXT: Loop %loop: backedge-taken count is false
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i1 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -76,7 +71,6 @@ define void @d(i64 %n) nounwind {
; 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:
%t0 = icmp sgt i64 %n, 0
@ -105,7 +99,6 @@ define void @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:
br label %loophead
@ -134,8 +127,6 @@ define void @constant_phi_operands() nounwind {
; CHECK-NEXT: Loop %loop: backedge-taken count is 1
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 2
;
entry:
@ -160,7 +151,6 @@ define void @exit_orcond_nsw(ptr %a) nounwind {
; CHECK-NEXT: Loop %for.body.i: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %for.body.i: constant max backedge-taken count is i32 1
; CHECK-NEXT: Loop %for.body.i: symbolic max backedge-taken count is 1
; CHECK-NEXT: Loop %for.body.i: Unpredictable predicated backedge-taken count.
;
entry:
br label %for.body.i

2
llvm/test/Analysis/ScalarEvolution/trip-count12.ll
View File

@ -9,8 +9,6 @@ define zeroext i16 @test(ptr nocapture %p, i32 %len) nounwind readonly {
; CHECK-NEXT: Loop %for.body: backedge-taken count is ((-2 + %len) /u 2)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 1073741823
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is ((-2 + %len) /u 2)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is ((-2 + %len) /u 2)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

10
llvm/test/Analysis/ScalarEvolution/trip-count13.ll
View File

@ -9,8 +9,6 @@ define void @u_0(i8 %rhs) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) umax %rhs))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 -100, actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) umax %rhs)), actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) umax %rhs))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -35,8 +33,6 @@ define void @u_1(i8 %start) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 * %start) + ((-100 + %start) umax %start))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 -100, actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 * %start) + ((-100 + %start) umax %start)), actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 * %start) + ((-100 + %start) umax %start))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -62,8 +58,6 @@ define void @s_0(i8 %rhs) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) smax %rhs))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 -100, actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) smax %rhs)), actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-100 + (-1 * %rhs) + ((100 + %rhs) smax %rhs))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -89,8 +83,6 @@ define void @s_1(i8 %start) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 * %start) + ((-100 + %start) smax %start))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 -100, actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 * %start) + ((-100 + %start) smax %start)), actual taken count either this or zero.
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 * %start) + ((-100 + %start) smax %start))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -116,8 +108,6 @@ define void @s_2(i8 %start) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 * ((-100 + %start) smin %start)) + %start)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i8 -1
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-1 * ((-100 + %start) smin %start)) + %start)
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-1 * ((-100 + %start) smin %start)) + %start)
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %loop: Trip multiple is 1
;
entry:

16
llvm/test/Analysis/ScalarEvolution/trip-count14.ll
View File

@ -7,8 +7,6 @@ define void @s32_max1(i32 %n, ptr %p) {
; 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 i32 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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -33,8 +31,6 @@ define void @s32_max2(i32 %n, ptr %p) {
; 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 i32 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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -59,8 +55,6 @@ define void @s32_maxx(i32 %n, i32 %x, ptr %p) {
; 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 i32 -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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -89,8 +83,6 @@ define void @s32_max2_unpredictable_exit(i32 %n, i32 %x, ptr %p) {
; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is (((-1 * %n) + ((2 + %n) smax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: 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-NEXT: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) smax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -119,8 +111,6 @@ define void @u32_max1(i32 %n, ptr %p) {
; 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 i32 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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -145,8 +135,6 @@ define void @u32_max2(i32 %n, ptr %p) {
; 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 i32 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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -171,8 +159,6 @@ define void @u32_maxx(i32 %n, i32 %x, ptr %p) {
; 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 i32 -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-NEXT: Loop %do.body: Trip multiple is 1
;
entry:
@ -201,8 +187,6 @@ define void @u32_max2_unpredictable_exit(i32 %n, i32 %x, ptr %p) {
; CHECK-NEXT: Loop %do.body: symbolic max backedge-taken count is (((-1 * %n) + ((2 + %n) umax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: 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-NEXT: Loop %do.body: Predicated backedge-taken count is (((-1 * %n) + ((2 + %n) umax %n)) umin ((-1 * %n) + %x))
; CHECK-NEXT: Predicates:
; CHECK-NEXT: Loop %do.body: Trip multiple is 1
;
entry:

7
llvm/test/Analysis/ScalarEvolution/trip-count15.ll
View File

@ -14,8 +14,6 @@ define void @umin_unsigned_check(i64 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -45,8 +43,6 @@ define void @umin_signed_check(i64 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (1 + (4096 umin %n))<nuw><nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -76,8 +72,6 @@ define void @smin_signed_check(i64 %n) {
; 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 i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -107,7 +101,6 @@ define void @smin_unsigned_check(i64 %n) {
; 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:
%min.cmp = icmp slt i64 4096, %n

2
llvm/test/Analysis/ScalarEvolution/trip-count2.ll
View File

@ -9,8 +9,6 @@ define void @PR1101(i32 %N) {
; CHECK-NEXT: Loop %bb3: backedge-taken count is 4
; CHECK-NEXT: Loop %bb3: constant max backedge-taken count is i32 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-NEXT: Loop %bb3: Trip multiple is 5
;
entry:

2
llvm/test/Analysis/ScalarEvolution/trip-count3.ll
View File

@ -42,8 +42,6 @@ define void @sha_stream_bb3_2E_i(ptr %sha_info, ptr %data1, i32, ptr %buffer_add
; 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 i32 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-NEXT: Loop %bb3.i: Trip multiple is 1
;
newFuncRoot:

2
llvm/test/Analysis/ScalarEvolution/trip-count4.ll
View File

@ -9,8 +9,6 @@ define void @another_count_down_signed(ptr %d, i64 %n) nounwind {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-11 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

1
llvm/test/Analysis/ScalarEvolution/trip-count6.ll
View File

@ -13,7 +13,6 @@ define i8 @f() {
; CHECK-NEXT: Loop %bb: symbolic max backedge-taken count is 1
; CHECK-NEXT: symbolic max exit count for bb: ***COULDNOTCOMPUTE***
; CHECK-NEXT: symbolic max exit count for bb2: 1
; CHECK-NEXT: Loop %bb: Unpredictable predicated backedge-taken count.
;
entry:
tail call i32 @fegetround( ) ; <i32>:0 [#uses=1]

1
llvm/test/Analysis/ScalarEvolution/trip-count7.ll
View File

@ -66,7 +66,6 @@ define void @Doit_bb7_2E_i(ptr %x1, ptr %c, ptr %b, ptr %a, ptr %q, ptr %x1.sub,
; CHECK-NEXT: Loop %bb7.i: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %bb7.i: constant max backedge-taken count is i32 8
; CHECK-NEXT: Loop %bb7.i: symbolic max backedge-taken count is 8
; CHECK-NEXT: Loop %bb7.i: Unpredictable predicated backedge-taken count.
;
newFuncRoot:
br label %bb7.i

2
llvm/test/Analysis/ScalarEvolution/trip-count8.ll
View File

@ -10,8 +10,6 @@ define i32 @foo(i32 %ecx) nounwind {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %ecx)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:

45
llvm/test/Analysis/ScalarEvolution/trip-count9.ll
View File

@ -15,8 +15,6 @@ define void @foo(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -37,7 +35,6 @@ define void @step2(i4 %n) {
; 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:
%s = icmp sgt i4 %n, 0
@ -57,8 +54,6 @@ define void @start1(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -79,7 +74,6 @@ define void @start1_step2(i4 %n) {
; 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:
%s = icmp sgt i4 %n, 0
@ -99,8 +93,6 @@ define void @startx(i4 %n, i4 %x) {
; 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 i4 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -121,7 +113,6 @@ define void @startx_step2(i4 %n, i4 %x) {
; 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:
%s = icmp sgt i4 %n, 0
@ -141,8 +132,6 @@ define void @nsw(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -171,8 +160,6 @@ define void @nsw_step2(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + %n) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -193,8 +180,6 @@ define void @nsw_start1(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 smax %n))<nsw>
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -215,8 +200,6 @@ define void @nsw_start1_step2(i4 %n) {
; 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 i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -237,8 +220,6 @@ define void @nsw_startx(i4 %n, i4 %x) {
; 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 i4 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -259,8 +240,6 @@ define void @nsw_startx_step2(i4 %n, i4 %x) {
; 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 i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -281,8 +260,6 @@ define void @even(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 2
;
entry:
@ -304,8 +281,6 @@ define void @even_step2(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -327,8 +302,6 @@ define void @even_start1(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -350,8 +323,6 @@ define void @even_start1_step2(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -373,8 +344,6 @@ define void @even_startx(i4 %n, i4 %x) {
; 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 i4 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -396,8 +365,6 @@ define void @even_startx_step2(i4 %n, i4 %x) {
; 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 i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -419,8 +386,6 @@ define void @even_nsw(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 2
;
entry:
@ -442,8 +407,6 @@ define void @even_nsw_step2(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -465,8 +428,6 @@ define void @even_nsw_start1(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (-2 + (2 * %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -488,8 +449,6 @@ define void @even_nsw_start1_step2(i4 %n) {
; CHECK-NEXT: Loop %loop: backedge-taken count is ((-2 + (2 * %n)) /u 2)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -511,8 +470,6 @@ define void @even_nsw_startx(i4 %n, i4 %x) {
; 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 i4 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -534,8 +491,6 @@ define void @even_nsw_startx_step2(i4 %n, i4 %x) {
; 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 i4 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

33
llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
View File

@ -16,8 +16,6 @@ define void @test_trip_multiple_4(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -51,8 +49,6 @@ define void @test_trip_multiple_4_guard(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -87,8 +83,6 @@ define void @test_trip_multiple_4_ugt_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -123,8 +117,6 @@ define void @test_trip_multiple_4_ugt_5_order_swapped(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -158,8 +150,6 @@ define void @test_trip_multiple_4_sgt_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -194,8 +184,6 @@ define void @test_trip_multiple_4_sgt_5_order_swapped(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -229,8 +217,6 @@ define void @test_trip_multiple_4_uge_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -265,8 +251,6 @@ define void @test_trip_multiple_4_uge_5_order_swapped(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -301,8 +285,6 @@ define void @test_trip_multiple_4_sge_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -336,8 +318,6 @@ define void @test_trip_multiple_4_sge_5_order_swapped(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -372,8 +352,6 @@ define void @test_trip_multiple_4_icmp_ops_swapped(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -407,8 +385,6 @@ define void @test_trip_multiple_4_upper_lower_bounds(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -444,8 +420,6 @@ define void @test_trip_multiple_4_upper_lower_bounds_swapped1(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -481,8 +455,6 @@ define void @test_trip_multiple_4_upper_lower_bounds_swapped2(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -518,8 +490,6 @@ define void @test_trip_multiple_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 5
;
entry:
@ -555,8 +525,6 @@ define void @test_trunc_operand_larger_than_urem_expr(i64 %N) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %N)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i64 -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-NEXT: Loop %for.body: Trip multiple is 1
;
entry:
@ -589,7 +557,6 @@ define void @test_trip_multiple_4_vectorized_iv(i32 %num) {
; 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:
%u = urem i32 %num, 4

16
llvm/test/Analysis/ScalarEvolution/trip-multiple.ll
View File

@ -27,8 +27,6 @@ define void @trip_multiple_3(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 3
;
entry:
@ -63,8 +61,6 @@ define void @trip_multiple_4(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -5
; 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-NEXT: Loop %for.body: Trip multiple is 4
;
entry:
@ -100,8 +96,6 @@ define void @trip_multiple_5(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -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-NEXT: Loop %for.body: Trip multiple is 5
;
entry:
@ -137,8 +131,6 @@ define void @trip_multiple_6(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -5
; 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-NEXT: Loop %for.body: Trip multiple is 6
;
entry:
@ -174,8 +166,6 @@ define void @trip_multiple_7(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -5
; 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-NEXT: Loop %for.body: Trip multiple is 7
;
entry:
@ -211,8 +201,6 @@ define void @trip_multiple_8(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -9
; 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-NEXT: Loop %for.body: Trip multiple is 8
;
entry:
@ -247,8 +235,6 @@ define void @trip_multiple_9(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -5
; 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-NEXT: Loop %for.body: Trip multiple is 9
;
entry:
@ -283,8 +269,6 @@ define void @trip_multiple_10(i32 noundef %num) {
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is i32 -7
; 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-NEXT: Loop %for.body: Trip multiple is 10
;
entry:

18
llvm/test/Analysis/ScalarEvolution/umin-umax-folds.ll
View File

@ -18,8 +18,6 @@ define void @umin_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -54,8 +52,6 @@ define void @ule_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -90,8 +86,6 @@ define void @uge_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -126,8 +120,6 @@ define void @ult_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -162,8 +154,6 @@ define void @ugt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -198,8 +188,6 @@ define void @sle_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -234,8 +222,6 @@ define void @sge_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -270,8 +256,6 @@ define void @slt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (sext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 -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-NEXT: Loop %loop: Trip multiple is 1
;
entry:
@ -306,8 +290,6 @@ define void @sgt_sext_x_zext_x(i32 %len) {
; CHECK-NEXT: Loop %loop: backedge-taken count is (zext i32 %len to i64)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 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-NEXT: Loop %loop: Trip multiple is 1
;
entry:

2
llvm/test/Analysis/ScalarEvolution/unknown_phis.ll
View File

@ -50,8 +50,6 @@ define void @merge_values_with_ranges_looped(ptr %a_len_ptr, ptr %b_len_ptr) {
; CHECK-NEXT: Loop %loop: backedge-taken count is 99
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 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-NEXT: Loop %loop: Trip multiple is 100
;

1
llvm/test/Analysis/ScalarEvolution/widenable-condition.ll
View File

@ -25,7 +25,6 @@ define i32 @wc_max() {
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i32 1999
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is 1999
; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count.
;
entry:
br label %loop

9
llvm/test/Transforms/LoopSimplify/preserve-scev.ll
View File

@ -14,10 +14,8 @@ target datalayout = "n8:16:32:64"
; CHECK-LABEL: Determining loop execution counts for: @test
; CHECK: Loop %for.body18: Unpredictable backedge-taken count.
; CHECK: Loop %for.body18: constant max backedge-taken count is i32 2147483646
; CHECK: Loop %for.body18: Unpredictable predicated backedge-taken count.
; CHECK: Loop %for.cond: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %for.cond: Unpredictable constant max backedge-taken count.
; CHECK: Loop %for.cond: Unpredictable predicated backedge-taken count.
;
; Now simplify the loop, which should cause SCEV to re-compute more precise
; info here in addition to having preheader PHIs. Second SCEV print:
@ -26,13 +24,10 @@ target datalayout = "n8:16:32:64"
; CHECK-LABEL: Determining loop execution counts for: @test
; CHECK: Loop %for.body18: Unpredictable backedge-taken count.
; CHECK: Loop %for.body18: constant max backedge-taken count is i32 2147483646
; CHECK: Loop %for.body18: Unpredictable predicated backedge-taken count.
; CHECK: Loop %for.cond: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %for.cond: constant max backedge-taken count is i32 -2147483647
; CHECK: Loop %for.cond: Unpredictable predicated backedge-taken count.
; CHECK: Loop %for.cond.outer: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %for.cond.outer: Unpredictable constant max backedge-taken count.
; CHECK: Loop %for.cond.outer: Unpredictable predicated backedge-taken count.
define i32 @test() nounwind {
entry:
br label %for.cond
@ -83,20 +78,16 @@ declare void @foo() nounwind
; CHECK-LABEL: Determining loop execution counts for: @mergeExit
; CHECK: Loop %while.cond191: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %while.cond191: constant max backedge-taken count is i32 -1
; CHECK: Loop %while.cond191: Unpredictable predicated backedge-taken count.
; CHECK: Loop %while.cond191.outer: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %while.cond191.outer: Unpredictable constant max backedge-taken count.
; CHECK: Loop %while.cond191.outer: Unpredictable predicated backedge-taken count.
;
; After simplifying, the max backedge count is refined.
; Second SCEV print:
; CHECK-LABEL: Determining loop execution counts for: @mergeExit
; CHECK: Loop %while.cond191: <multiple exits> backedge-taken count is 0
; CHECK: Loop %while.cond191: constant max backedge-taken count is i32 0
; CHECK: Loop %while.cond191: Predicated backedge-taken count is 0
; CHECK: Loop %while.cond191.outer: <multiple exits> Unpredictable backedge-taken count.
; CHECK: Loop %while.cond191.outer: constant max backedge-taken count is i1 false
; CHECK: Loop %while.cond191.outer: Unpredictable predicated backedge-taken count.
define void @mergeExit(i32 %MapAttrCount) nounwind uwtable ssp {
entry:
br i1 undef, label %if.then124, label %if.end126