410 changes: 408 additions & 2 deletions llvm/test/Analysis/ScalarEvolution/ranges.ll
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" -scev-range-iter-threshold=1 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>,verify<scalar-evolution>" 2>&1 | FileCheck %s
; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>,verify<scalar-evolution>" -scev-range-iter-threshold=1 2>&1 | FileCheck %s

target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"

Expand Down Expand Up @@ -126,3 +126,409 @@ loop:
%shr = lshr i32 %range.1, 1
br label %loop
}

define void @add_6(i32 %n) {
; CHECK-LABEL: 'add_6'
; CHECK-NEXT: Classifying expressions for: @add_6
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,6}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (6 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 6
; CHECK-NEXT: --> {6,+,6}<nuw><%loop> U: [6,-3) S: [-2147483648,2147483647) Exits: (6 + (6 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 6) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_6
; 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 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: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nsw i32 %iv, 6
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}
define void @add_7(i32 %n) {
; CHECK-LABEL: 'add_7'
; CHECK-NEXT: Classifying expressions for: @add_7
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,7}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 7
; CHECK-NEXT: --> {7,+,7}<nuw><%loop> U: [7,-3) S: [7,0) Exits: (7 + (7 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_7
; CHECK-NEXT: Loop %loop: backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 613566756
; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 7) + (1 umin %n))
; CHECK-NEXT: Predicates:
; CHECK: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nsw i32 %iv, 7
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}
define void @add_8(i32 %n) {
; CHECK-LABEL: 'add_8'
; CHECK-NEXT: Classifying expressions for: @add_8
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,8}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,2147483641) Exits: (8 * ((7 + %n) /u 8))<nuw> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 8
; CHECK-NEXT: --> {8,+,8}<nuw><%loop> U: [8,-7) S: [-2147483648,2147483641) Exits: (8 + (8 * ((7 + %n) /u 8))<nuw>) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_8
; CHECK-NEXT: Loop %loop: backedge-taken count is ((7 + %n) /u 8)
; CHECK-NEXT: Loop %loop: constant max backedge-taken count is 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: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nsw i32 %iv, 8
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @add_9(i32 %n) {
; CHECK-LABEL: 'add_9'
; CHECK-NEXT: Classifying expressions for: @add_9
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,9}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,-2147483648) Exits: (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 9
; CHECK-NEXT: --> {9,+,9}<nuw><%loop> U: [9,-3) S: [9,0) Exits: (9 + (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_9
; 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 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: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nsw i32 %iv, 9
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @add_10(i32 %n) {
; CHECK-LABEL: 'add_10'
; CHECK-NEXT: Classifying expressions for: @add_10
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,10}<nuw><nsw><%loop> U: [0,-2147483648) S: [0,2147483647) Exits: (10 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nsw i32 %iv, 10
; CHECK-NEXT: --> {10,+,10}<nuw><%loop> U: [10,-5) S: [-2147483648,2147483647) Exits: (10 + (10 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 10) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_10
; 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 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: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nsw i32 %iv, 10
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @add_8_wrap(i32 %n) {
; CHECK-LABEL: 'add_8_wrap'
; CHECK-NEXT: Classifying expressions for: @add_8_wrap
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,8}<%loop> U: [0,-7) S: [-2147483648,2147483641) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add i32 %iv, 8
; CHECK-NEXT: --> {8,+,8}<%loop> U: [0,-7) S: [-2147483648,2147483641) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_8_wrap
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add i32 %iv, 8
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @add_10_wrap(i32 %n) {
; CHECK-LABEL: 'add_10_wrap'
; CHECK-NEXT: Classifying expressions for: @add_10_wrap
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,10}<%loop> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add i32 %iv, 10
; CHECK-NEXT: --> {10,+,10}<%loop> U: [0,-1) S: [-2147483648,2147483647) Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @add_10_wrap
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add i32 %iv, 10
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_6(i32 %n) {
; CHECK-LABEL: 'mul_6'
; CHECK-NEXT: Classifying expressions for: @mul_6
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: [0,-1) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul nuw i32 %iv, 6
; CHECK-NEXT: --> (6 * %iv) U: [0,-3) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_6
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul nuw i32 %iv, 6
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_7(i32 %n) {
; CHECK-LABEL: 'mul_7'
; CHECK-NEXT: Classifying expressions for: @mul_7
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul nuw i32 %iv, 7
; CHECK-NEXT: --> (7 * %iv) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_7
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul nuw i32 %iv, 7
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_8(i32 %n) {
; CHECK-LABEL: 'mul_8'
; CHECK-NEXT: Classifying expressions for: @mul_8
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: [0,-7) S: [-2147483648,2147483585) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul nuw i32 %iv, 8
; CHECK-NEXT: --> (8 * %iv) U: [0,-63) S: [-2147483648,2147483585) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_8
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul nuw i32 %iv, 8
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_9(i32 %n) {
; CHECK-LABEL: 'mul_9'
; CHECK-NEXT: Classifying expressions for: @mul_9
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul nuw i32 %iv, 9
; CHECK-NEXT: --> (9 * %iv) U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_9
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul nuw i32 %iv, 9
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_10(i32 %n) {
; CHECK-LABEL: 'mul_10'
; CHECK-NEXT: Classifying expressions for: @mul_10
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: [0,-1) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul nuw i32 %iv, 10
; CHECK-NEXT: --> (10 * %iv) U: [0,-3) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_10
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul nuw i32 %iv, 10
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_8_wrap(i32 %n) {
; CHECK-LABEL: 'mul_8_wrap'
; CHECK-NEXT: Classifying expressions for: @mul_8_wrap
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: [0,-7) S: [-2147483648,2147483585) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul i32 %iv, 8
; CHECK-NEXT: --> (8 * %iv) U: [0,-63) S: [-2147483648,2147483585) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_8_wrap
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul i32 %iv, 8
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @mul_10_wrap(i32 %n) {
; CHECK-LABEL: 'mul_10_wrap'
; CHECK-NEXT: Classifying expressions for: @mul_10_wrap
; CHECK-NEXT: %iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> %iv U: [0,-1) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: %iv.inc = mul i32 %iv, 10
; CHECK-NEXT: --> (10 * %iv) U: [0,-3) S: [-2147483648,2147483645) Exits: <<Unknown>> LoopDispositions: { %loop: Variant }
; CHECK-NEXT: Determining loop execution counts for: @mul_10_wrap
; 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

loop:
%iv = phi i32 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = mul i32 %iv, 10
%becond = icmp ult i32 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}

define void @truncate(i16 %n) {
; %t is not a multiple of 7 because we cannot make the assumption through truncation
; CHECK-LABEL: 'truncate'
; CHECK-NEXT: Classifying expressions for: @truncate
; CHECK-NEXT: %iv = phi i16 [ 0, %entry ], [ %iv.inc, %loop ]
; CHECK-NEXT: --> {0,+,9}<nuw><%loop> U: [0,-6) S: [0,-6) Exits: (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %iv.inc = add nuw i16 %iv, 9
; CHECK-NEXT: --> {9,+,9}<nw><%loop> U: [9,3) S: [9,3) Exits: (9 + (9 * ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n)))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: %t = trunc i16 %iv.inc to i8
; CHECK-NEXT: --> {9,+,9}<%loop> U: full-set S: full-set Exits: (9 + (9 * (trunc i16 ((((-1 * (1 umin %n))<nuw><nsw> + %n) /u 9) + (1 umin %n)) to i8))) LoopDispositions: { %loop: Computable }
; CHECK-NEXT: Determining loop execution counts for: @truncate
; 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 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: Loop %loop: Trip multiple is 1
;
entry:
br label %loop

loop:
%iv = phi i16 [ 0, %entry ], [ %iv.inc, %loop ]
%iv.inc = add nuw i16 %iv, 9
%t = trunc i16 %iv.inc to i8
%becond = icmp ult i16 %iv, %n
br i1 %becond, label %loop, label %leave

leave:
ret void
}


2 changes: 1 addition & 1 deletion llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -520,7 +520,7 @@ define void @test_trip_multiple_5(i32 %num) {
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 1
; CHECK: Loop %for.body: Trip multiple is 5
;
entry:
%u = urem i32 %num, 5
Expand Down
306 changes: 306 additions & 0 deletions llvm/test/Analysis/ScalarEvolution/trip-multiple.ll
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,306 @@
; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
; RUN: opt -passes='print<scalar-evolution>,verify<scalar-evolution>' -disable-output %s 2>&1 | FileCheck %s

; Test trip multiples with functions that look like:

; void foo();
; void square(unsigned num) {
; if (num % 5 == 0)
; for (unsigned i = 0; i < num; ++i)
; foo();
; }

declare void @foo(...)

define void @trip_multiple_3(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_3'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_3
; CHECK-NEXT: %rem = urem i32 %num, 3
; CHECK-NEXT: --> ((-3 * (%num /u 3)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-1) S: [0,-1) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_3
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 3
;
entry:
%rem = urem i32 %num, 3
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}
define void @trip_multiple_4(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_4'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_4
; CHECK-NEXT: %rem = urem i32 %num, 4
; CHECK-NEXT: --> (zext i2 (trunc i32 %num to i2) to i32) U: [0,4) S: [0,4)
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-4) S: [0,-4) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-3) S: [1,-3) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_4
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 4
;
entry:
%rem = urem i32 %num, 4
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}

define void @trip_multiple_5(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_5'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_5
; CHECK-NEXT: %rem = urem i32 %num, 5
; CHECK-NEXT: --> ((-5 * (%num /u 5)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-1) S: [0,-1) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,0) S: [1,0) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_5
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -2
; CHECK-NEXT: Loop %for.body: symbolic max backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: Predicated backedge-taken count is (-1 + %num)
; CHECK-NEXT: Predicates:
; CHECK: Loop %for.body: Trip multiple is 5
;
entry:
%rem = urem i32 %num, 5
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}

define void @trip_multiple_6(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_6'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_6
; CHECK-NEXT: %rem = urem i32 %num, 6
; CHECK-NEXT: --> ((-6 * (%num /u 6)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-4) S: [0,-4) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-3) S: [1,-3) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_6
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 6
;
entry:
%rem = urem i32 %num, 6
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}

define void @trip_multiple_7(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_7'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_7
; CHECK-NEXT: %rem = urem i32 %num, 7
; CHECK-NEXT: --> ((-7 * (%num /u 7)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-4) S: [0,-4) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-3) S: [1,-3) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_7
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 7
;
entry:
%rem = urem i32 %num, 7
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}

define void @trip_multiple_8(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_8'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_8
; CHECK-NEXT: %rem = urem i32 %num, 8
; CHECK-NEXT: --> (zext i3 (trunc i32 %num to i3) to i32) U: [0,8) S: [0,8)
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-8) S: [0,-8) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-7) S: [1,-7) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_8
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 8
;
entry:
%rem = urem i32 %num, 8
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}
define void @trip_multiple_9(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_9'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_9
; CHECK-NEXT: %rem = urem i32 %num, 9
; CHECK-NEXT: --> ((-9 * (%num /u 9)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-4) S: [0,-4) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-3) S: [1,-3) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_9
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 9
;
entry:
%rem = urem i32 %num, 9
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}
define void @trip_multiple_10(i32 noundef %num) {
; CHECK-LABEL: 'trip_multiple_10'
; CHECK-NEXT: Classifying expressions for: @trip_multiple_10
; CHECK-NEXT: %rem = urem i32 %num, 10
; CHECK-NEXT: --> ((-10 * (%num /u 10)) + %num) U: full-set S: full-set
; CHECK-NEXT: %or.cond = and i1 %cmp, %cmp14
; CHECK-NEXT: --> (%cmp14 umin %cmp) U: full-set S: full-set
; CHECK-NEXT: %i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
; CHECK-NEXT: --> {0,+,1}<nuw><%for.body> U: [0,-6) S: [0,-6) Exits: (-1 + %num) LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: %inc = add nuw i32 %i.05, 1
; CHECK-NEXT: --> {1,+,1}<nuw><%for.body> U: [1,-5) S: [1,-5) Exits: %num LoopDispositions: { %for.body: Computable }
; CHECK-NEXT: Determining loop execution counts for: @trip_multiple_10
; CHECK-NEXT: Loop %for.body: backedge-taken count is (-1 + %num)
; CHECK-NEXT: Loop %for.body: constant max backedge-taken count is -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: Loop %for.body: Trip multiple is 10
;
entry:
%rem = urem i32 %num, 10
%cmp = icmp eq i32 %rem, 0
%cmp14 = icmp ne i32 %num, 0
%or.cond = and i1 %cmp, %cmp14
br i1 %or.cond, label %for.body, label %if.end

for.body: ; preds = %entry, %for.body
%i.05 = phi i32 [ %inc, %for.body ], [ 0, %entry ]
tail call void (...) @foo() #2
%inc = add nuw i32 %i.05, 1
%exitcond.not = icmp eq i32 %inc, %num
br i1 %exitcond.not, label %if.end, label %for.body

if.end: ; preds = %for.body, %entry
ret void
}