mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-11-01 00:17:01 +00:00
148e8c9b8b
IRCE eliminates range checks of the form
0 <= A * I + B < Length
by splitting a loop's iteration space into three segments in a way
that the check is completely redundant in the middle segment. As an
example, IRCE will convert
len = < known positive >
for (i = 0; i < n; i++) {
if (0 <= i && i < len) {
do_something();
} else {
throw_out_of_bounds();
}
}
to
len = < known positive >
limit = smin(n, len)
// no first segment
for (i = 0; i < limit; i++) {
if (0 <= i && i < len) { // this check is fully redundant
do_something();
} else {
throw_out_of_bounds();
}
}
for (i = limit; i < n; i++) {
if (0 <= i && i < len) {
do_something();
} else {
throw_out_of_bounds();
}
}
IRCE can deal with multiple range checks in the same loop (it takes
the intersection of the ranges that will make each of them redundant
individually).
Currently IRCE does not do any profitability analysis. That is a
TODO.
Please note that the status of this pass is *experimental*, and it is
not part of any default pass pipeline. Having said that, I will love
to get feedback and general input from people interested in trying
this out.
This pass was originally r226201. It was reverted because it used C++
features not supported by MSVC 2012.
Differential Revision: http://reviews.llvm.org/D6693
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226238 91177308-0d34-0410-b5e6-96231b3b80d8
60 lines
2.2 KiB
LLVM
60 lines
2.2 KiB
LLVM
; RUN: opt -irce -S < %s | FileCheck %s
|
|
|
|
define void @single_access_with_preloop(i32 *%arr, i32 *%a_len_ptr, i32 %n, i32 %offset) {
|
|
entry:
|
|
%len = load i32* %a_len_ptr, !range !0
|
|
%first.itr.check = icmp sgt i32 %n, 0
|
|
br i1 %first.itr.check, label %loop, label %exit
|
|
|
|
loop:
|
|
%idx = phi i32 [ 0, %entry ] , [ %idx.next, %in.bounds ]
|
|
%idx.next = add i32 %idx, 1
|
|
%array.idx = add i32 %idx, %offset
|
|
%abc.high = icmp slt i32 %array.idx, %len
|
|
%abc.low = icmp sge i32 %array.idx, 0
|
|
%abc = and i1 %abc.low, %abc.high
|
|
br i1 %abc, label %in.bounds, label %out.of.bounds
|
|
|
|
in.bounds:
|
|
%addr = getelementptr i32* %arr, i32 %array.idx
|
|
store i32 0, i32* %addr
|
|
%next = icmp slt i32 %idx.next, %n
|
|
br i1 %next, label %loop, label %exit
|
|
|
|
out.of.bounds:
|
|
ret void
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: loop.preheader:
|
|
; CHECK: [[safe_start:[^ ]+]] = sub i32 0, %offset
|
|
; CHECK: [[safe_end:[^ ]+]] = sub i32 %len, %offset
|
|
; CHECK: [[exit_preloop_at_cond:[^ ]+]] = icmp slt i32 %n, [[safe_start]]
|
|
; CHECK: [[exit_preloop_at:[^ ]+]] = select i1 [[exit_preloop_at_cond]], i32 %n, i32 [[safe_start]]
|
|
; CHECK: [[exit_mainloop_at_cond:[^ ]+]] = icmp slt i32 %n, [[safe_end]]
|
|
; CHECK: [[exit_mainloop_at:[^ ]+]] = select i1 [[exit_mainloop_at_cond]], i32 %n, i32 [[safe_end]]
|
|
|
|
; CHECK-LABEL: in.bounds:
|
|
; CHECK: [[continue_mainloop_cond:[^ ]+]] = icmp slt i32 %idx.next, [[exit_mainloop_at]]
|
|
; CHECK: br i1 [[continue_mainloop_cond]], label %loop, label %main.exit.selector
|
|
|
|
; CHECK-LABEL: main.exit.selector:
|
|
; CHECK: [[mainloop_its_left:[^ ]+]] = icmp slt i32 %idx.next, %n
|
|
; CHECK: br i1 [[mainloop_its_left]], label %main.pseudo.exit, label %exit.loopexit
|
|
|
|
; CHECK-LABEL: in.bounds.preloop:
|
|
; CHECK: [[continue_preloop_cond:[^ ]+]] = icmp slt i32 %idx.next.preloop, [[exit_preloop_at]]
|
|
; CHECK: br i1 [[continue_preloop_cond]], label %loop.preloop, label %preloop.exit.selector
|
|
|
|
; CHECK-LABEL: preloop.exit.selector:
|
|
; CHECK: [[preloop_its_left:[^ ]+]] = icmp slt i32 %idx.next.preloop, %n
|
|
; CHECK: br i1 [[preloop_its_left]], label %preloop.pseudo.exit, label %exit.loopexit
|
|
|
|
; CHECK-LABEL: in.bounds.postloop:
|
|
; CHECK: %next.postloop = icmp slt i32 %idx.next.postloop, %n
|
|
; CHECK: br i1 %next.postloop, label %loop.postloop, label %exit.loopexit
|
|
|
|
!0 = !{i32 0, i32 2147483647}
|