6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-15 23:31:37 +00:00
Code Issues Projects Releases Wiki Activity
llvm-6502/test/Analysis/ScalarEvolution/trip-count9.ll
Andrew Trick a5c5bc9948 SCEV should use NSW to get trip count for positive nonunit stride loops. 
SCEV currently fails to compute loop counts for nonunit stride
loops. This comes up frequently. It prevents loop optimization and
forces vectorization to insert extra loop checks.

For example:
void foo(int n, int *x) {
 for (int i = 0; i < n; i += 3) {
   x[i] = i;
   x[i+1] = i+1;
   x[i+2] = i+2;
 }
}

We need to properly handle the case in which limit > INT_MAX-stride. In
the above case: n > INT_MAX-3. In this case the loop counter will step
beyond the limit and overflow at the same time. However, knowing that
signed integer overlow in undefined, we can assume the loop test
behavior is arbitrary after overflow. This obeys both C undefined
behavior rules, and the more strict LLVM poison value rules.

I'm finally fixing this in response to Hal Finkel's persistence.
The most probable reason that we never optimized this before is that
we were being careful to handle case where the developer expected a
side-effect free infinite loop relying on overflow:

for (int i = 0; i < n; i += s) {
  ++j;
}
return j;

If INT_MAX+1 is a multiple of s and n > INT_MAX-s, then we might
expect an infinite loop. However there are plenty of ways to achieve
this effect without relying on undefined behavior of signed overflow.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@193015 91177308-0d34-0410-b5e6-96231b3b80d8
2013-10-18 23:43:53 +00:00

416 lines
12 KiB
LLVM
Raw Blame History

; RUN: opt -analyze -scalar-evolution -S < %s | FileCheck %s
; Every combination of
; - starting at 0, 1, or %x
; - steping by 1 or 2
; - stopping at %n or %n*2
; - using nsw, or not
; Some of these represent missed opportunities.
; CHECK: Determining loop execution counts for: @foo
; CHECK: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK: Loop %loop: max backedge-taken count is 6
define void @foo(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: Unpredictable max backedge-taken count.
define void @step2(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @start1
; CHECK: Loop %loop: backedge-taken count is (-2 + (2 smax %n))
; CHECK: Loop %loop: max backedge-taken count is 5
define void @start1(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @start1_step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: Unpredictable max backedge-taken count.
define void @start1_step2(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @startx
; CHECK: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK: Loop %loop: max backedge-taken count is -1
define void @startx(i4 %n, i4 %x) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @startx_step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: Unpredictable max backedge-taken count.
define void @startx_step2(i4 %n, i4 %x) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @nsw
; CHECK: Loop %loop: backedge-taken count is (-1 + %n)
; CHECK: Loop %loop: max backedge-taken count is 6
define void @nsw(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; If %n is INT4_MAX, %i.next will wrap. The nsw bit says that the
; result is undefined. Therefore, after the loop's second iteration,
; we are free to assume that the loop exits. This is valid because:
; (a) %i.next is a poison value after the second iteration, which can
; also be considered an undef value.
; (b) the return instruction enacts a side effect that is control
; dependent on the poison value.
;
; CHECK-LABEL: nsw_step2
; CHECK: Determining loop execution counts for: @nsw_step2
; CHECK: Loop %loop: backedge-taken count is ((-1 + %n) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 2
define void @nsw_step2(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK-LABEL: nsw_start1
; CHECK: Determining loop execution counts for: @nsw_start1
; CHECK: Loop %loop: backedge-taken count is (-2 + (2 smax %n))
; CHECK: Loop %loop: max backedge-taken count is 5
define void @nsw_start1(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @nsw_start1_step2
; CHECK: Loop %loop: backedge-taken count is ((-2 + (3 smax %n)) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 2
define void @nsw_start1_step2(i4 %n) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @nsw_startx
; CHECK: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax %n))
; CHECK: Loop %loop: max backedge-taken count is -1
define void @nsw_startx(i4 %n, i4 %x) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @nsw_startx_step2
; CHECK: Loop %loop: backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax %n)) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 7
define void @nsw_startx_step2(i4 %n, i4 %x) {
entry:
%s = icmp sgt i4 %n, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %n
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even
; CHECK: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK: Loop %loop: max backedge-taken count is 5
define void @even(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: max backedge-taken count is 2
define void @even_step2(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_start1
; CHECK: Loop %loop: backedge-taken count is (-2 + (2 smax (2 * %n)))
; CHECK: Loop %loop: max backedge-taken count is 4
define void @even_start1(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_start1_step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: max backedge-taken count is 2
define void @even_start1_step2(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_startx
; CHECK: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK: Loop %loop: max backedge-taken count is -1
define void @even_startx(i4 %n, i4 %x) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_startx_step2
; CHECK: Loop %loop: Unpredictable backedge-taken count.
; CHECK: Loop %loop: max backedge-taken count is 7
define void @even_startx_step2(i4 %n, i4 %x) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw
; CHECK: Loop %loop: backedge-taken count is (-1 + (2 * %n))
; CHECK: Loop %loop: max backedge-taken count is 5
define void @even_nsw(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw_step2
; CHECK: Loop %loop: backedge-taken count is ((-1 + (2 * %n)) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 2
define void @even_nsw_step2(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 0, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw_start1
; CHECK: Loop %loop: backedge-taken count is (-2 + (2 smax (2 * %n)))
; CHECK: Loop %loop: max backedge-taken count is 4
define void @even_nsw_start1(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw_start1_step2
; CHECK: Loop %loop: backedge-taken count is ((-2 + (3 smax (2 * %n))) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 2
define void @even_nsw_start1_step2(i4 %n) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ 1, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw_startx
; CHECK: Loop %loop: backedge-taken count is (-1 + (-1 * %x) + ((1 + %x) smax (2 * %n)))
; CHECK: Loop %loop: max backedge-taken count is -1
define void @even_nsw_startx(i4 %n, i4 %x) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 1
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
; CHECK: Determining loop execution counts for: @even_nsw_startx_step2
; CHECK: Loop %loop: backedge-taken count is ((-1 + (-1 * %x) + ((2 + %x) smax (2 * %n))) /u 2)
; CHECK: Loop %loop: max backedge-taken count is 7
define void @even_nsw_startx_step2(i4 %n, i4 %x) {
entry:
%m = shl i4 %n, 1
%s = icmp sgt i4 %m, 0
br i1 %s, label %loop, label %exit
loop:
%i = phi i4 [ %x, %entry ], [ %i.next, %loop ]
%i.next = add nsw i4 %i, 2
%t = icmp slt i4 %i.next, %m
br i1 %t, label %loop, label %exit
exit:
ret void
}
Reference in New Issue View Git Blame Copy Permalink