| ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py |
| ; RUN: opt -disable-output "-passes=print<scalar-evolution>" < %s 2>&1 | FileCheck %s |
| |
| define void @test_lshr() { |
| ; CHECK-LABEL: 'test_lshr' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1023, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [0,1024) S: [0,1024) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 1 |
| ; CHECK-NEXT: --> (%iv.lshr /u 2) U: [0,512) S: [0,512) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.lshr = phi i64 [1023, %entry], [%iv.lshr.next, %loop] |
| %iv.lshr.next = lshr i64 %iv.lshr, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Deliberate overflow doesn't change range |
| define void @test_lshr2() { |
| ; CHECK-LABEL: 'test_lshr2' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr2 |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1023, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [0,1024) S: [0,1024) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 4 |
| ; CHECK-NEXT: --> (%iv.lshr /u 16) U: [0,64) S: [0,64) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr2 |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.lshr = phi i64 [1023, %entry], [%iv.lshr.next, %loop] |
| %iv.lshr.next = lshr i64 %iv.lshr, 4 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| |
| define void @test_ashr_zeros() { |
| ; CHECK-LABEL: 'test_ashr_zeros' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_zeros |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ 1023, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [0,1024) S: [0,1024) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [0,512) S: [0,512) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_zeros |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.ashr = phi i64 [1023, %entry], [%iv.ashr.next, %loop] |
| %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_ashr_ones() { |
| ; CHECK-LABEL: 'test_ashr_ones' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_ones |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ -1023, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [-1023,0) S: [-1023,0) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-512,0) S: [-512,0) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_ones |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.ashr = phi i64 [-1023, %entry], [%iv.ashr.next, %loop] |
| %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Same as previous, but swapped operands to phi |
| define void @test_ashr_ones2() { |
| ; CHECK-LABEL: 'test_ashr_ones2' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_ones2 |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ %iv.ashr.next, %loop ], [ -1023, %entry ] |
| ; CHECK-NEXT: --> %iv.ashr U: [-1023,0) S: [-1023,0) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-512,0) S: [-512,0) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_ones2 |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.ashr = phi i64 [%iv.ashr.next, %loop], [-1023, %entry] |
| %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| |
| ; negative case for when start is unknown |
| define void @test_ashr_unknown(i64 %start) { |
| ; CHECK-LABEL: 'test_ashr_unknown' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_unknown |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ %start, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-4611686018427387904,4611686018427387904) S: [-4611686018427387904,4611686018427387904) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_unknown |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.ashr = phi i64 [%start, %entry], [%iv.ashr.next, %loop] |
| %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Negative case where we don't have a (shift) recurrence because the operands |
| ; of the ashr are swapped. (This does end up being a divide recurrence.) |
| define void @test_ashr_wrong_op(i64 %start) { |
| ; CHECK-LABEL: 'test_ashr_wrong_op' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_wrong_op |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ %start, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 1, %iv.ashr |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-2,2) S: [-2,2) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_wrong_op |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.ashr = phi i64 [%start, %entry], [%iv.ashr.next, %loop] |
| %iv.ashr.next = ashr i64 1, %iv.ashr |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| |
| define void @test_shl() { |
| ; CHECK-LABEL: 'test_shl' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 8, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [0,-7) S: [-9223372036854775808,9223372036854775793) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, 1 |
| ; CHECK-NEXT: --> (2 * %iv.shl) U: [0,-15) S: [-9223372036854775808,9223372036854775793) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl |
| ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv.shl = phi i64 [8, %entry], [%iv.shl.next, %loop] |
| %iv.shl.next = shl i64 %iv.shl, 1 |
| br i1 undef, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; use trip count to refine |
| define void @test_shl2() { |
| ; CHECK-LABEL: 'test_shl2' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl2 |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [4,65) S: [4,65) Exits: 64 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, 1 |
| ; CHECK-NEXT: --> (2 * %iv.shl)<nuw><nsw> U: [8,129) S: [8,129) Exits: 128 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl2 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Variable shift with a tight upper bound |
| define void @test_shl3(i1 %c) { |
| ; CHECK-LABEL: 'test_shl3' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl3 |
| ; CHECK-NEXT: %shiftamt = select i1 %c, i64 1, i64 0 |
| ; CHECK-NEXT: --> %shiftamt U: [0,2) S: [0,2) |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [4,65) S: [4,65) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| ; CHECK-NEXT: --> %iv.shl.next U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl3 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| %shiftamt = select i1 %c, i64 1, i64 0 |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; edge case on max value not overflowing |
| define void @test_shl4() { |
| ; CHECK-LABEL: 'test_shl4' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl4 |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,61) S: [0,61) Exits: 60 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [4,4611686018427387905) S: [4,4611686018427387905) Exits: 4611686018427387904 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,62) S: [1,62) Exits: 61 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, 1 |
| ; CHECK-NEXT: --> (2 * %iv.shl)<nuw> U: [8,-9223372036854775807) S: [-9223372036854775808,9223372036854775801) Exits: -9223372036854775808 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl4 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 60 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 60 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 60 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 61 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, 1 |
| %cmp = icmp eq i64 %iv, 60 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; other side of edge case from previous test |
| define void @test_shl5() { |
| ; CHECK-LABEL: 'test_shl5' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl5 |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,62) S: [0,62) Exits: 61 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [0,-3) S: [-9223372036854775808,9223372036854775801) Exits: -9223372036854775808 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,63) S: [1,63) Exits: 62 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, 1 |
| ; CHECK-NEXT: --> (2 * %iv.shl) U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: 0 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl5 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 61 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 61 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 61 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 62 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, 1 |
| %cmp = icmp eq i64 %iv, 61 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Loop varying (but tightly bounded) shift amount |
| define void @test_shl6(i1 %c) { |
| ; CHECK-LABEL: 'test_shl6' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl6 |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [4,65) S: [4,65) Exits: 16 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %shiftamt = and i64 %iv, 1 |
| ; CHECK-NEXT: --> (zext i1 {false,+,true}<%loop> to i64) U: [0,2) S: [0,2) Exits: 0 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| ; CHECK-NEXT: --> %iv.shl.next U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: 16 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl6 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %shiftamt = and i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Unanalyzeable shift amount |
| define void @test_shl7(i1 %c, i64 %shiftamt) { |
| ; CHECK-LABEL: 'test_shl7' |
| ; CHECK-NEXT: Classifying expressions for: @test_shl7 |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl = phi i64 [ 4, %entry ], [ %iv.shl.next, %loop ] |
| ; CHECK-NEXT: --> %iv.shl U: [0,-3) S: [-9223372036854775808,9223372036854775805) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| ; CHECK-NEXT: --> %iv.shl.next U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_shl7 |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.shl = phi i64 [4, %entry], [%iv.shl.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.shl.next = shl i64 %iv.shl, %shiftamt |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Corner case where phi is not in a loop because it is in unreachable |
| ; code (which loopinfo ignores, but simple recurrence matching does not). |
| define void @unreachable_phi() { |
| ; CHECK-LABEL: 'unreachable_phi' |
| ; CHECK-NEXT: Classifying expressions for: @unreachable_phi |
| ; CHECK-NEXT: %p_58.addr.1 = phi i32 [ undef, %unreachable1 ], [ %sub2629, %unreachable2 ] |
| ; CHECK-NEXT: --> undef U: full-set S: full-set |
| ; CHECK-NEXT: %sub2629 = sub i32 %p_58.addr.1, 1 |
| ; CHECK-NEXT: --> undef U: full-set S: full-set |
| ; CHECK-NEXT: Determining loop execution counts for: @unreachable_phi |
| ; |
| entry: |
| ret void |
| |
| unreachable1: |
| br label %unreachable_nonloop |
| unreachable2: |
| br label %unreachable_nonloop |
| unreachable_nonloop: |
| %p_58.addr.1 = phi i32 [ undef, %unreachable1 ], [ %sub2629, %unreachable2 ] |
| %sub2629 = sub i32 %p_58.addr.1, 1 |
| unreachable |
| } |
| |
| ; Corner case where phi is not in loop header because binop is in unreachable |
| ; code (which loopinfo ignores, but simple recurrence matching does not). |
| define void @unreachable_binop() { |
| ; CHECK-LABEL: 'unreachable_binop' |
| ; CHECK-NEXT: Classifying expressions for: @unreachable_binop |
| ; CHECK-NEXT: %p_58.addr.1 = phi i32 [ undef, %header ], [ %sub2629, %unreachable ] |
| ; CHECK-NEXT: --> %p_58.addr.1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %header: Variant } |
| ; CHECK-NEXT: %sub2629 = sub i32 %p_58.addr.1, 1 |
| ; CHECK-NEXT: --> undef U: full-set S: full-set |
| ; CHECK-NEXT: Determining loop execution counts for: @unreachable_binop |
| ; CHECK-NEXT: Loop %header: Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %header: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %header: Unpredictable predicated backedge-taken count. |
| ; |
| entry: |
| br label %header |
| |
| header: |
| br label %for.cond2295 |
| |
| for.cond2295: |
| %p_58.addr.1 = phi i32 [ undef, %header ], [ %sub2629, %unreachable ] |
| br i1 undef, label %if.then2321, label %header |
| |
| if.then2321: |
| ret void |
| |
| unreachable: |
| %sub2629 = sub i32 %p_58.addr.1, 1 |
| br label %for.cond2295 |
| } |
| |
| ; Was pr49856. We can match the recurrence without a loop |
| ; since dominance collapses in unreachable code. Conceptually, |
| ; this is a recurrence which only executes one iteration. |
| define void @nonloop_recurrence() { |
| ; CHECK-LABEL: 'nonloop_recurrence' |
| ; CHECK-NEXT: Classifying expressions for: @nonloop_recurrence |
| ; CHECK-NEXT: %tmp = phi i32 [ 2, %bb ], [ %tmp2, %bb3 ] |
| ; CHECK-NEXT: --> %tmp U: [1,-2147483648) S: [0,-2147483648) |
| ; CHECK-NEXT: %tmp2 = add nuw nsw i32 %tmp, 1 |
| ; CHECK-NEXT: --> (1 + %tmp)<nuw> U: [1,-2147483647) S: [1,-2147483647) |
| ; CHECK-NEXT: Determining loop execution counts for: @nonloop_recurrence |
| ; |
| bb: |
| br label %bb1 |
| |
| bb1: ; preds = %bb3, %bb |
| %tmp = phi i32 [ 2, %bb ], [ %tmp2, %bb3 ] |
| %tmp2 = add nuw nsw i32 %tmp, 1 |
| ret void |
| |
| bb3: ; No predecessors! |
| br label %bb1 |
| } |
| |
| ; Tweak of pr49856 test case - analogous, but there is a loop |
| ; it's trip count simply doesn't relate to the single iteration |
| ; "recurrence" we found. |
| define void @nonloop_recurrence_2() { |
| ; CHECK-LABEL: 'nonloop_recurrence_2' |
| ; CHECK-NEXT: Classifying expressions for: @nonloop_recurrence_2 |
| ; CHECK-NEXT: %tmp = phi i32 [ 2, %loop ], [ %tmp2, %bb3 ] |
| ; CHECK-NEXT: --> %tmp U: [1,-2147483648) S: [0,-2147483648) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %tmp2 = add nuw nsw i32 %tmp, 1 |
| ; CHECK-NEXT: --> (1 + %tmp)<nuw> U: [1,-2147483647) S: [1,-2147483647) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @nonloop_recurrence_2 |
| ; CHECK-NEXT: Loop %loop: <multiple exits> Unpredictable backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable max backedge-taken count. |
| ; CHECK-NEXT: Loop %loop: Unpredictable predicated backedge-taken count. |
| ; |
| bb: |
| br label %loop |
| |
| loop: |
| br label %bb1 |
| bb1: ; preds = %bb3, %loop |
| %tmp = phi i32 [ 2, %loop ], [ %tmp2, %bb3 ] |
| %tmp2 = add nuw nsw i32 %tmp, 1 |
| br label %loop |
| |
| bb3: ; No predecessors! |
| br label %bb1 |
| } |
| |
| |
| ; Next batch of tests show where we can get tighter ranges on ashr/lshr |
| ; by using the trip count information on the loop. |
| |
| define void @test_ashr_tc_positive() { |
| ; CHECK-LABEL: 'test_ashr_tc_positive' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_tc_positive |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ 1023, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [63,1024) S: [63,1024) Exits: 63 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [0,512) S: [0,512) Exits: 31 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_positive |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.ashr = phi i64 [1023, %entry], [%iv.ashr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.ashr.next = ashr i64 %iv.ashr, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_ashr_tc_negative() { |
| ; CHECK-LABEL: 'test_ashr_tc_negative' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_tc_negative |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr = phi i8 [ -128, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [-128,-7) S: [-128,-7) Exits: -8 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i8 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-64,0) S: [-64,0) Exits: -4 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_negative |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.ashr = phi i8 [128, %entry], [%iv.ashr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.ashr.next = ashr i8 %iv.ashr, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_ashr_tc_either(i1 %a) { |
| ; CHECK-LABEL: 'test_ashr_tc_either' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_tc_either |
| ; CHECK-NEXT: %start = sext i1 %a to i8 |
| ; CHECK-NEXT: --> (sext i1 %a to i8) U: [-1,1) S: [-1,1) |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,61) S: [0,61) Exits: 60 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr = phi i8 [ %start, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [-16,16) S: [-16,16) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,62) S: [1,62) Exits: 61 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i8 %iv.ashr, 1 |
| ; CHECK-NEXT: --> %iv.ashr.next U: [-16,16) S: [-16,16) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_tc_either |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 60 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 60 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 60 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 61 |
| ; |
| entry: |
| %start = sext i1 %a to i8 |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.ashr = phi i8 [%start, %entry], [%iv.ashr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.ashr.next = ashr i8 %iv.ashr, 1 |
| %cmp = icmp eq i64 %iv, 60 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_ashr_zero_shift() { |
| ; CHECK-LABEL: 'test_ashr_zero_shift' |
| ; CHECK-NEXT: Classifying expressions for: @test_ashr_zero_shift |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr = phi i64 [ 1023, %entry ], [ %iv.ashr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.ashr U: [1023,1024) S: [1023,1024) Exits: 1023 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.ashr.next = ashr i64 %iv.ashr, 0 |
| ; CHECK-NEXT: --> %iv.ashr U: [1023,1024) S: [1023,1024) Exits: 1023 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_ashr_zero_shift |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.ashr = phi i64 [1023, %entry], [%iv.ashr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.ashr.next = ashr i64 %iv.ashr, 0 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_lshr_tc_positive() { |
| ; CHECK-LABEL: 'test_lshr_tc_positive' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_tc_positive |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1023, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [63,1024) S: [63,1024) Exits: 63 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 1 |
| ; CHECK-NEXT: --> (%iv.lshr /u 2) U: [31,512) S: [31,512) Exits: 31 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_positive |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i64 [1023, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i64 %iv.lshr, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_lshr_tc_negative() { |
| ; CHECK-LABEL: 'test_lshr_tc_negative' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_tc_negative |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i8 [ -1, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [15,0) S: [-1,-128) Exits: 15 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i8 %iv.lshr, 1 |
| ; CHECK-NEXT: --> (%iv.lshr /u 2) U: [7,-128) S: [7,-128) Exits: 7 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_negative |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i8 [-1, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i8 %iv.lshr, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_lshr_tc_either(i1 %a) { |
| ; CHECK-LABEL: 'test_lshr_tc_either' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_tc_either |
| ; CHECK-NEXT: %start = sext i1 %a to i8 |
| ; CHECK-NEXT: --> (sext i1 %a to i8) U: [-1,1) S: [-1,1) |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i8 [ %start, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [-1,-128) S: [-1,-128) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i8 %iv.lshr, 1 |
| ; CHECK-NEXT: --> (%iv.lshr /u 2) U: [0,-128) S: [0,-128) Exits: <<Unknown>> LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_tc_either |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| %start = sext i1 %a to i8 |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i8 [%start, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i8 %iv.lshr, 1 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_lshr_zero_shift() { |
| ; CHECK-LABEL: 'test_lshr_zero_shift' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_zero_shift |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1023, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [1023,1024) S: [1023,1024) Exits: 1023 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 0 |
| ; CHECK-NEXT: --> %iv.lshr U: [1023,1024) S: [1023,1024) Exits: 1023 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_zero_shift |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i64 [1023, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i64 %iv.lshr, 0 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| |
| define void @test_lshr_power_of_2_start() { |
| ; CHECK-LABEL: 'test_lshr_power_of_2_start' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_power_of_2_start |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1024, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [4,1025) S: [4,1025) Exits: 4 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| ; CHECK-NEXT: --> (%iv.lshr /u 4) U: [1,257) S: [1,257) Exits: 1 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_power_of_2_start |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i64 [1024, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| ; Starting value is chosen not to be near power of 2 |
| define void @test_lshr_arbitrary_start() { |
| ; CHECK-LABEL: 'test_lshr_arbitrary_start' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_arbitrary_start |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 957, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [3,958) S: [3,958) Exits: 3 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| ; CHECK-NEXT: --> (%iv.lshr /u 4) U: [0,240) S: [0,240) Exits: 0 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_arbitrary_start |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i64 [957, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |
| |
| define void @test_lshr_start_power_of_2_plus_one() { |
| ; CHECK-LABEL: 'test_lshr_start_power_of_2_plus_one' |
| ; CHECK-NEXT: Classifying expressions for: @test_lshr_start_power_of_2_plus_one |
| ; CHECK-NEXT: %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ] |
| ; CHECK-NEXT: --> {0,+,1}<%loop> U: [0,5) S: [0,5) Exits: 4 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr = phi i64 [ 1025, %entry ], [ %iv.lshr.next, %loop ] |
| ; CHECK-NEXT: --> %iv.lshr U: [4,1026) S: [4,1026) Exits: 4 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: %iv.next = add i64 %iv, 1 |
| ; CHECK-NEXT: --> {1,+,1}<%loop> U: [1,6) S: [1,6) Exits: 5 LoopDispositions: { %loop: Computable } |
| ; CHECK-NEXT: %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| ; CHECK-NEXT: --> (%iv.lshr /u 4) U: [1,257) S: [1,257) Exits: 1 LoopDispositions: { %loop: Variant } |
| ; CHECK-NEXT: Determining loop execution counts for: @test_lshr_start_power_of_2_plus_one |
| ; CHECK-NEXT: Loop %loop: backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: max backedge-taken count is 4 |
| ; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is 4 |
| ; CHECK-NEXT: Predicates: |
| ; CHECK: Loop %loop: Trip multiple is 5 |
| ; |
| entry: |
| br label %loop |
| loop: |
| %iv = phi i64 [0, %entry], [%iv.next, %loop] |
| %iv.lshr = phi i64 [1025, %entry], [%iv.lshr.next, %loop] |
| %iv.next = add i64 %iv, 1 |
| %iv.lshr.next = lshr i64 %iv.lshr, 2 |
| %cmp = icmp eq i64 %iv, 4 |
| br i1 %cmp, label %exit, label %loop |
| exit: |
| ret void |
| } |