[llvm] b3d2df4 - [NFC][SCEV] Autogenerate check lines in tests being affected by upcoming patch
Roman Lebedev via llvm-commits
llvm-commits at lists.llvm.org
Thu Oct 15 13:15:37 PDT 2020
Author: Roman Lebedev
Date: 2020-10-15T23:15:03+03:00
New Revision: b3d2df42f7ac60ff7645cf944a93f0fde144a195
URL: https://github.com/llvm/llvm-project/commit/b3d2df42f7ac60ff7645cf944a93f0fde144a195
DIFF: https://github.com/llvm/llvm-project/commit/b3d2df42f7ac60ff7645cf944a93f0fde144a195.diff
LOG: [NFC][SCEV] Autogenerate check lines in tests being affected by upcoming patch
Added:
Modified:
llvm/test/Analysis/ScalarEvolution/load.ll
llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
Removed:
################################################################################
diff --git a/llvm/test/Analysis/ScalarEvolution/load.ll b/llvm/test/Analysis/ScalarEvolution/load.ll
index 6d9745bd76ef..707908ff78cd 100644
--- a/llvm/test/Analysis/ScalarEvolution/load.ll
+++ b/llvm/test/Analysis/ScalarEvolution/load.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
@@ -9,20 +10,43 @@ target triple = "i386-pc-linux-gnu"
; PR11034
define i32 @test1() nounwind readnone {
-; CHECK: test1
+; CHECK-LABEL: 'test1'
+; CHECK-NEXT: Classifying expressions for: @test1
+; CHECK-NEXT: %sum.04 = phi i32 [ 0, %entry ], [ %add2, %for.body ]
+; CHECK-NEXT: --> %sum.04 U: full-set S: full-set Exits: 2450 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %i.03 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%for.body> U: [0,50) S: [0,50) Exits: 49 LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %arrayidx = getelementptr inbounds [50 x i32], [50 x i32]* @arr1, i32 0, i32 %i.03
+; CHECK-NEXT: --> {@arr1,+,4}<nsw><%for.body> U: [0,-3) S: [-2147483648,2147483645) Exits: (196 + @arr1) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %0 = load i32, i32* %arrayidx, align 4
+; CHECK-NEXT: --> %0 U: full-set S: full-set Exits: 50 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %arrayidx1 = getelementptr inbounds [50 x i32], [50 x i32]* @arr2, i32 0, i32 %i.03
+; CHECK-NEXT: --> {@arr2,+,4}<nsw><%for.body> U: [0,-3) S: [-2147483648,2147483645) Exits: (196 + @arr2) LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: %1 = load i32, i32* %arrayidx1, align 4
+; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %add = add i32 %0, %sum.04
+; CHECK-NEXT: --> (%0 + %sum.04) U: full-set S: full-set Exits: 2500 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %add2 = add i32 %add, %1
+; CHECK-NEXT: --> (%1 + %0 + %sum.04) U: full-set S: full-set Exits: 2500 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %inc = add nsw i32 %i.03, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%for.body> U: [1,51) S: [1,51) Exits: 50 LoopDispositions: { %for.body: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test1
+; CHECK-NEXT: Loop %for.body: backedge-taken count is 49
+; CHECK-NEXT: Loop %for.body: max backedge-taken count is 49
+; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 49
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 50
+;
entry:
br label %for.body
for.body: ; preds = %entry, %for.body
%sum.04 = phi i32 [ 0, %entry ], [ %add2, %for.body ]
-; CHECK: --> %sum.04{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: 2450
%i.03 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
%arrayidx = getelementptr inbounds [50 x i32], [50 x i32]* @arr1, i32 0, i32 %i.03
%0 = load i32, i32* %arrayidx, align 4
-; CHECK: --> %0{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: 50
%arrayidx1 = getelementptr inbounds [50 x i32], [50 x i32]* @arr2, i32 0, i32 %i.03
%1 = load i32, i32* %arrayidx1, align 4
-; CHECK: --> %1{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: 0
%add = add i32 %0, %sum.04
%add2 = add i32 %add, %1
%inc = add nsw i32 %i.03, 1
@@ -43,21 +67,40 @@ for.end: ; preds = %for.body
@node1 = internal constant { %struct.ListNode*, i32, [4 x i8] } { %struct.ListNode* null, i32 0, [4 x i8] undef }, align 8
define i32 @test2() nounwind uwtable readonly {
-; CHECK: test2
+; CHECK-LABEL: 'test2'
+; CHECK-NEXT: Classifying expressions for: @test2
+; CHECK-NEXT: %sum.02 = phi i32 [ 0, %entry ], [ %add, %for.body ]
+; CHECK-NEXT: --> %sum.02 U: full-set S: full-set Exits: 10 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %n.01 = phi %struct.ListNode* [ bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node5 to %struct.ListNode*), %entry ], [ %1, %for.body ]
+; CHECK-NEXT: --> %n.01 U: full-set S: full-set Exits: @node1 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %i = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 1
+; CHECK-NEXT: --> (4 + %n.01)<nsw> U: [-2147483644,-2147483648) S: [-2147483644,-2147483648) Exits: (4 + @node1)<nuw><nsw> LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %0 = load i32, i32* %i, align 4
+; CHECK-NEXT: --> %0 U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %add = add nsw i32 %0, %sum.02
+; CHECK-NEXT: --> (%0 + %sum.02) U: full-set S: full-set Exits: 10 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %next = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 0
+; CHECK-NEXT: --> %n.01 U: full-set S: full-set Exits: @node1 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: %1 = load %struct.ListNode*, %struct.ListNode** %next, align 8
+; CHECK-NEXT: --> %1 U: full-set S: full-set Exits: 0 LoopDispositions: { %for.body: Variant }
+; CHECK-NEXT: Determining loop execution counts for: @test2
+; CHECK-NEXT: Loop %for.body: backedge-taken count is 4
+; CHECK-NEXT: Loop %for.body: max backedge-taken count is 4
+; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is 4
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %for.body: Trip multiple is 5
+;
entry:
br label %for.body
for.body: ; preds = %entry, %for.body
%sum.02 = phi i32 [ 0, %entry ], [ %add, %for.body ]
-; CHECK: --> %sum.02{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: 10
%n.01 = phi %struct.ListNode* [ bitcast ({ %struct.ListNode*, i32, [4 x i8] }* @node5 to %struct.ListNode*), %entry ], [ %1, %for.body ]
-; CHECK: --> %n.01{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: @node1
%i = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 1
%0 = load i32, i32* %i, align 4
%add = add nsw i32 %0, %sum.02
%next = getelementptr inbounds %struct.ListNode, %struct.ListNode* %n.01, i64 0, i32 0
%1 = load %struct.ListNode*, %struct.ListNode** %next, align 8
-; CHECK: --> %1{{ U: [^ ]+ S: [^ ]+}}{{ *}}Exits: 0
%cmp = icmp eq %struct.ListNode* %1, null
br i1 %cmp, label %for.end, label %for.body
diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
index 489ae76495b9..12094ac14e71 100644
--- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
+++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll
@@ -1,13 +1,24 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -analyze -scalar-evolution %s -enable-new-pm=0 | FileCheck %s
; RUN: opt -passes='print<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s
; Test case for PR40961. The loop guard limit the max backedge-taken count.
define void @test_guard_less_than_16(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_less_than_16
+; CHECK-LABEL: 'test_guard_less_than_16'
+; CHECK-NEXT: Classifying expressions for: @test_guard_less_than_16
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ %i, %entry ]
+; CHECK-NEXT: --> {%i,+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 15 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {((4 * %i) + %a)<nsw>,+,4}<nsw><%loop> U: full-set S: full-set Exits: (60 + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {(1 + %i),+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 16 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: max backedge-taken count is 15
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp3 = icmp ult i64 %i, 16
@@ -26,10 +37,20 @@ exit:
}
define void @test_guard_less_than_16_operands_swapped(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_less_than_16_operands_swapped
+; CHECK-LABEL: 'test_guard_less_than_16_operands_swapped'
+; CHECK-NEXT: Classifying expressions for: @test_guard_less_than_16_operands_swapped
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ %i, %entry ]
+; CHECK-NEXT: --> {%i,+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 15 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {((4 * %i) + %a)<nsw>,+,4}<nsw><%loop> U: full-set S: full-set Exits: (60 + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {(1 + %i),+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 16 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16_operands_swapped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: max backedge-taken count is 15
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp3 = icmp ugt i64 16, %i
@@ -48,10 +69,20 @@ exit:
}
define void @test_guard_less_than_16_branches_flipped(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_less_than_16_branches_flipped
+; CHECK-LABEL: 'test_guard_less_than_16_branches_flipped'
+; CHECK-NEXT: Classifying expressions for: @test_guard_less_than_16_branches_flipped
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ %i, %entry ]
+; CHECK-NEXT: --> {%i,+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 15 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {((4 * %i) + %a)<nsw>,+,4}<nsw><%loop> U: full-set S: full-set Exits: (60 + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {(1 + %i),+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 16 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_less_than_16_branches_flipped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: max backedge-taken count is -1
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp3 = icmp ult i64 %i, 16
@@ -70,10 +101,20 @@ exit:
}
define void @test_guard_uge_16_branches_flipped(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_uge_16_branches_flipped
+; CHECK-LABEL: 'test_guard_uge_16_branches_flipped'
+; CHECK-NEXT: Classifying expressions for: @test_guard_uge_16_branches_flipped
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ %i, %entry ]
+; CHECK-NEXT: --> {%i,+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 15 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {((4 * %i) + %a)<nsw>,+,4}<nsw><%loop> U: full-set S: full-set Exits: (60 + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {(1 + %i),+,1}<nuw><nsw><%loop> U: full-set S: full-set Exits: 16 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_uge_16_branches_flipped
; CHECK-NEXT: Loop %loop: backedge-taken count is (15 + (-1 * %i))
; CHECK-NEXT: Loop %loop: max backedge-taken count is 15
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (15 + (-1 * %i))
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp3 = icmp uge i64 %i, 16
@@ -92,10 +133,20 @@ exit:
}
define void @test_guard_eq_12(i32* nocapture %a, i64 %N) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_eq_12
+; CHECK-LABEL: 'test_guard_eq_12'
+; CHECK-NEXT: Classifying expressions for: @test_guard_eq_12
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: %N LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %N) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%loop> U: [1,14) S: [1,14) Exits: (1 + %N) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_eq_12
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: max backedge-taken count is 12
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp eq i64 %N, 12
@@ -114,10 +165,20 @@ exit:
}
define void @test_guard_ule_12(i32* nocapture %a, i64 %N) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_ule_12
+; CHECK-LABEL: 'test_guard_ule_12'
+; CHECK-NEXT: Classifying expressions for: @test_guard_ule_12
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,13) S: [0,13) Exits: %N LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %N) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%loop> U: [1,14) S: [1,14) Exits: (1 + %N) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_ule_12
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: max backedge-taken count is 12
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ule i64 %N, 12
@@ -136,10 +197,20 @@ exit:
}
define void @test_guard_ule_12_step2(i32* nocapture %a, i64 %N) {
-; CHECK-LABEL: Determining loop execution counts for: @test_guard_ule_12_step2
+; CHECK-LABEL: 'test_guard_ule_12_step2'
+; CHECK-NEXT: Classifying expressions for: @test_guard_ule_12_step2
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
+; CHECK-NEXT: --> {0,+,2}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,9223372036854775807) Exits: (2 * (%N /u 2))<nuw> LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,8}<nsw><%loop> U: full-set S: full-set Exits: ((8 * (%N /u 2)) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 2
+; CHECK-NEXT: --> {2,+,2}<nuw><%loop> U: [2,-1) S: [-9223372036854775808,9223372036854775807) Exits: (2 + (2 * (%N /u 2))<nuw>) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_ule_12_step2
; CHECK-NEXT: Loop %loop: backedge-taken count is (%N /u 2)
; CHECK-NEXT: Loop %loop: max backedge-taken count is 9223372036854775807
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (%N /u 2)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ule i64 %N, 12
@@ -158,10 +229,20 @@ exit:
}
define void @test_multiple_const_guards_order1(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: @test_multiple_const_guards_order1
-; CHECK: Loop %loop: backedge-taken count is %i
+; CHECK-LABEL: 'test_multiple_const_guards_order1'
+; CHECK-NEXT: Classifying expressions for: @test_multiple_const_guards_order1
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,10) S: [0,10) Exits: %i LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %i) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%loop> U: [1,11) S: [1,11) Exits: (1 + %i) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_multiple_const_guards_order1
+; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: max backedge-taken count is 9
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ult i64 %i, 16
@@ -184,10 +265,20 @@ exit:
}
define void @test_multiple_const_guards_order2(i32* nocapture %a, i64 %i) {
-; CHECK-LABEL: @test_multiple_const_guards_order2
-; CHECK: Loop %loop: backedge-taken count is %i
+; CHECK-LABEL: 'test_multiple_const_guards_order2'
+; CHECK-NEXT: Classifying expressions for: @test_multiple_const_guards_order2
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,10) S: [0,10) Exits: %i LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %i) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><nsw><%loop> U: [1,11) S: [1,11) Exits: (1 + %i) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_multiple_const_guards_order2
+; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: max backedge-taken count is 9
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ult i64 %i, 10
@@ -211,10 +302,20 @@ exit:
; TODO: Currently we miss getting the tightest max backedge-taken count (11).
define void @test_multiple_var_guards_order1(i32* nocapture %a, i64 %i, i64 %N) {
-; CHECK-LABEL: @test_multiple_var_guards_order1
-; CHECK: Loop %loop: backedge-taken count is %i
+; CHECK-LABEL: 'test_multiple_var_guards_order1'
+; CHECK-NEXT: Classifying expressions for: @test_multiple_var_guards_order1
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: %i LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %i) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (1 + %i) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_order1
+; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: max backedge-taken count is -1
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ult i64 %N, 12
@@ -238,10 +339,20 @@ exit:
; TODO: Currently we miss getting the tightest max backedge-taken count (11).
define void @test_multiple_var_guards_order2(i32* nocapture %a, i64 %i, i64 %N) {
-; CHECK-LABEL: Determining loop execution counts for: @test_multiple_var_guards_order2
+; CHECK-LABEL: 'test_multiple_var_guards_order2'
+; CHECK-NEXT: Classifying expressions for: @test_multiple_var_guards_order2
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: %i LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %i) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (1 + %i) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_order2
; CHECK-NEXT: Loop %loop: backedge-taken count is %i
; CHECK-NEXT: Loop %loop: max backedge-taken count is -1
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %i
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ult i64 %i, %N
@@ -265,10 +376,20 @@ exit:
; The guards here reference each other in a cycle.
define void @test_multiple_var_guards_cycle(i32* nocapture %a, i64 %i, i64 %N) {
-; CHECK-LABEL: Determining loop execution counts for: @test_multiple_var_guards_cycle
+; CHECK-LABEL: 'test_multiple_var_guards_cycle'
+; CHECK-NEXT: Classifying expressions for: @test_multiple_var_guards_cycle
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><nsw><%loop> U: [0,-9223372036854775808) S: [0,-9223372036854775808) Exits: %N LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %a, i64 %iv
+; CHECK-NEXT: --> {%a,+,4}<nsw><%loop> U: full-set S: full-set Exits: ((4 * %N) + %a) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw nsw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><%loop> U: [1,0) S: [1,0) Exits: (1 + %N) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_multiple_var_guards_cycle
; CHECK-NEXT: Loop %loop: backedge-taken count is %N
; CHECK-NEXT: Loop %loop: max backedge-taken count is -1
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is %N
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%c.1 = icmp ult i64 %N, %i
@@ -291,10 +412,20 @@ exit:
}
define void @test_guard_ult_ne(i32* nocapture readonly %data, i64 %count) {
-; CHECK-LABEL: @test_guard_ult_ne
-; CHECK: Loop %loop: backedge-taken count is (-1 + %count)
+; CHECK-LABEL: 'test_guard_ult_ne'
+; CHECK-NEXT: Classifying expressions for: @test_guard_ult_ne
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %guardbb ]
+; CHECK-NEXT: --> {0,+,1}<nuw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %data, i64 %iv
+; CHECK-NEXT: --> {%data,+,4}<nw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %data) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><%loop> U: [1,5) S: [1,5) Exits: %count LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_ult_ne
+; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: max backedge-taken count is 3
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp.ult = icmp ult i64 %count, 5
@@ -320,10 +451,20 @@ exit:
; max backedge-taken count.
define void @test_guard_and_assume(i32* nocapture readonly %data, i64 %count) {
-; CHECK-LABEL: @test_guard_and_assume
-; CHECK: Loop %loop: backedge-taken count is (-1 + %count)
+; CHECK-LABEL: 'test_guard_and_assume'
+; CHECK-NEXT: Classifying expressions for: @test_guard_and_assume
+; CHECK-NEXT: %iv = phi i64 [ %iv.next, %loop ], [ 0, %entry ]
+; CHECK-NEXT: --> {0,+,1}<nuw><%loop> U: [0,4) S: [0,4) Exits: (-1 + %count) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %idx = getelementptr inbounds i32, i32* %data, i64 %iv
+; CHECK-NEXT: --> {%data,+,4}<nw><%loop> U: full-set S: full-set Exits: (-4 + (4 * %count) + %data) LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add nuw i64 %iv, 1
+; CHECK-NEXT: --> {1,+,1}<nuw><%loop> U: [1,5) S: [1,5) Exits: %count LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @test_guard_and_assume
+; CHECK-NEXT: Loop %loop: backedge-taken count is (-1 + %count)
; CHECK-NEXT: Loop %loop: max backedge-taken count is 3
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (-1 + %count)
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
%cmp = icmp ult i64 %count, 5
@@ -347,10 +488,20 @@ exit:
declare void @llvm.assume(i1 noundef)
define void @guard_pessimizes_analysis(i1 %c, i32 %N) {
-; CHECK-LABEL: @guard_pessimizes_analysis
-; CHECK: Loop %loop: backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
-; CHECK-NEXT: Loop %loop: max backedge-taken count is 7
-; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
+; CHECK-LABEL: 'guard_pessimizes_analysis'
+; CHECK-NEXT: Classifying expressions for: @guard_pessimizes_analysis
+; CHECK-NEXT: %init = phi i32 [ 2, %entry ], [ 3, %bb1 ]
+; CHECK-NEXT: --> %init U: [2,4) S: [2,4)
+; CHECK-NEXT: %iv = phi i32 [ %iv.next, %loop ], [ %init, %loop.ph ]
+; CHECK-NEXT: --> {%init,+,1}<%loop> U: [2,11) S: [2,11) Exits: 9 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: %iv.next = add i32 %iv, 1
+; CHECK-NEXT: --> {(1 + %init)<nuw><nsw>,+,1}<%loop> U: [3,12) S: [3,12) Exits: 10 LoopDispositions: { %loop: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @guard_pessimizes_analysis
+; CHECK-NEXT: Loop %loop: backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
+; CHECK-NEXT: Loop %loop: max backedge-taken count is 7
+; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is (9 + (-1 * %init)<nsw>)<nsw>
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br i1 %c, label %bb1, label %guard
@@ -377,10 +528,28 @@ exit:
}
define void @crash(i8* %ptr) {
-; CHECK-LABEL: @crash
-; CHECK: Loop %while.body125: backedge-taken count is {(-2 + (-1 * %ptr)),+,-1}<nw><%while.cond111>
+; CHECK-LABEL: 'crash'
+; CHECK-NEXT: Classifying expressions for: @crash
+; CHECK-NEXT: %text.addr.5 = phi i8* [ %incdec.ptr112, %while.cond111 ], [ null, %while.body ]
+; CHECK-NEXT: --> {0,+,-1}<nw><%while.cond111> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %while.cond111: Computable, %while.body: Variant }
+; CHECK-NEXT: %incdec.ptr112 = getelementptr inbounds i8, i8* %text.addr.5, i64 -1
+; CHECK-NEXT: --> {-1,+,-1}<nw><%while.cond111> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %while.cond111: Computable, %while.body: Variant }
+; CHECK-NEXT: %lastout.2271 = phi i8* [ %incdec.ptr126, %while.body125 ], [ %ptr, %while.end117 ]
+; CHECK-NEXT: --> {%ptr,+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {-2,+,-1}<nw><%while.cond111> LoopDispositions: { %while.body125: Computable }
+; CHECK-NEXT: %incdec.ptr126 = getelementptr inbounds i8, i8* %lastout.2271, i64 1
+; CHECK-NEXT: --> {(1 + %ptr)<nsw>,+,1}<nuw><%while.body125> U: full-set S: full-set Exits: {-1,+,-1}<nw><%while.cond111> LoopDispositions: { %while.body125: Computable }
+; CHECK-NEXT: Determining loop execution counts for: @crash
+; CHECK-NEXT: Loop %while.body125: backedge-taken count is {(-2 + (-1 * %ptr)),+,-1}<nw><%while.cond111>
; CHECK-NEXT: Loop %while.body125: max backedge-taken count is -1
; CHECK-NEXT: Loop %while.body125: Predicated backedge-taken count is {(-2 + (-1 * %ptr)),+,-1}<nw><%while.cond111>
+; CHECK-NEXT: Predicates:
+; CHECK: Loop %while.body125: Trip multiple is 1
+; CHECK-NEXT: Loop %while.cond111: Unpredictable backedge-taken count.
+; CHECK-NEXT: Loop %while.cond111: Unpredictable 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 max backedge-taken count.
+; CHECK-NEXT: Loop %while.body: Unpredictable predicated backedge-taken count.
;
entry:
br label %while.body
diff --git a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
index 5a7bb3c9e5cd..7707ebbc176c 100644
--- a/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
+++ b/llvm/test/Analysis/ScalarEvolution/no-wrap-add-exprs.ll
@@ -1,123 +1,137 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -S -analyze -enable-new-pm=0 -scalar-evolution < %s | FileCheck %s
; RUN: opt -S -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s
!0 = !{i8 0, i8 127}
define void @f0(i8* %len_addr) {
-; CHECK-LABEL: Classifying expressions for: @f0
- entry:
+; CHECK-LABEL: 'f0'
+; CHECK-NEXT: Classifying expressions for: @f0
+; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0
+; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
+; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1
+; CHECK-NEXT: --> %len_norange U: full-set S: full-set
+; CHECK-NEXT: %t0 = add i8 %len, 1
+; CHECK-NEXT: --> (1 + %len)<nuw><nsw> U: [1,-128) S: [1,-128)
+; CHECK-NEXT: %t1 = add i8 %len, 2
+; CHECK-NEXT: --> (2 + %len)<nuw> U: [2,-127) S: [2,-127)
+; CHECK-NEXT: %t2 = sub i8 %len, 1
+; CHECK-NEXT: --> (-1 + %len)<nsw> U: [-1,126) S: [-1,126)
+; CHECK-NEXT: %t3 = sub i8 %len, 2
+; CHECK-NEXT: --> (-2 + %len)<nsw> U: [-2,125) S: [-2,125)
+; CHECK-NEXT: %q0 = add i8 %len_norange, 1
+; CHECK-NEXT: --> (1 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q1 = add i8 %len_norange, 2
+; CHECK-NEXT: --> (2 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q2 = sub i8 %len_norange, 1
+; CHECK-NEXT: --> (-1 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q3 = sub i8 %len_norange, 2
+; CHECK-NEXT: --> (-2 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: Determining loop execution counts for: @f0
+;
+ entry:
%len = load i8, i8* %len_addr, !range !0
%len_norange = load i8, i8* %len_addr
-; CHECK: %len = load i8, i8* %len_addr, align 1, !range !0
-; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
-; CHECK: %len_norange = load i8, i8* %len_addr
-; CHECK-NEXT: --> %len_norange U: full-set S: full-set
%t0 = add i8 %len, 1
%t1 = add i8 %len, 2
-; CHECK: %t0 = add i8 %len, 1
-; CHECK-NEXT: --> (1 + %len)<nuw><nsw> U: [1,-128) S: [1,-128)
-; CHECK: %t1 = add i8 %len, 2
-; CHECK-NEXT: --> (2 + %len)<nuw> U: [2,-127) S: [2,-127)
%t2 = sub i8 %len, 1
%t3 = sub i8 %len, 2
-; CHECK: %t2 = sub i8 %len, 1
-; CHECK-NEXT: --> (-1 + %len)<nsw> U: [-1,126) S: [-1,126)
-; CHECK: %t3 = sub i8 %len, 2
-; CHECK-NEXT: --> (-2 + %len)<nsw> U: [-2,125) S: [-2,125)
%q0 = add i8 %len_norange, 1
%q1 = add i8 %len_norange, 2
-; CHECK: %q0 = add i8 %len_norange, 1
-; CHECK-NEXT: --> (1 + %len_norange) U: full-set S: full-set
-; CHECK: %q1 = add i8 %len_norange, 2
-; CHECK-NEXT: --> (2 + %len_norange) U: full-set S: full-set
%q2 = sub i8 %len_norange, 1
%q3 = sub i8 %len_norange, 2
-; CHECK: %q2 = sub i8 %len_norange, 1
-; CHECK-NEXT: --> (-1 + %len_norange) U: full-set S: full-set
-; CHECK: %q3 = sub i8 %len_norange, 2
-; CHECK-NEXT: --> (-2 + %len_norange) U: full-set S: full-set
ret void
}
define void @f1(i8* %len_addr) {
-; CHECK-LABEL: Classifying expressions for: @f1
- entry:
+; CHECK-LABEL: 'f1'
+; CHECK-NEXT: Classifying expressions for: @f1
+; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0
+; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
+; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1
+; CHECK-NEXT: --> %len_norange U: full-set S: full-set
+; CHECK-NEXT: %t0 = add i8 %len, -1
+; CHECK-NEXT: --> (-1 + %len)<nsw> U: [-1,126) S: [-1,126)
+; CHECK-NEXT: %t1 = add i8 %len, -2
+; CHECK-NEXT: --> (-2 + %len)<nsw> U: [-2,125) S: [-2,125)
+; CHECK-NEXT: %t0.sext = sext i8 %t0 to i16
+; CHECK-NEXT: --> (-1 + (zext i8 %len to i16))<nsw> U: [-1,126) S: [-1,126)
+; CHECK-NEXT: %t1.sext = sext i8 %t1 to i16
+; CHECK-NEXT: --> (-2 + (zext i8 %len to i16))<nsw> U: [-2,125) S: [-2,125)
+; CHECK-NEXT: %q0 = add i8 %len_norange, 1
+; CHECK-NEXT: --> (1 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q1 = add i8 %len_norange, 2
+; CHECK-NEXT: --> (2 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q0.sext = sext i8 %q0 to i16
+; CHECK-NEXT: --> (sext i8 (1 + %len_norange) to i16) U: [-128,128) S: [-128,128)
+; CHECK-NEXT: %q1.sext = sext i8 %q1 to i16
+; CHECK-NEXT: --> (sext i8 (2 + %len_norange) to i16) U: [-128,128) S: [-128,128)
+; CHECK-NEXT: Determining loop execution counts for: @f1
+;
+ entry:
%len = load i8, i8* %len_addr, !range !0
%len_norange = load i8, i8* %len_addr
-; CHECK: %len = load i8, i8* %len_addr, align 1, !range !0
-; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
-; CHECK: %len_norange = load i8, i8* %len_addr
-; CHECK-NEXT: --> %len_norange U: full-set S: full-set
%t0 = add i8 %len, -1
%t1 = add i8 %len, -2
-; CHECK: %t0 = add i8 %len, -1
-; CHECK-NEXT: --> (-1 + %len)<nsw> U: [-1,126) S: [-1,126)
-; CHECK: %t1 = add i8 %len, -2
-; CHECK-NEXT: --> (-2 + %len)<nsw> U: [-2,125) S: [-2,125)
%t0.sext = sext i8 %t0 to i16
%t1.sext = sext i8 %t1 to i16
-; CHECK: %t0.sext = sext i8 %t0 to i16
-; CHECK-NEXT: --> (-1 + (zext i8 %len to i16))<nsw> U: [-1,126) S: [-1,126)
-; CHECK: %t1.sext = sext i8 %t1 to i16
-; CHECK-NEXT: --> (-2 + (zext i8 %len to i16))<nsw> U: [-2,125) S: [-2,125)
%q0 = add i8 %len_norange, 1
%q1 = add i8 %len_norange, 2
-; CHECK: %q0 = add i8 %len_norange, 1
-; CHECK-NEXT: --> (1 + %len_norange) U: full-set S: full-set
-; CHECK: %q1 = add i8 %len_norange, 2
-; CHECK-NEXT: --> (2 + %len_norange) U: full-set S: full-set
%q0.sext = sext i8 %q0 to i16
%q1.sext = sext i8 %q1 to i16
-; CHECK: %q0.sext = sext i8 %q0 to i16
-; CHECK-NEXT: --> (sext i8 (1 + %len_norange) to i16) U: [-128,128) S: [-128,128)
-; CHECK: %q1.sext = sext i8 %q1 to i16
-; CHECK-NEXT: --> (sext i8 (2 + %len_norange) to i16) U: [-128,128) S: [-128,128)
ret void
}
define void @f2(i8* %len_addr) {
-; CHECK-LABEL: Classifying expressions for: @f2
- entry:
+; CHECK-LABEL: 'f2'
+; CHECK-NEXT: Classifying expressions for: @f2
+; CHECK-NEXT: %len = load i8, i8* %len_addr, align 1, !range !0
+; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
+; CHECK-NEXT: %len_norange = load i8, i8* %len_addr, align 1
+; CHECK-NEXT: --> %len_norange U: full-set S: full-set
+; CHECK-NEXT: %t0 = add i8 %len, 1
+; CHECK-NEXT: --> (1 + %len)<nuw><nsw> U: [1,-128) S: [1,-128)
+; CHECK-NEXT: %t1 = add i8 %len, 2
+; CHECK-NEXT: --> (2 + %len)<nuw> U: [2,-127) S: [2,-127)
+; CHECK-NEXT: %t0.zext = zext i8 %t0 to i16
+; CHECK-NEXT: --> (1 + (zext i8 %len to i16))<nuw><nsw> U: [1,128) S: [1,128)
+; CHECK-NEXT: %t1.zext = zext i8 %t1 to i16
+; CHECK-NEXT: --> (2 + (zext i8 %len to i16))<nuw><nsw> U: [2,129) S: [2,129)
+; CHECK-NEXT: %q0 = add i8 %len_norange, 1
+; CHECK-NEXT: --> (1 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q1 = add i8 %len_norange, 2
+; CHECK-NEXT: --> (2 + %len_norange) U: full-set S: full-set
+; CHECK-NEXT: %q0.zext = zext i8 %q0 to i16
+; CHECK-NEXT: --> (zext i8 (1 + %len_norange) to i16) U: [0,256) S: [0,256)
+; CHECK-NEXT: %q1.zext = zext i8 %q1 to i16
+; CHECK-NEXT: --> (zext i8 (2 + %len_norange) to i16) U: [0,256) S: [0,256)
+; CHECK-NEXT: Determining loop execution counts for: @f2
+;
+ entry:
%len = load i8, i8* %len_addr, !range !0
%len_norange = load i8, i8* %len_addr
-; CHECK: %len = load i8, i8* %len_addr, align 1, !range !0
-; CHECK-NEXT: --> %len U: [0,127) S: [0,127)
-; CHECK: %len_norange = load i8, i8* %len_addr
-; CHECK-NEXT: --> %len_norange U: full-set S: full-set
%t0 = add i8 %len, 1
%t1 = add i8 %len, 2
-; CHECK: %t0 = add i8 %len, 1
-; CHECK-NEXT: --> (1 + %len)<nuw><nsw>
-; CHECK: %t1 = add i8 %len, 2
-; CHECK-NEXT: --> (2 + %len)<nuw>
%t0.zext = zext i8 %t0 to i16
%t1.zext = zext i8 %t1 to i16
-; CHECK: %t0.zext = zext i8 %t0 to i16
-; CHECK-NEXT: --> (1 + (zext i8 %len to i16))<nuw><nsw> U: [1,128) S: [1,128)
-; CHECK: %t1.zext = zext i8 %t1 to i16
-; CHECK-NEXT: --> (2 + (zext i8 %len to i16))<nuw><nsw> U: [2,129) S: [2,129)
%q0 = add i8 %len_norange, 1
%q1 = add i8 %len_norange, 2
%q0.zext = zext i8 %q0 to i16
%q1.zext = zext i8 %q1 to i16
-; CHECK: %q0.zext = zext i8 %q0 to i16
-; CHECK-NEXT: --> (zext i8 (1 + %len_norange) to i16) U: [0,256) S: [0,256)
-; CHECK: %q1.zext = zext i8 %q1 to i16
-; CHECK-NEXT: --> (zext i8 (2 + %len_norange) to i16) U: [0,256) S: [0,256)
ret void
}
@@ -129,32 +143,111 @@ define void @f2(i8* %len_addr) {
@tmp_addr = external unnamed_addr global { %union, [2000 x i8] }
define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) {
-; CHECK-LABEL: Classifying expressions for: @f3
- entry:
+; CHECK-LABEL: 'f3'
+; CHECK-NEXT: Classifying expressions for: @f3
+; CHECK-NEXT: %x = load i8, i8* %x_addr, align 1
+; CHECK-NEXT: --> %x U: full-set S: full-set
+; CHECK-NEXT: %t0 = mul i8 %x, 4
+; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %t1 = add i8 %t0, 5
+; CHECK-NEXT: --> (5 + (4 * %x)) U: [5,2) S: [-123,-126)
+; CHECK-NEXT: %t1.zext = zext i8 %t1 to i16
+; CHECK-NEXT: --> (1 + (zext i8 (4 + (4 * %x)) to i16))<nuw><nsw> U: [1,254) S: [1,257)
+; CHECK-NEXT: %q0 = mul i8 %x, 4
+; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %q1 = add i8 %q0, 7
+; CHECK-NEXT: --> (7 + (4 * %x)) U: [7,4) S: [-121,-124)
+; CHECK-NEXT: %q1.zext = zext i8 %q1 to i16
+; CHECK-NEXT: --> (3 + (zext i8 (4 + (4 * %x)) to i16))<nuw><nsw> U: [3,256) S: [3,259)
+; CHECK-NEXT: %p0 = mul i8 %x, 4
+; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %p1 = add i8 %p0, 8
+; CHECK-NEXT: --> (8 + (4 * %x)) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %p1.zext = zext i8 %p1 to i16
+; CHECK-NEXT: --> (zext i8 (8 + (4 * %x)) to i16) U: [0,253) S: [0,256)
+; CHECK-NEXT: %r0 = mul i8 %x, 4
+; CHECK-NEXT: --> (4 * %x) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %r1 = add i8 %r0, -2
+; CHECK-NEXT: --> (-2 + (4 * %x)) U: [0,-1) S: [-128,127)
+; CHECK-NEXT: %r1.zext = zext i8 %r1 to i16
+; CHECK-NEXT: --> (2 + (zext i8 (-4 + (4 * %x)) to i16))<nuw><nsw> U: [2,255) S: [2,258)
+; CHECK-NEXT: %y = load i8, i8* %y_addr, align 1
+; CHECK-NEXT: --> %y U: full-set S: full-set
+; CHECK-NEXT: %s0 = mul i8 %x, 32
+; CHECK-NEXT: --> (32 * %x) U: [0,-31) S: [-128,97)
+; CHECK-NEXT: %s1 = mul i8 %y, 36
+; CHECK-NEXT: --> (36 * %y) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %s2 = add i8 %s0, %s1
+; CHECK-NEXT: --> ((32 * %x) + (36 * %y)) U: [0,-3) S: [-128,125)
+; CHECK-NEXT: %s3 = add i8 %s2, 5
+; CHECK-NEXT: --> (5 + (32 * %x) + (36 * %y)) U: full-set S: full-set
+; CHECK-NEXT: %s3.zext = zext i8 %s3 to i16
+; CHECK-NEXT: --> (1 + (zext i8 (4 + (32 * %x) + (36 * %y)) to i16))<nuw><nsw> U: [1,254) S: [1,257)
+; CHECK-NEXT: %ptr = bitcast [16 x i8]* @z_addr to i8*
+; CHECK-NEXT: --> @z_addr U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %int0 = ptrtoint i8* %ptr to i32
+; CHECK-NEXT: --> %int0 U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT: %int5 = add i32 %int0, 5
+; CHECK-NEXT: --> (5 + %int0) U: [5,2) S: [-2147483643,-2147483646)
+; CHECK-NEXT: %int.zext = zext i32 %int5 to i64
+; CHECK-NEXT: --> (1 + (zext i32 (4 + %int0) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
+; CHECK-NEXT: %ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8*
+; CHECK-NEXT: --> @z_addr_noalign U: full-set S: full-set
+; CHECK-NEXT: %int0_na = ptrtoint i8* %ptr_noalign to i32
+; CHECK-NEXT: --> %int0_na U: full-set S: full-set
+; CHECK-NEXT: %int5_na = add i32 %int0_na, 5
+; CHECK-NEXT: --> (5 + %int0_na) U: full-set S: full-set
+; CHECK-NEXT: %int.zext_na = zext i32 %int5_na to i64
+; CHECK-NEXT: --> (zext i32 (5 + %int0_na) to i64) U: [0,4294967296) S: [0,4294967296)
+; CHECK-NEXT: %tmp = load i32, i32* %tmp_addr, align 4
+; CHECK-NEXT: --> %tmp U: full-set S: full-set
+; CHECK-NEXT: %mul = and i32 %tmp, -4
+; CHECK-NEXT: --> (4 * (%tmp /u 4))<nuw> U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT: %add4 = add i32 %mul, 4
+; CHECK-NEXT: --> (4 + (4 * (%tmp /u 4))<nuw>) U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT: %add4.zext = zext i32 %add4 to i64
+; CHECK-NEXT: --> (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64) U: [0,4294967293) S: [0,4294967296)
+; CHECK-NEXT: %sunkaddr3 = mul i64 %add4.zext, 4
+; CHECK-NEXT: --> (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> U: [0,17179869169) S: [0,17179869181)
+; CHECK-NEXT: %sunkaddr4 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr3
+; CHECK-NEXT: --> ((4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr)<nsw> U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %sunkaddr5 = getelementptr inbounds i8, i8* %sunkaddr4, i64 4096
+; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %addr4.cast = bitcast i8* %sunkaddr5 to i32*
+; CHECK-NEXT: --> (4096 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %addr4.incr = getelementptr i32, i32* %addr4.cast, i64 1
+; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %add5 = add i32 %mul, 5
+; CHECK-NEXT: --> (5 + (4 * (%tmp /u 4))<nuw>) U: [5,2) S: [-2147483643,-2147483646)
+; CHECK-NEXT: %add5.zext = zext i32 %add5 to i64
+; CHECK-NEXT: --> (1 + (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
+; CHECK-NEXT: %sunkaddr0 = mul i64 %add5.zext, 4
+; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw>)<nuw><nsw> U: [4,17179869173) S: [4,17179869185)
+; CHECK-NEXT: %sunkaddr1 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr0
+; CHECK-NEXT: --> (4 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %sunkaddr2 = getelementptr inbounds i8, i8* %sunkaddr1, i64 4096
+; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: %addr5.cast = bitcast i8* %sunkaddr2 to i32*
+; CHECK-NEXT: --> (4100 + (4 * (zext i32 (4 + (4 * (%tmp /u 4))<nuw>) to i64))<nuw><nsw> + @tmp_addr) U: [0,-3) S: [-9223372036854775808,9223372036854775805)
+; CHECK-NEXT: Determining loop execution counts for: @f3
+;
+ entry:
%x = load i8, i8* %x_addr
%t0 = mul i8 %x, 4
%t1 = add i8 %t0, 5
%t1.zext = zext i8 %t1 to i16
-; CHECK: %t1.zext = zext i8 %t1 to i16
-; CHECK-NEXT: --> (1 + (zext i8 (4 + (4 * %x)) to i16))<nuw><nsw> U: [1,254) S: [1,257)
%q0 = mul i8 %x, 4
%q1 = add i8 %q0, 7
%q1.zext = zext i8 %q1 to i16
-; CHECK: %q1.zext = zext i8 %q1 to i16
-; CHECK-NEXT: --> (3 + (zext i8 (4 + (4 * %x)) to i16))<nuw><nsw> U: [3,256) S: [3,259)
%p0 = mul i8 %x, 4
%p1 = add i8 %p0, 8
%p1.zext = zext i8 %p1 to i16
-; CHECK: %p1.zext = zext i8 %p1 to i16
-; CHECK-NEXT: --> (zext i8 (8 + (4 * %x)) to i16) U: [0,253) S: [0,256)
%r0 = mul i8 %x, 4
%r1 = add i8 %r0, 254
%r1.zext = zext i8 %r1 to i16
-; CHECK: %r1.zext = zext i8 %r1 to i16
-; CHECK-NEXT: --> (2 + (zext i8 (-4 + (4 * %x)) to i16))<nuw><nsw> U: [2,255) S: [2,258)
%y = load i8, i8* %y_addr
%s0 = mul i8 %x, 32
@@ -162,22 +255,16 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) {
%s2 = add i8 %s0, %s1
%s3 = add i8 %s2, 5
%s3.zext = zext i8 %s3 to i16
-; CHECK: %s3.zext = zext i8 %s3 to i16
-; CHECK-NEXT: --> (1 + (zext i8 (4 + (32 * %x) + (36 * %y)) to i16))<nuw><nsw> U: [1,254) S: [1,257)
%ptr = bitcast [16 x i8]* @z_addr to i8*
%int0 = ptrtoint i8* %ptr to i32
%int5 = add i32 %int0, 5
%int.zext = zext i32 %int5 to i64
-; CHECK: %int.zext = zext i32 %int5 to i64
-; CHECK-NEXT: --> (1 + (zext i32 (4 + %int0) to i64))<nuw><nsw> U: [1,4294967294) S: [1,4294967297)
%ptr_noalign = bitcast [16 x i8]* @z_addr_noalign to i8*
%int0_na = ptrtoint i8* %ptr_noalign to i32
%int5_na = add i32 %int0_na, 5
%int.zext_na = zext i32 %int5_na to i64
-; CHECK: %int.zext_na = zext i32 %int5_na to i64
-; CHECK-NEXT: --> (zext i32 (5 + %int0_na) to i64) U: [0,4294967296) S: [0,4294967296)
%tmp = load i32, i32* %tmp_addr
%mul = and i32 %tmp, -4
@@ -188,8 +275,6 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) {
%sunkaddr5 = getelementptr inbounds i8, i8* %sunkaddr4, i64 4096
%addr4.cast = bitcast i8* %sunkaddr5 to i32*
%addr4.incr = getelementptr i32, i32* %addr4.cast, i64 1
-; CHECK: %addr4.incr = getelementptr i32, i32* %addr4.cast, i64 1
-; CHECK-NEXT: --> ([[C:4100]] + ([[SIZE:4]] * (zext i32 ([[OFFSET:4]] + ([[STRIDE:4]] * (%tmp /u [[STRIDE]]))<nuw>) to i64))<nuw><nsw> + @tmp_addr)
%add5 = add i32 %mul, 5
%add5.zext = zext i32 %add5 to i64
@@ -197,8 +282,6 @@ define void @f3(i8* %x_addr, i8* %y_addr, i32* %tmp_addr) {
%sunkaddr1 = getelementptr inbounds i8, i8* bitcast ({ %union, [2000 x i8] }* @tmp_addr to i8*), i64 %sunkaddr0
%sunkaddr2 = getelementptr inbounds i8, i8* %sunkaddr1, i64 4096
%addr5.cast = bitcast i8* %sunkaddr2 to i32*
-; CHECK: %addr5.cast = bitcast i8* %sunkaddr2 to i32*
-; CHECK-NEXT: --> ([[C]] + ([[SIZE]] * (zext i32 ([[OFFSET]] + ([[STRIDE]] * (%tmp /u [[STRIDE]]))<nuw>) to i64))<nuw><nsw> + @tmp_addr)
ret void
}
diff --git a/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll b/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
index 34758e11c0a2..135d3305061e 100644
--- a/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
+++ b/llvm/test/Analysis/ScalarEvolution/scalable-vector.ll
@@ -1,11 +1,16 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -scalar-evolution -analyze -enable-new-pm=0 < %s | FileCheck %s
; RUN: opt "-passes=print<scalar-evolution>" -disable-output < %s 2>&1 | FileCheck %s
-; CHECK: %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3
-; CHECK: --> (3 * sizeof(<vscale x 4 x i32>)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
-; CHECK: %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1
-; CHECK: --> (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set
define void @a(<vscale x 1 x i64> *%p) {
+; CHECK-LABEL: 'a'
+; CHECK-NEXT: Classifying expressions for: @a
+; CHECK-NEXT: %1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* null, i32 3
+; CHECK-NEXT: --> (3 * sizeof(<vscale x 4 x i32>)) U: [0,-15) S: [-9223372036854775808,9223372036854775793)
+; CHECK-NEXT: %2 = getelementptr <vscale x 1 x i64>, <vscale x 1 x i64>* %p, i32 1
+; CHECK-NEXT: --> (sizeof(<vscale x 1 x i64>) + %p) U: full-set S: full-set
+; CHECK-NEXT: Determining loop execution counts for: @a
+;
getelementptr <vscale x 4 x i32>, <vscale x 4 x i32> *null, i32 3
getelementptr <vscale x 1 x i64>, <vscale x 1 x i64> *%p, i32 1
ret void
More information about the llvm-commits
mailing list