This is an archive of the discontinued LLVM Phabricator instance.

Differential D16095

[Polly] Prepare unit tests for update to ISL 0.16
ClosedPublic

Authored by Meinersbur on Jan 11 2016, 4:05 PM.

Details

Reviewers
grosser
jdoerfert
Commits
rG5a9a65e43fb7: Prepare unit tests for update to ISL 0.16
rPLO257851: Prepare unit tests for update to ISL 0.16
rL257851: Prepare unit tests for update to ISL 0.16
Summary

ISL 0.16 will change how sets are printed which breaks 117 unit tests that text-compare printed sets. This patch re-formats most of these unit tests using a script and small manual editing on top of that. When actually updating ISL, most work is done by just re-running the script to adapt to the changed output.

Some tests that compare IR and tests with single CHECK-lines that can be easily updated manually are not included here.

The re-format script will also be committed afterwards. The per-test formatter invocation command lines options will not be added in the near future because it is ad hoc and would overwrite the manual edits. Ideally it also shouldn't be required anymore because ISL's set printing has become more stable in 0.16.

Diff Detail

Repository
rL LLVM

Event Timeline

Meinersbur updated this revision to Diff 44573.Jan 11 2016, 4:05 PM
Meinersbur retitled this revision from to [Polly] Prepare unit tests for update to ISL 0.16 (WIP).
Meinersbur updated this object.
Meinersbur added reviewers: grosser, jdoerfert.
Meinersbur added a project: Restricted Project.
Meinersbur added subscribers: pollydev, llvm-commits.
grosser edited edge metadata.Jan 11 2016, 10:42 PM

Hi Michael,

the patch looks to me very sensible. I would be generally comfortable to commit something like this. What are the remaining changes you had in mind?

Regarding the script, I think it would be great if the --check-include options could eventually (not necessary for this commit) be auto-derived. Also, does --check-position=autodetect work after this initial formatting? If both would, the majority of the options in https://raw.githubusercontent.com/Meinersbur/polly/update_test/test/CMakeLists.txt would not be necessary any more, right? I think this is would be desirable.

test/ScopInfo/remarks.ll
3 ↗(On Diff #44573)

Why was this line dropped?

Meinersbur added a comment.Jan 12 2016, 4:32 AM
In D16095#324467, @grosser wrote:

the patch looks to me very sensible. I would be generally comfortable to commit something like this. What are the remaining changes you had in mind?

Removing additional lines in reduction_simple_iv_debug_wrapped_dependences.ll and sequential_loops.ll, re-add possibly interesting CHECK-NOT lines that are not covered by CHECK-NEXTs.

Regarding the script, I think it would be great if the --check-include options could eventually (not necessary for this commit) be auto-derived.

Can you share your idea how this autodetection could work?

Also, does --check-position=autodetect work after this initial formatting?

Yes, it looks for the position of the first CHECK, and the reformatted one with --check-position=autodetect will still be in the same position.

If both would, the majority of the options in https://raw.githubusercontent.com/Meinersbur/polly/update_test/test/CMakeLists.txt would not be necessary any more, right?

For the moment I do not plan commit the CMakeLists.txt (appart from the configure_file) in its current form as it is too preliminary, would again destroy any manual edits and from our last phone call discussion it seemed there wouldn't be that much interest.

I think this is would be desirable.

Why?

test/ScopInfo/remarks.ll
3 ↗(On Diff #44573)

Good catch

The RUN line here emits binary data to FileCheck, so I added -analyze (alternatively -S would be possible, but there is another unit test also checking the remark which uses -analyze)

The -analyze output is printed to stdout while the remarks are printed to stderr. How they are combined depends on the receiving program (Terminal, FileCheck, or the python script). For some reason (buffering?) python combines the stdline without its \n, so it writes:

Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'entry.split => if.remark: test/ScopInfo/remarks.c:4:7: SCoP begins here

This is not recognized as a "Remark"-line by the script. Does opt maybe have an option to suppress its output?

grosser added a comment.Jan 12 2016, 4:39 AM
In D16095#324609, @Meinersbur wrote:
In D16095#324467, @grosser wrote:

the patch looks to me very sensible. I would be generally comfortable to commit something like this. What are the remaining changes you had in mind?

Removing additional lines in reduction_simple_iv_debug_wrapped_dependences.ll and sequential_loops.ll, re-add possibly interesting CHECK-NOT lines that are not covered by CHECK-NEXTs.

Cool.

Regarding the script, I think it would be great if the --check-include options could eventually (not necessary for this commit) be auto-derived.

Can you share your idea how this autodetection could work?

It seems you have only a couple of options Statements, AssumedContext, InvariantAccesses. Most (all) of these options could possibly be identified
by looking for specific string in the CHECK lines. E.g., for AssumedContext.

Also, does --check-position=autodetect work after this initial formatting?

Yes, it looks for the position of the first CHECK, and the reformatted one with --check-position=autodetect will still be in the same position.

Nice.

If both would, the majority of the options in https://raw.githubusercontent.com/Meinersbur/polly/update_test/test/CMakeLists.txt would not be necessary any more, right?

For the moment I do not plan commit the CMakeLists.txt (appart from the configure_file) in its current form as it is too preliminary, would again destroy any manual edits and from our last phone call discussion it seemed there wouldn't be that much interest.

Sure.

I think this is would be desirable.

Why?

If I would like to update a test case using your script, it's nicer if it just works rather than me having to figure out all options.

Best,
Tobias

Meinersbur added a comment.Jan 12 2016, 5:04 AM
In D16095#324622, @grosser wrote:

Regarding the script, I think it would be great if the --check-include options could eventually (not necessary for this commit) be auto-derived.

Can you share your idea how this autodetection could work?

It seems you have only a couple of options Statements, AssumedContext, InvariantAccesses. Most (all) of these options could possibly be identified
by looking for specific string in the CHECK lines. E.g., for AssumedContext.

This is extremely fragile. Just imagine we change the -analyze output. The script would need to recognize the old and new format.
And because we are not upgrading all tests at once, all the formats of the past, including degenerated ones. Also, this would not work with new test cases. You'd need to first write a correct test case manually before one can use the script.

I think this is would be desirable.

Why?

If I would like to update a test case using your script, it's nicer if it just works rather than me having to figure out all options.

We might also standardize unit tests. That is, tests in DependenceInfo have all dependences checked, ScoopInfo the Statements, etc.

Meinersbur updated this revision to Diff 44640.Jan 12 2016, 9:03 AM
Meinersbur edited edge metadata.
Meinersbur marked 2 inline comments as done.

Solved problem of interleaving stderr/stdout by disabling opt's stdout output and testing it with its own RUN line

Meinersbur updated this revision to Diff 44815.Jan 13 2016, 4:56 PM
Meinersbur retitled this revision from [Polly] Prepare unit tests for update to ISL 0.16 (WIP) to [Polly] Prepare unit tests for update to ISL 0.16.
Meinersbur updated this object.

Manual edits (+some minor script changes)

grosser accepted this revision.Jan 13 2016, 9:27 PM
grosser edited edge metadata.

lgtm

This revision is now accepted and ready to land.Jan 13 2016, 9:27 PM
Closed by commit rL257851: Prepare unit tests for update to ISL 0.16 (authored by Meinersbur). · Explain WhyJan 14 2016, 4:52 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
polly/
trunk/
test/
DependenceInfo/
32 lines
27 lines
16 lines
16 lines
17 lines
4 lines
17 lines
4 lines
17 lines
32 lines
4 lines
17 lines
18 lines
21 lines
22 lines
18 lines
16 lines
115 lines
18 lines
16 lines
16 lines
168 lines
ScheduleOptimizer/
38 lines
ScopInfo/
29 lines
NonAffine/
26 lines
60 lines
152 lines
170 lines
15 lines
17 lines
41 lines
58 lines
58 lines
56 lines
54 lines
137 lines
21 lines
8 lines
342 lines
61 lines
39 lines
9 lines
5 lines
19 lines
30 lines
57 lines
38 lines
32 lines
32 lines
28 lines
47 lines
25 lines
29 lines
30 lines
66 lines
34 lines
36 lines
32 lines
41 lines
249 lines
36 lines
33 lines
43 lines
124 lines
33 lines
43 lines
46 lines
41 lines
34 lines
40 lines
65 lines
40 lines
52 lines
29 lines
21 lines
65 lines
63 lines
65 lines
88 lines
64 lines
44 lines
122 lines
160 lines
98 lines
46 lines
22 lines
12 lines
57 lines
30 lines
84 lines
59 lines
96 lines
109 lines
30 lines
89 lines
63 lines
48 lines
38 lines
27 lines
12 lines
17 lines
6 lines
10 lines
12 lines
10 lines

Diff 44949

polly/trunk/test/DependenceInfo/computeout.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 LinesS3:
%indvar.next.3 = add i64 %indvar.3, 1 %indvar.next.3 = add i64 %indvar.3, 1
%exitcond.3 = icmp ne i64 %indvar.next.3, 200 %exitcond.3 = icmp ne i64 %indvar.next.3, 200
br i1 %exitcond.3, label %S3 , label %exit.3 br i1 %exitcond.3, label %S3 , label %exit.3
exit.3: exit.3:
ret void ret void
} }
; VALUE: region: 'S1 => exit.3' in function 'sequential_writes':
; VALUE: RAW dependences: ; VALUE: RAW dependences:
; VALUE: { } ; VALUE-NEXT: { }
; VALUE: WAR dependences: ; VALUE-NEXT: WAR dependences:
; VALUE: { } ; VALUE-NEXT: { }
; VALUE: WAW dependences: ; VALUE-NEXT: WAW dependences:
; VALUE: { ; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0; Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10 }
; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10
; VALUE: }
; TIMEOUT: region: 'S1 => exit.3' in function 'sequential_writes':
; TIMEOUT: RAW dependences: ; TIMEOUT: RAW dependences:
; TIMEOUT: n/a ; TIMEOUT-NEXT: n/a
; TIMEOUT: WAR dependences: ; TIMEOUT-NEXT: WAR dependences:
; TIMEOUT: n/a ; TIMEOUT-NEXT: n/a
; TIMEOUT: WAW dependences: ; TIMEOUT-NEXT: WAW dependences:
; TIMEOUT: n/a ; TIMEOUT-NEXT: n/a

polly/trunk/test/DependenceInfo/do_pluto_matmult.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linesdo.cond42: ; preds = %do.end39
%exitcond6 = icmp ne i64 %indvar.next4, 36 ; <i1> [#uses=1] %exitcond6 = icmp ne i64 %indvar.next4, 36 ; <i1> [#uses=1]
br i1 %exitcond6, label %do.body, label %do.end45 br i1 %exitcond6, label %do.body, label %do.end45
do.end45: ; preds = %do.cond42 do.end45: ; preds = %do.cond42
fence seq_cst fence seq_cst
ret void ret void
} }
; VALUE: RAW dependences: ; VALUE: RAW dependences:
; VALUE: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 <= 34 and i2 >= 0 } ; VALUE-NEXT: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 <= 34 and i2 >= 0 }
; VALUE: WAR dependences: ; VALUE-NEXT: WAR dependences:
; VALUE: { } ; VALUE-NEXT: { }
; VALUE: WAW dependences: ; VALUE-NEXT: WAW dependences:
; VALUE: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 <= 34 and i2 >= 0 } ; VALUE-NEXT: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, 1 + i2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 <= 34 and i2 >= 0 }
; MEMORY: RAW dependences: ; MEMORY: RAW dependences:
; MEMORY: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 } ; MEMORY-NEXT: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 }
; MEMORY: WAR dependences: ; MEMORY-NEXT: WAR dependences:
; MEMORY: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 } ; MEMORY-NEXT: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 }
; MEMORY: WAW dependences: ; MEMORY-NEXT: WAW dependences:
; MEMORY: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 } ; MEMORY-NEXT: { Stmt_do_body2[i0, i1, i2] -> Stmt_do_body2[i0, i1, o2] : i0 <= 35 and i0 >= 0 and i1 <= 35 and i1 >= 0 and i2 >= 0 and o2 >= 1 + i2 and o2 <= 35 and o2 >= 0 }

polly/trunk/test/DependenceInfo/reduction_complex_location.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[2 + i0, -1 + i1] : i0 <= 97 and i0 >= 0 and i1 <= 99 and i1 >= 1 } ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[2 + i0, -1 + i1] : i0 <= 97 and i0 >= 0 and i1 <= 99 and i1 >= 1 }
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; for (int j = 0; j < 100; j++) ; for (int j = 0; j < 100; j++)
; sum[i+j*2] += j * i; ; sum[i+j*2] += j * i;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_dependences_equal_non_reduction_dependences.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; This loopnest contains a reduction which imposes the same dependences as the ; This loopnest contains a reduction which imposes the same dependences as the
; accesses to the array A. We need to ensure we keep the dependences of A. ; accesses to the array A. We need to ensure we keep the dependences of A.
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 >= 0 and i0 <= 1022 } ; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 >= 0 and i0 <= 1022 }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 <= 1022 and i0 >= 0 } ; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 <= 1022 and i0 >= 0 }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 <= 1022 and i0 >= 0 } ; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : i0 <= 1022 and i0 >= 0 }
; ;
; ;
; void AandSum(int *restrict sum, int *restrict A) { ; void AandSum(int *restrict sum, int *restrict A) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; A[i] = A[i] + A[i - 1]; ; A[i] = A[i] + A[i - 1];
; A[i - 1] = A[i] + A[i - 2]; ; A[i - 1] = A[i] + A[i - 2];
; *sum += i; ; *sum += i;
; } ; }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_mixed_reduction_and_non_reduction_dependences.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0 + i1, o1] : i1 <= 1023 - i0 and i1 >= 0 and i1 <= 1 and i0 >= 0 and o1 <= 511 and o1 >= 1 ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0 + i1, o1] : i1 <= 1023 - i0 and i1 >= 0 and i1 <= 1 and i0 >= 0 and o1 <= 511 and o1 >= 1 }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 511 and i1 >= 2 ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 511 and i1 >= 2; Stmt_for_body3[i0, 2] -> Stmt_for_body3[2 + i0, 0] : i0 <= 1021 and i0 >= 0 }
; CHECK-DAG: Stmt_for_body3[i0, 2] -> Stmt_for_body3[2 + i0, 0] : i0 <= 1021 and i0 >= 0 ; CHECK-NEXT: Reduction dependences:
; CHECK: Reduction dependences: ; CHECK-NEXT: { Stmt_for_body3[i0, 1] -> Stmt_for_body3[1 + i0, 0] : i0 <= 1022 and i0 >= 0 }
; CHECK: { Stmt_for_body3[i0, 1] -> Stmt_for_body3[1 + i0, 0] : i0 <= 1022 and i0 >= 0 }
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = 0; j < 512; j++) ; for (int j = 0; j < 512; j++)
; sum[i + j] = sum[i] + 3; ; sum[i + j] = sum[i] + 3;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
Show All 40 Lines

polly/trunk/test/DependenceInfo/reduction_multiple_loops_array_sum.ll

; RUN: opt -basicaa %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; Verify that only the inner reduction like accesses cause reduction dependences ; Verify that only the inner reduction like accesses cause reduction dependences
; ;
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
; CHECK: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 } ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 }
; ;
; void f(int * restrict A, int * restrict sum) { ; void f(int * restrict A, int * restrict sum) {
; int i, j, k; ; int i, j, k;
; for (i = 0; i < 100; i++) { ; for (i = 0; i < 100; i++) {
; *sum *= 7; ; *sum *= 7;
; for (j = 0; j < 100; j++) { ; for (j = 0; j < 100; j++) {
; *sum += A[i+j]; ; *sum += A[i+j];
; for (k = 0; k< 100; k++) {} ; for (k = 0; k< 100; k++) {}
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_multiple_loops_array_sum_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0; Stmt_for_body3[i0, 99] -> Stmt_for_body3[1 + i0, 0] : i0 <= 98 and i0 >= 0 }
; CHECK-DAG: Stmt_for_body3[i0, 99] -> Stmt_for_body3[1 + i0, 0] : i0 <= 98 and i0 >= 0
; ;
; int f(int * restrict A, int * restrict sum) { ; int f(int * restrict A, int * restrict sum) {
; int i, j, k; ; int i, j, k;
; for (i = 0; i < 100; i++) { ; for (i = 0; i < 100; i++) {
; for (j = 0; j < 100; j++) { ; for (j = 0; j < 100; j++) {
; sum += A[i+j]; ; sum += A[i+j];
; for (k = 0; k< 100; k++) {} ; for (k = 0; k< 100; k++) {}
; } ; }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_multiple_loops_array_sum_3.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s
; ;
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
; CHECK: { Stmt_for_inc[i0, i1] -> Stmt_for_inc[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 } ; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> Stmt_for_inc[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 }
; ;
; int f(int * __restrict__ A) { ; int f(int * __restrict__ A) {
; int i, j, sum = 0; ; int i, j, sum = 0;
; for (k = 0; k < 37; k = g(k)) { ; for (k = 0; k < 37; k = g(k)) {
; for (i = 0; i < 100; i++) { ; for (i = 0; i < 100; i++) {
; sum *= 2; ; sum *= 2;
; for (j = 0; j < 100; j++) { ; for (j = 0; j < 100; j++) {
; sum += A[i+j]; ; sum += A[i+j];
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_multiple_reductions.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; Verify we do not have dependences between the if and the else clause ; Verify we do not have dependences between the if and the else clause
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_if_then[i0] -> Stmt_if_then[1 + i0] : i0 <= 510 and i0 >= 0 ; CHECK-NEXT: { Stmt_if_else[i0] -> Stmt_if_else[1 + i0] : i0 <= 1022 and i0 >= 512; Stmt_if_then[i0] -> Stmt_if_then[1 + i0] : i0 <= 510 and i0 >= 0 }
; CHECK-DAG: Stmt_if_else[i0] -> Stmt_if_else[1 + i0] : i0 <= 1022 and i0 >= 512
; ;
; void f(int *restrict sum, int *restrict prod) { ; void f(int *restrict sum, int *restrict prod) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (i < 512) ; if (i < 512)
; *sum += i; ; *sum += i;
; else ; else
; *prod *= i; ; *prod *= i;
; } ; }
Show All 38 Lines

polly/trunk/test/DependenceInfo/reduction_multiple_reductions_2.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ;
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 <= 1022 and i0 >= 0
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0
; These are the important RAW dependences, as they need to originate/end in only one iteration: ; These are the important RAW dependences, as they need to originate/end in only one iteration:
; CHECK-DAG: Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0 ; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1]
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 ; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0]
; CHECK: WAR dependences: ;
; CHECK: { }
; CHECK: WAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 <= 1022 and i0 >= 0
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0
; These are the important WAW dependences, as they need to originate/end in only one iteration: ; These are the important WAW dependences, as they need to originate/end in only one iteration:
; CHECK-DAG: Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0 ; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1]
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 ; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0]
; CHECK: Reduction dependences: ;
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S1[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S2[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 ; CHECK-NEXT: { Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0; Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0; Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 <= 1022 and i0 >= 0; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 }
; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0; Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0; Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 <= 1022 and i0 >= 0; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 }
; CHECK-NEXT: Reduction dependences:
; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S1[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0; Stmt_S2[i0, i1] -> Stmt_S2[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 }
; ;
; void f(int *restrict red) { ; void f(int *restrict red) {
; for (int j = 0; j < 1024; j++) { ; for (int j = 0; j < 1024; j++) {
; S0: *red = 42 + *red * 5; ; S0: *red = 42 + *red * 5;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S1: *red *= i; ; S1: *red *= i;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S2: *red += i; ; S2: *red += i;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_partially_escaping_intermediate_in_other_stmt.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s
; ;
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
; CHECK: [N] -> { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 and i1 >= 1024 - N + i0 } ; CHECK-NEXT: [N] -> { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 and i1 >= 1024 - N + i0 }
; ;
; void f(int N, int * restrict sums, int * restrict escape) { ; void f(int N, int * restrict sums, int * restrict escape) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; for (int j = 0; j < 1024; j++) { ; for (int j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; if (N - i + j < 1024) ; if (N - i + j < 1024)
; escape[N - i + j] = sums[i]; ; escape[N - i + j] = sums[i];
; } ; }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_privatization_deps.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0 ; CHECK-NEXT: { Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0; Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : i1 <= 1023 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 and i0 <= 1023 and i1 <= 1024 - i0 }
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : i1 <= 1023 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 and i0 <= 1023 and i1 <= 1024 - i0 ; CHECK-NEXT: WAR dependences:
; CHECK: WAR dependences: ; CHECK-NEXT: { Stmt_S2[i0] -> Stmt_S2[1 + i0] : i0 <= 1022 and i0 >= 0; Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i1 <= 1023 - i0 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 }
; CHECK-DAG: Stmt_S2[i0] -> Stmt_S2[1 + i0] : i0 <= 1022 and i0 >= 0 ; CHECK-NEXT: WAW dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i1 <= 1023 - i0 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 } ; CHECK-NEXT: { Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0; Stmt_S1[0, 0] -> Stmt_S2[0] }
; CHECK: WAW dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0 ; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S1[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 1023 and i1 >= 1 }
; CHECK-DAG: Stmt_S1[0, 0] -> Stmt_S2[0]
; CHECK: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S1[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 1023 and i1 >= 1
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S0: sum[i] = 0; ; S0: sum[i] = 0;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = 0; j < 1024; j++) ; for (int j = 0; j < 1024; j++)
; S1: sum[i + j] += i; ; S1: sum[i + j] += i;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_privatization_deps_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; We have privatization dependences from a textually later statement to a ; We have privatization dependences from a textually later statement to a
; textually earlier one, but the dependences still go forward in time. ; textually earlier one, but the dependences still go forward in time.
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0 ; CHECK-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0 }
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: WAR dependences:
; CHECK: WAR dependences: ; CHECK-NEXT: { }
; CHECK: { } ; CHECK-NEXT: WAW dependences:
; CHECK: WAW dependences: ; CHECK-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0 }
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0 ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S2[i0, 1 + i1] : i0 <= 98 and i0 >= 0 and i1 <= 98 and i1 >= 0 }
; CHECK: Reduction dependences:
; CHECK: { Stmt_S2[i0, i1] -> Stmt_S2[i0, 1 + i1] : i0 <= 98 and i0 >= 0 and i1 <= 98 and i1 >= 0 }
; ;
; void f(int *sum) { ; void f(int *sum) {
; int i, j; ; int i, j;
; for (i = 0; i < 99; i++) { ; for (i = 0; i < 99; i++) {
; S1: sum[i + 1] += 42; ; S1: sum[i + 1] += 42;
; for (j = 0; j < 100; j++) ; for (j = 0; j < 100; j++)
; S2: sum[i] += i * j; ; S2: sum[i] += i * j;
; S3: sum[i + 1] += 7; ; S3: sum[i + 1] += 7;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_privatization_deps_3.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1 ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1; Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98; Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 <= 96 and i0 >= 0 }
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 ; CHECK-NEXT: WAR dependences:
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 <= 96 and i0 >= 0 ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1; Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98; Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 <= 96 and i0 >= 0 }
; CHECK: WAW dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1 ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : i0 <= 97 and i0 >= 0 and i1 <= 98 - i0 and i1 >= 0 and i1 >= 2 - i0; Stmt_S2[0, 0] -> Stmt_S2[1, 0] }
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 <= 96 and i0 >= 0
; CHECK: Reduction dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : i0 <= 97 and i0 >= 0 and i1 <= 98 - i0 and i1 >= 0 and i1 >= 2 - i0
; CHECK-DAG: Stmt_S2[0, 0] -> Stmt_S2[1, 0]
; ;
; void f(int *sum) { ; void f(int *sum) {
; int i, j; ; int i, j;
; for (i = 0; i < 99; i++) { ; for (i = 0; i < 99; i++) {
; S1: sum[i + 1] += 42; ; S1: sum[i + 1] += 42;
; for (j = i; j < 100; j++) ; for (j = i; j < 100; j++)
; S2: sum[i - j] += i * j; ; S2: sum[i - j] += i * j;
; S3: sum[i - 1] += 7; ; S3: sum[i - 1] += 7;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_privatization_deps_4.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98 ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98; Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 <= 98 and i0 >= 0; Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 }
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: WAR dependences:
; CHECK-DAG: Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: { }
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 ; CHECK-NEXT: WAW dependences:
; CHECK: WAR dependences: ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98; Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 <= 98 and i0 >= 0; Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 }
; CHECK-DAG: { } ; CHECK-NEXT: Reduction dependences:
; CHECK: WAW dependences: ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : (i0 >= 0 and i1 >= 2 + i0 and i1 <= 99) or (i0 <= 97 and i1 >= 0 and i1 <= -1 + i0) }
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 <= 98 and i0 >= 0
; CHECK-DAG: Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 <= 98 and i0 >= 0
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98
; CHECK: Reduction dependences:
; CHECK-DAG: { Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : (i0 >= 0 and i1 >= 2 + i0 and i1 <= 99) or (i0 <= 97 and i1 >= 0 and i1 <= -1 + i0) }
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 99; i++) { ; for (int i = 0; i < 99; i++) {
; S1: sum[i] += 42; ; S1: sum[i] += 42;
; for (int j = 0; j < 100; j++) ; for (int j = 0; j < 100; j++)
; S2: sum[j] += i * j; ; S2: sum[j] += i * j;
; S3: sum[i] += 7; ; S3: sum[i] += 7;
; } ; }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_privatization_deps_5.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 <= 97 and i0 >= 0 ; CHECK-NEXT: { Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 <= 97 and i0 >= 0; Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 <= 98 and i0 >= 0 }
; CHECK-DAG: Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: WAR dependences:
; CHECK: WAR dependences: ; CHECK-NEXT: { }
; CHECK-DAG: { } ; CHECK-NEXT: WAW dependences:
; CHECK: WAW dependences: ; CHECK-NEXT: { Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 <= 97 and i0 >= 0; Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 <= 98 and i0 >= 0 }
; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 <= 97 and i0 >= 0 ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: { Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : i0 <= 97 and i0 >= 0 and i1 <= 99 and i1 >= 1 }
; CHECK: Reduction dependences:
; CHECK-DAG: { Stmt_S2[i0, i1] -> Stmt_S2[1 + i0, i1] : i0 <= 97 and i0 >= 0 and i1 <= 99 and i1 >= 1 }
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 99; i++) { ; for (int i = 0; i < 99; i++) {
; for (int j = 0; j < 1; j++) ; for (int j = 0; j < 1; j++)
; S1: sum[j] += 42; ; S1: sum[j] += 42;
; for (int j = 0; j < 100; j++) ; for (int j = 0; j < 100; j++)
; S2: sum[j] += i * j; ; S2: sum[j] += i * j;
; } ; }
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_simple_iv.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 }
; ;
; void f(int* sum) { ; void f(int* sum) {
; for (int i = 0; i <= 100; i++) ; for (int i = 0; i <= 100; i++)
; sum += i * 3; ; sum += i * 3;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
define void @f(i32* %sum) { define void @f(i32* %sum) {
Show All 22 Lines

polly/trunk/test/DependenceInfo/reduction_simple_iv_debug_wrapped_dependences.ll

; RUN: opt %loadPolly -polly-dependences -analyze -debug-only=polly-dependence 2>&1 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze -debug-only=polly-dependence 2>&1 < %s | FileCheck %s
; ;
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : ; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : i0 <= 100 and i0 >= 0 }
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : i0 <= 100 and i0 >= 0 }
; CHECK-DAG: and ; CHECK-NEXT: MayWrite: { }
; CHECK-DAG: i0 <= 100 ;
; CHECK: }
; CHECK: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] :
; CHECK-DAG: i0 >= 0
; CHECK-DAG: and
; CHECK-DAG: i0 <= 100
; CHECK: }
; CHECK: Wrapped Dependences: ; CHECK: Wrapped Dependences:
; CHECK: RAW dependences: ; CHECK-NEXT: RAW dependences:
; CHECK: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0]] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0{{\]\]}} : i0 <= 99 and i0 >= 0 }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0]] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0{{\]\]}} : i0 <= 99 and i0 >= 0 }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: n/a ; CHECK-NEXT: n/a
;
; CHECK: Final Wrapped Dependences: ; CHECK: Final Wrapped Dependences:
; CHECK: RAW dependences: ; CHECK-NEXT: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0]] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> [Stmt_for_cond[1 + i0] -> MemRef_sum[0{{\]\]}} : i0 <= 99 and i0 >= 0 }
;
; CHECK: Zipped Dependences: ; CHECK: Zipped Dependences:
; CHECK: RAW dependences: ; CHECK-NEXT: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { [Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0]] -> [MemRef_sum[0] -> MemRef_sum[0]] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { [Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0{{\]\]}} -> [MemRef_sum[0] -> MemRef_sum[0{{\]\]}} : i0 <= 99 and i0 >= 0 }
;
; CHECK: Unwrapped Dependences: ; CHECK: Unwrapped Dependences:
; CHECK-NEXT: RAW dependences:
; CHECK-NEXT: { }
; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { }
; CHECK-NEXT: Reduction dependences:
; CHECK-NEXT: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 }
;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 }
;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 } ; CHECK-NEXT: { Stmt_for_cond[i0] -> Stmt_for_cond[1 + i0] : i0 <= 99 and i0 >= 0 }
; ;
; void f(int* sum) { ; void f(int* sum) {
; for (int i = 0; i <= 100; i++) ; for (int i = 0; i <= 100; i++)
; sum += i * 3; ; sum += i * 3;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
define void @f(i32* %sum) { define void @f(i32* %sum) {
Show All 22 Lines

polly/trunk/test/DependenceInfo/reduction_simple_privatization_deps_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 ; CHECK-NEXT: { Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 <= 98 and i0 >= 0; Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0; Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 }
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0 ; CHECK-NEXT: WAR dependences:
; CHECK-DAG: Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 <= 98 and i0 >= 0 ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-DAG: { } ; CHECK-NEXT: { Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 <= 98 and i0 >= 0; Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0; Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 }
; CHECK: WAW dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 ; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S1[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0 }
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0
; CHECK-DAG: Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 <= 98 and i0 >= 0
; CHECK: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S1[i0, 1 + i1] : i0 <= 99 and i0 >= 0 and i1 <= 98 and i1 >= 0
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 100; i++) { ; for (int i = 0; i < 100; i++) {
; S0: *sum *= 42; ; S0: *sum *= 42;
; for (int j = 0; j < 100; j++) ; for (int j = 0; j < 100; j++)
; S1: *sum += i * j; ; S1: *sum += i * j;
; S2: *sum *= 7; ; S2: *sum *= 7;
; } ; }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_simple_privatization_deps_w_parameter.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0 ; CHECK-NEXT: [N] -> { Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0; Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0 }
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0 ; CHECK-NEXT: WAR dependences:
; CHECK: WAR dependences: ; CHECK-NEXT: [N] -> { }
; CHECK: [N] -> { } ; CHECK-NEXT: WAW dependences:
; CHECK: WAW dependences: ; CHECK-NEXT: [N] -> { Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0; Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0 }
; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0 ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0 ; CHECK-NEXT: [N] -> { Stmt_S1[i0] -> Stmt_S1[1 + i0] : N >= 11 and i0 <= 1022 and i0 >= 0 }
; CHECK: Reduction dependences:
; CHECK: Stmt_S1[i0] -> Stmt_S1[1 + i0] : N >= 11 and i0 <= 1022 and i0 >= 0
; ;
; void f(int *sum, int N) { ; void f(int *sum, int N) {
; if (N >= 10) { ; if (N >= 10) {
; S0: *sum = 0; ; S0: *sum = 0;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S1: *sum += i; ; S1: *sum += i;
; S2: *sum = *sum * 3; ; S2: *sum = *sum * 3;
; } ; }
Show All 39 Lines

polly/trunk/test/DependenceInfo/reduction_two_reductions_different_rloops.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK: { } ; CHECK-NEXT: { }
; CHECK: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[o0, 1 + i0 + i1 - o0] : o0 <= 1 + i0 and o0 >= i0 and o0 <= 1023 and i0 >= 0 and i1 >= 0 and o0 >= -1022 + i0 + i1 ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[o0, 1 + i0 + i1 - o0] : o0 <= 1 + i0 and o0 >= i0 and o0 <= 1023 and i0 >= 0 and i1 >= 0 and o0 >= -1022 + i0 + i1 }
; ;
; void f(int *restrict A, int *restrict B, int *restrict Values) { ; void f(int *restrict A, int *restrict B, int *restrict Values) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; for (int j = 0; j < 1024; j++) { ; for (int j = 0; j < 1024; j++) {
; A[i] += Values[i + j - 1]; ; A[i] += Values[i + j - 1];
; B[j] += Values[i + j + 42]; ; B[j] += Values[i + j + 42];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/sequential_loops.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY ; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY
; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'sequential_writes':
; VALUE-NEXT: RAW dependences:
; VALUE-NEXT: { }
; VALUE-NEXT: WAR dependences:
; VALUE-NEXT: { }
; VALUE-NEXT: WAW dependences:
; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0; Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10 }
;
; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'read_after_writes':
; VALUE-NEXT: RAW dependences:
; VALUE-NEXT: { Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10 }
; VALUE-NEXT: WAR dependences:
; VALUE-NEXT: { }
; VALUE-NEXT: WAW dependences:
; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0 }
;
; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'write_after_read':
; VALUE-NEXT: RAW dependences:
; VALUE-NEXT: { }
; VALUE-NEXT: WAR dependences:
; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10 }
; VALUE-NEXT: WAW dependences:
; VALUE-NEXT: { Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0 }
;
; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.2' in function 'parametric_offset':
; VALUE-NEXT: RAW dependences:
; VALUE-NEXT: [p] -> { Stmt_S1[i0] -> Stmt_S2[-p + i0] : i0 <= 9 + p and i0 >= p and i0 <= 99 and i0 >= 0 }
; VALUE-NEXT: WAR dependences:
; VALUE-NEXT: [p] -> { }
; VALUE-NEXT: WAW dependences:
; VALUE-NEXT: [p] -> { }
; MEMORY-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'sequential_writes':
; MEMORY-NEXT: RAW dependences:
; MEMORY-NEXT: { }
; MEMORY-NEXT: WAR dependences:
; MEMORY-NEXT: { }
; MEMORY-NEXT: WAW dependences:
; MEMORY-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0; Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0 }
;
; MEMORY-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'read_after_writes':
; MEMORY-NEXT: RAW dependences:
; MEMORY-NEXT: { Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0 }
; MEMORY-NEXT: WAR dependences:
; MEMORY-NEXT: { }
; MEMORY-NEXT: WAW dependences:
; MEMORY-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0 }
;
; MEMORY-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'write_after_read':
; MEMORY-NEXT: RAW dependences:
; MEMORY-NEXT: { }
; MEMORY-NEXT: WAR dependences:
; MEMORY-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0; Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0 }
; MEMORY-NEXT: WAW dependences:
; MEMORY-NEXT: { Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0 }
;
; MEMORY-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.2' in function 'parametric_offset':
; MEMORY-NEXT: RAW dependences:
; MEMORY-NEXT: [p] -> { Stmt_S1[i0] -> Stmt_S2[-p + i0] : i0 >= p and i0 <= 99 and i0 >= 0 and i0 <= 9 + p }
; MEMORY-NEXT: WAR dependences:
; MEMORY-NEXT: [p] -> { }
; MEMORY-NEXT: WAW dependences:
; MEMORY-NEXT: [p] -> { }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
; ;
Show All 34 LinesS3:
%indvar.next.3 = add i64 %indvar.3, 1 %indvar.next.3 = add i64 %indvar.3, 1
%exitcond.3 = icmp ne i64 %indvar.next.3, 200 %exitcond.3 = icmp ne i64 %indvar.next.3, 200
br i1 %exitcond.3, label %S3 , label %exit.3 br i1 %exitcond.3, label %S3 , label %exit.3
exit.3: exit.3:
ret void ret void
} }
; VALUE-LABEL: region: 'S1 => exit.3' in function 'sequential_writes':
; VALUE: RAW dependences:
; VALUE: { }
; VALUE: WAR dependences:
; VALUE: { }
; VALUE: WAW dependences:
; VALUE: {
; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10
; VALUE: }
; MEMORY-LABEL: region: 'S1 => exit.3' in function 'sequential_writes':
; MEMORY: RAW dependences:
; MEMORY: { }
; MEMORY: WAR dependences:
; MEMORY: { }
; MEMORY: WAW dependences:
; MEMORY: {
; MEMORY: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0;
; MEMORY: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
; MEMORY: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0
; MEMORY: }
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
; ;
; for (i = 0; i < 200; i++ ) ; for (i = 0; i < 200; i++ )
Show All 36 LinesS3:
%indvar.next.3 = add i64 %indvar.3, 1 %indvar.next.3 = add i64 %indvar.3, 1
%exitcond.3 = icmp ne i64 %indvar.next.3, 200 %exitcond.3 = icmp ne i64 %indvar.next.3, 200
br i1 %exitcond.3, label %S3 , label %exit.3 br i1 %exitcond.3, label %S3 , label %exit.3
exit.3: exit.3:
ret void ret void
} }
; VALUE-LABEL: region: 'S1 => exit.3' in function 'read_after_writes':
; VALUE: RAW dependences:
; VALUE: {
; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10
; VALUE: }
; VALUE: WAR dependences:
; VALUE: { }
; VALUE: WAW dependences:
; VALUE: {
; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0
; VALUE: }
; MEMORY-LABEL: region: 'S1 => exit.3' in function 'read_after_writes':
; MEMORY: RAW dependences:
; MEMORY: {
; MEMORY: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0;
; MEMORY: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0
; MEMORY: }
; MEMORY: WAR dependences:
; MEMORY: { }
; MEMORY: WAW dependences:
; MEMORY: {
; MEMORY: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0
; MEMORY: }
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: B[i] = A[i]; ; S1: B[i] = A[i];
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
; ;
; for (i = 0; i < 200; i++ ) ; for (i = 0; i < 200; i++ )
Show All 36 LinesS3:
%indvar.next.3 = add i64 %indvar.3, 1 %indvar.next.3 = add i64 %indvar.3, 1
%exitcond.3 = icmp ne i64 %indvar.next.3, 200 %exitcond.3 = icmp ne i64 %indvar.next.3, 200
br i1 %exitcond.3, label %S3 , label %exit.3 br i1 %exitcond.3, label %S3 , label %exit.3
exit.3: exit.3:
ret void ret void
} }
; VALUE-LABEL: region: 'S1 => exit.3' in function 'write_after_read':
; VALUE: RAW dependences:
; VALUE: {
; VALUE: }
; VALUE: WAR dependences:
; VALUE: {
; VALUE: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0;
; VALUE: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 10
; VALUE: }
; VALUE: WAW dependences:
; VALUE: {
; VALUE: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0
; VALUE: }
; MEMORY-LABEL: region: 'S1 => exit.3' in function 'write_after_read':
; MEMORY: RAW dependences:
; MEMORY: {
; MEMORY: }
; MEMORY: WAR dependences:
; MEMORY: {
; MEMORY: Stmt_S1[i0] -> Stmt_S2[i0] : i0 <= 9 and i0 >= 0;
; MEMORY: Stmt_S1[i0] -> Stmt_S3[i0] : i0 <= 99 and i0 >= 0
; MEMORY: }
; MEMORY: WAW dependences:
; MEMORY: {
; MEMORY: Stmt_S2[i0] -> Stmt_S3[i0] : i0 <= 9 and i0 >= 0
; MEMORY: }
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 10 ; S1: A[i] = 10
; ;
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S2: B[i] = A[i + p]; ; S2: B[i] = A[i + p];
define void @parametric_offset(i64 %p) { define void @parametric_offset(i64 %p) {
Show All 23 LinesS2:
%indvar.next.2 = add i64 %indvar.2, 1 %indvar.next.2 = add i64 %indvar.2, 1
%exitcond.2 = icmp ne i64 %indvar.next.2, 10 %exitcond.2 = icmp ne i64 %indvar.next.2, 10
br i1 %exitcond.2, label %S2, label %exit.2 br i1 %exitcond.2, label %S2, label %exit.2
exit.2: exit.2:
ret void ret void
} }
; VALUE: region: 'S1 => exit.2' in function 'parametric_offset':
; VALUE: RAW dependences:
; VALUE: [p] -> {
; VALUE: Stmt_S1[i0] -> Stmt_S2[-p + i0] :
; VALUE-DAG: i0 >= p
; VALUE-DAG: i0 <= 9 + p
; VALUE-DAG: i0 <= 99
; VALUE-DAG: i0 >= 0
; VALUE: }
; VALUE: WAR dependences:
; VALUE: [p] -> {
; VALUE: }
; VALUE: WAW dependences:
; VALUE: [p] -> {
; VALUE: }
; MEMORY: region: 'S1 => exit.2' in function 'parametric_offset':
; MEMORY: RAW dependences:
; MEMORY: [p] -> {
; MEMORY: Stmt_S1[i0] -> Stmt_S2[-p + i0] :
; MEMORY: i0 >= p and i0 <= 99 and i0 >= 0 and i0 <= 9 + p
; MEMORY: }
; MEMORY: WAR dependences:
; MEMORY: [p] -> {
; MEMORY: }
; MEMORY: WAW dependences:
; MEMORY: [p] -> {
; MEMORY: }

polly/trunk/test/ScheduleOptimizer/full_partial_tile_separation.ll

; RUN: opt -S %loadPolly -polly-vectorizer=stripmine -polly-opt-isl -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-vectorizer=stripmine -polly-opt-isl -polly-ast -analyze < %s | FileCheck %s
; CHECK: // 1st level tiling - Tiles ; CHECK: // 1st level tiling - Tiles
; CHECK: #pragma known-parallel ; CHECK-NEXT: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= floord(ni - 1, 32); c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 <= floord(ni - 1, 32); c0 += 1)
; CHECK: for (int c1 = 0; c1 <= floord(nj - 1, 32); c1 += 1) ; CHECK-NEXT: for (int c1 = 0; c1 <= floord(nj - 1, 32); c1 += 1)
; CHECK: for (int c2 = 0; c2 <= floord(nk - 1, 32); c2 += 1) { ; CHECK-NEXT: for (int c2 = 0; c2 <= floord(nk - 1, 32); c2 += 1) {
; CHECK: // 1st level tiling - Points ; CHECK-NEXT: // 1st level tiling - Points
; CHECK: for (int c3 = 0; c3 <= min(31, ni - 32 * c0 - 1); c3 += 1) { ; CHECK-NEXT: for (int c3 = 0; c3 <= min(31, ni - 32 * c0 - 1); c3 += 1) {
; CHECK: for (int c4 = 0; c4 <= min(7, -8 * c1 + nj / 4 - 1); c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= min(7, -8 * c1 + nj / 4 - 1); c4 += 1)
; CHECK: for (int c5 = 0; c5 <= min(31, nk - 32 * c2 - 1); c5 += 1) ; CHECK-NEXT: for (int c5 = 0; c5 <= min(31, nk - 32 * c2 - 1); c5 += 1)
; CHECK: #pragma simd ; CHECK-NEXT: #pragma simd
; CHECK: for (int c6 = 0; c6 <= 3; c6 += 1) ; CHECK-NEXT: for (int c6 = 0; c6 <= 3; c6 += 1)
; CHECK: Stmt_for_body_6(32 * c0 + c3, 32 * c1 + 4 * c4 + c6, 32 * c2 + c5); ; CHECK-NEXT: Stmt_for_body_6(32 * c0 + c3, 32 * c1 + 4 * c4 + c6, 32 * c2 + c5);
; CHECK: if (32 * c1 + 31 >= nj) ; CHECK-NEXT: if (32 * c1 + 31 >= nj)
; CHECK: for (int c5 = 0; c5 <= min(31, nk - 32 * c2 - 1); c5 += 1) ; CHECK-NEXT: for (int c5 = 0; c5 <= min(31, nk - 32 * c2 - 1); c5 += 1)
; CHECK: #pragma simd ; CHECK-NEXT: #pragma simd
; CHECK: for (int c6 = 0; c6 < nj % 4; c6 += 1) ; CHECK-NEXT: for (int c6 = 0; c6 < nj % 4; c6 += 1)
; CHECK: Stmt_for_body_6(32 * c0 + c3, -((nj - 1) % 4) + nj + c6 - 1, 32 * c2 + c5); ; CHECK-NEXT: Stmt_for_body_6(32 * c0 + c3, -((nj - 1) % 4) + nj + c6 - 1, 32 * c2 + c5);
; CHECK: } ; CHECK-NEXT: }
; CHECK: } ; CHECK-NEXT: }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, [1024 x double]* %C, [1024 x double]* %A, [1024 x double]* %B) #0 { define void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, [1024 x double]* %C, [1024 x double]* %A, [1024 x double]* %B) #0 {
entry: entry:
%cmp.27 = icmp sgt i32 %ni, 0 %cmp.27 = icmp sgt i32 %ni, 0
br i1 %cmp.27, label %for.cond.1.preheader.lr.ph, label %for.end.22 br i1 %cmp.27, label %for.cond.1.preheader.lr.ph, label %for.end.22
for.cond.1.preheader.lr.ph: ; preds = %entry for.cond.1.preheader.lr.ph: ; preds = %entry
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/20111108-Parameter-not-detected.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
for.inc5: ; preds = %for.end for.inc5: ; preds = %for.end
%indvar_out.next = add i64 %indvar_out, 1 %indvar_out.next = add i64 %indvar_out, 1
br label %for.cond br label %for.cond
for.end7: ; preds = %for.cond for.end7: ; preds = %for.cond
ret i32 0 ret i32 0
} }
; CHECK: Context:
; CHECK: p0: {0,+,1}<%for.cond> ; CHECK: p0: {0,+,1}<%for.cond>
;
; CHECK: Domain := ; CHECK: Statements {
; CHECK: [p_0] -> { Stmt_if_then[i0] : ; CHECK-NEXT: Stmt_if_then
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [p_0] -> { Stmt_if_then[i0] : i0 <= 1022 and i0 >= 0 and i0 >= 999 - p_0 };
; CHECK-DAG: i0 <= 1022 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [p_0] -> { Stmt_if_then[i0] -> [0, i0] };
; CHECK-DAG: i0 >= 999 - p_0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: [p_0] -> { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_for_inc5
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p_0] -> { Stmt_for_inc5[] };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [p_0] -> { Stmt_for_inc5[] -> [1, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0] -> { Stmt_for_inc5[] -> MemRef_indvar_out_next[] };
; CHECK-NEXT: }

polly/trunk/test/ScopInfo/NonAffine/div_domain.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 0; i < 16; i++) { ; for (long i = 0; i < 16; i++) {
; A[i] += 1; ; A[i] += 1;
; if (i / 2 == 3) ; if (i / 2 == 3)
; A[i] += 2; ; A[i] += 2;
; } ; }
; } ; }
; ;
; CHECK: Stmt_for_body ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_for_body
; CHECK: { Stmt_for_body[i0] : i0 <= 15 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Stmt_if_then ; CHECK-NEXT: { Stmt_for_body[i0] : i0 <= 15 and i0 >= 0 };
; CHECK: Domain := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_if_then[i0] : i0 <= 7 and i0 >= 6 }; ; CHECK-NEXT: { Stmt_for_body[i0] -> [i0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_if_then
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_if_then[i0] : i0 <= 7 and i0 >= 6 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_if_then[i0] -> [i0, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(float* %A) { define void @foo(float* %A) {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
Show All 30 Lines

polly/trunk/test/ScopInfo/NonAffine/non-affine-loop-condition-dependent-access_1.ll

; RUN: opt %loadPolly -basicaa -polly-scops \ ; RUN: opt %loadPolly -basicaa -polly-scops \
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \ ; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s \ ; RUN: -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s \
; RUN: -check-prefix=SCALAR ; RUN: -check-prefix=SCALAR
; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine \
; RUN: -polly-process-unprofitable=false \ ; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s -check-prefix=PROFIT ; RUN: -analyze < %s | FileCheck %s -check-prefix=PROFIT
; ;
; SCALAR: Function: f ; SCALAR: Function: f
; SCALAR: Region: %bb1---%bb13 ; SCALAR-NEXT: Region: %bb1---%bb13
; SCALAR: Max Loop Depth: 1 ; SCALAR-NEXT: Max Loop Depth: 1
; SCALAR: Context: ; SCALAR-NEXT: Invariant Accesses: {
; SCALAR: { : } ; SCALAR-NEXT: }
; SCALAR: Assumed Context: ; SCALAR-NEXT: Context:
; SCALAR: { : } ; SCALAR-NEXT: { : }
; SCALAR: Alias Groups (0): ; SCALAR-NEXT: Assumed Context:
; SCALAR: n/a ; SCALAR-NEXT: { : }
; SCALAR: Statements { ; SCALAR-NEXT: Boundary Context:
; SCALAR: Stmt_bb3__TO__bb11 ; SCALAR-NEXT: { : }
; SCALAR: Domain := ; SCALAR-NEXT: Arrays {
; SCALAR: { Stmt_bb3__TO__bb11[i0] : ; SCALAR-NEXT: i32 MemRef_C[*]; // Element size 4
; SCALAR-DAG: i0 >= 0 ; SCALAR-NEXT: i32 MemRef_A[*]; // Element size 4
; SCALAR-DAG: and ; SCALAR-NEXT: }
; SCALAR-DAG: i0 <= 1023 ; SCALAR-NEXT: Arrays (Bounds as pw_affs) {
; SCALAR: } ; SCALAR-NEXT: i32 MemRef_C[*]; // Element size 4
; SCALAR: Schedule := ; SCALAR-NEXT: i32 MemRef_A[*]; // Element size 4
; SCALAR: { Stmt_bb3__TO__bb11[i0] -> [i0] }; ; SCALAR-NEXT: }
; SCALAR: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; SCALAR-NEXT: Alias Groups (0):
; SCALAR: { Stmt_bb3__TO__bb11[i0] -> MemRef_C[i0] }; ; SCALAR-NEXT: n/a
; SCALAR: ReadAccess := [Reduction Type: +] [Scalar: 0] ; SCALAR-NEXT: Statements {
; SCALAR: { Stmt_bb3__TO__bb11[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= -2147483648 }; ; SCALAR-NEXT: Stmt_bb3__TO__bb11
; SCALAR: MayWriteAccess := [Reduction Type: +] [Scalar: 0] ; SCALAR-NEXT: Domain :=
; SCALAR: { Stmt_bb3__TO__bb11[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= -2147483648 }; ; SCALAR-NEXT: { Stmt_bb3__TO__bb11[i0] : i0 <= 1023 and i0 >= 0 };
; SCALAR: } ; SCALAR-NEXT: Schedule :=
; SCALAR-NEXT: { Stmt_bb3__TO__bb11[i0] -> [i0] };
; SCALAR-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; SCALAR-NEXT: { Stmt_bb3__TO__bb11[i0] -> MemRef_C[i0] };
; SCALAR-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; SCALAR-NEXT: { Stmt_bb3__TO__bb11[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= -2147483648 };
; SCALAR-NEXT: MayWriteAccess := [Reduction Type: +] [Scalar: 0]
; SCALAR-NEXT: { Stmt_bb3__TO__bb11[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= -2147483648 };
; SCALAR-NEXT: }
; PROFIT-NOT: Statements ; PROFIT-NOT: Statements
; ;
; void f(int * restrict A, int * restrict C) { ; void f(int * restrict A, int * restrict C) {
; int j; ; int j;
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; while ((j = C[i++])) { ; while ((j = C[i++])) {
; A[j]++; ; A[j]++;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non-affine-loop-condition-dependent-access_2.ll

Show All 9 Lines
; RUN: --check-prefix=ALL ; RUN: --check-prefix=ALL
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always model the ; and also a non-affine access (A[k]). While we can always model the
; innermost loop as a SCoP of depth 1, we can overapproximate the ; innermost loop as a SCoP of depth 1, we can overapproximate the
; innermost loop in the whole loop nest and model A[k] as a non-affine ; innermost loop in the whole loop nest and model A[k] as a non-affine
; access. ; access.
; ;
; INNERMOST: Function: f ; INNERMOST: Function: f
; INNERMOST: Region: %bb15---%bb13 ; INNERMOST-NEXT: Region: %bb15---%bb13
; INNERMOST: Max Loop Depth: 1 ; INNERMOST-NEXT: Max Loop Depth: 1
; INNERMOST: p0: {0,+,{0,+,1}<nuw><nsw><%bb11>}<nuw><nsw><%bb13> ; INNERMOST-NEXT: Invariant Accesses: {
; INNERMOST: p1: {0,+,4}<nuw><nsw><%bb11> ; INNERMOST-NEXT: }
; INNERMOST: p2: {0,+,4}<nuw><nsw><%bb13> ; INNERMOST-NEXT: Context:
; INNERMOST: p3: {0,+,{0,+,4}<nuw><nsw><%bb11>}<%bb13> ; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { : p_0 >= 0 and p_0 <= 1048576 and p_1 >= 0 and p_1 <= 4096 and p_2 >= 0 and p_2 <= 4096 and p_3 >= 0 and p_3 <= 4194304 }
; INNERMOST: Alias Groups (0): ; INNERMOST-NEXT: Assumed Context:
; INNERMOST: n/a ; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { : }
; INNERMOST: Statements { ; INNERMOST-NEXT: Boundary Context:
; INNERMOST: Stmt_bb16 ; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { : }
; INNERMOST: Domain := ; INNERMOST-NEXT: p0: {0,+,{0,+,1}<nuw><nsw><%bb11>}<nuw><nsw><%bb13>
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] : i0 <= 1023 - p_0 and i0 >= 0 } ; INNERMOST-NEXT: p1: {0,+,4}<nuw><nsw><%bb11>
; INNERMOST: Schedule := ; INNERMOST-NEXT: p2: {0,+,4}<nuw><nsw><%bb13>
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> [0, i0] } ; INNERMOST-NEXT: p3: {0,+,{0,+,4}<nuw><nsw><%bb11>}<%bb13>
; INNERMOST: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; INNERMOST-NEXT: Arrays {
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_1 }; ; INNERMOST-NEXT: i32 MemRef_A[*]; // Element size 4
; INNERMOST: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next6; // Element size 8
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_2 }; ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next4; // Element size 8
; INNERMOST: ReadAccess := [Reduction Type: +] [Scalar: 0] ; INNERMOST-NEXT: }
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_3 + 4i0 }; ; INNERMOST-NEXT: Arrays (Bounds as pw_affs) {
; INNERMOST: MustWriteAccess := [Reduction Type: +] [Scalar: 0] ; INNERMOST-NEXT: i32 MemRef_A[*]; // Element size 4
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_3 + 4i0 }; ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next6; // Element size 8
; INNERMOST: Stmt_bb26 ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next4; // Element size 8
; INNERMOST: Domain := ; INNERMOST-NEXT: }
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] : p_0 <= 1024 }; ; INNERMOST-NEXT: Alias Groups (0):
; INNERMOST: Schedule := ; INNERMOST-NEXT: n/a
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> [1, 0] }; ; INNERMOST-NEXT: Statements {
; INNERMOST: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; INNERMOST-NEXT: Stmt_bb16
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> MemRef_indvars_iv_next6[] }; ; INNERMOST-NEXT: Domain :=
; INNERMOST: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] : i0 <= 1023 - p_0 and i0 >= 0 };
; INNERMOST: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> MemRef_indvars_iv_next4[] }; ; INNERMOST-NEXT: Schedule :=
; INNERMOST: } ; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> [0, i0] };
; ; INNERMOST-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_1 };
; INNERMOST-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_2 };
; INNERMOST-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_3 + 4i0 };
; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_3 + 4i0 };
; INNERMOST-NEXT: Stmt_bb26
; INNERMOST-NEXT: Domain :=
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] : p_0 <= 1024 };
; INNERMOST-NEXT: Schedule :=
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> [1, 0] };
; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> MemRef_indvars_iv_next6[] };
; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; INNERMOST-NEXT: [p_0, p_1, p_2, p_3] -> { Stmt_bb26[] -> MemRef_indvars_iv_next4[] };
; INNERMOST-NEXT: }
; ALL: Function: f ; ALL: Function: f
; ALL: Region: %bb11---%bb29 ; ALL-NEXT: Region: %bb11---%bb29
; ALL: Max Loop Depth: 2 ; ALL-NEXT: Max Loop Depth: 2
; ALL: Context: ; ALL-NEXT: Invariant Accesses: {
; ALL: { : } ; ALL-NEXT: }
; ALL: Assumed Context: ; ALL-NEXT: Context:
; ALL: { : } ; ALL-NEXT: { : }
; ALL: Alias Groups (0): ; ALL-NEXT: Assumed Context:
; ALL: n/a ; ALL-NEXT: { : }
; ALL: Statements { ; ALL-NEXT: Boundary Context:
; ALL: Stmt_bb15__TO__bb25 ; ALL-NEXT: { : }
; ALL: Domain := ; ALL-NEXT: Arrays {
; ALL: { Stmt_bb15__TO__bb25[i0, i1] : ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: i0 >= 0 ; ALL-NEXT: }
; ALL-DAG: and ; ALL-NEXT: Arrays (Bounds as pw_affs) {
; ALL-DAG: i0 <= 1023 ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: and ; ALL-NEXT: }
; ALL-DAG: i1 >= 0 ; ALL-NEXT: Alias Groups (0):
; ALL-DAG: and ; ALL-NEXT: n/a
; ALL-DAG: i1 <= 1023 ; ALL-NEXT: Statements {
; ALL: } ; ALL-NEXT: Stmt_bb15__TO__bb25
; ALL: Schedule := ; ALL-NEXT: Domain :=
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> [i0, i1] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0 };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Schedule :=
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i0] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> [i0, i1] };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i1] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i0] };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 2305843009213693949 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i1] };
; ALL: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 2305843009213693949 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 2305843009213693949 and o0 >= 0 };
; ALL: } ; ALL-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 2305843009213693949 and o0 >= 0 };
; ALL-NEXT: }
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = 0; j < 1024; j++) ; for (int j = 0; j < 1024; j++)
; for (int k = i *j; k < 1024; k++) ; for (int k = i *j; k < 1024; k++)
; A[k] += A[i] + A[j]; ; A[k] += A[i] + A[j];
; } ; }
; ;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non-affine-loop-condition-dependent-access_3.ll

; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: -polly-allow-nonaffine-loops=false \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -basicaa -polly-scops -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALL ; RUN: -analyze < %s | FileCheck %s --check-prefix=ALL
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always model the ; and also a non-affine access (A[k]). While we can always model the
; innermost loop as a SCoP of depth 1, we can overapproximate the ; innermost loop as a SCoP of depth 1, we can overapproximate the
; innermost loop in the whole loop nest and model A[k] as a non-affine ; innermost loop in the whole loop nest and model A[k] as a non-affine
; access. ; access.
; ;
; INNERMOST: Function: f ; INNERMOST: Function: f
; INNERMOST: Region: %bb15---%bb13 ; INNERMOST-NEXT: Region: %bb15---%bb13
; INNERMOST: Max Loop Depth: 1 ; INNERMOST-NEXT: Max Loop Depth: 1
; INNERMOST: Context: ; INNERMOST-NEXT: Invariant Accesses: {
; INNERMOST: [p_0, p_1, p_2] -> { : ; INNERMOST-NEXT: }
; INNERMOST-DAG: p_0 >= 0 ; INNERMOST-NEXT: Context:
; INNERMOST-DAG: and ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { : p_0 >= 0 and p_0 <= 2147483647 and p_1 >= 0 and p_1 <= 4096 and p_2 >= 0 and p_2 <= 4096 }
; INNERMOST-DAG: p_0 <= 2147483647 ; INNERMOST-NEXT: Assumed Context:
; INNERMOST-DAG: and ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { : }
; INNERMOST-DAG: p_1 >= 0 ; INNERMOST-NEXT: Boundary Context:
; INNERMOST-DAG: and ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { : }
; INNERMOST-DAG: p_1 <= 4096 ; INNERMOST-NEXT: p0: {0,+,{0,+,1}<nuw><nsw><%bb11>}<nuw><nsw><%bb13>
; INNERMOST-DAG: and ; INNERMOST-NEXT: p1: {0,+,4}<nuw><nsw><%bb11>
; INNERMOST-DAG: p_2 >= 0 ; INNERMOST-NEXT: p2: {0,+,4}<nuw><nsw><%bb13>
; INNERMOST-DAG: and ; INNERMOST-NEXT: Arrays {
; INNERMOST-DAG: p_2 <= 4096 ; INNERMOST-NEXT: i32 MemRef_A[*]; // Element size 4
; INNERMOST: } ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next6; // Element size 8
; INNERMOST: Assumed Context: ; INNERMOST-NEXT: i32 MemRef_indvars_iv_next4; // Element size 4
; INNERMOST: [p_0, p_1, p_2] -> { : } ; INNERMOST-NEXT: }
; INNERMOST: p0: {0,+,{0,+,1}<nuw><nsw><%bb11>}<nuw><nsw><%bb13> ; INNERMOST-NEXT: Arrays (Bounds as pw_affs) {
; INNERMOST: p1: {0,+,4}<nuw><nsw><%bb11> ; INNERMOST-NEXT: i32 MemRef_A[*]; // Element size 4
; INNERMOST: p2: {0,+,4}<nuw><nsw><%bb13> ; INNERMOST-NEXT: i64 MemRef_indvars_iv_next6; // Element size 8
; INNERMOST: Alias Groups (0): ; INNERMOST-NEXT: i32 MemRef_indvars_iv_next4; // Element size 4
; INNERMOST: n/a ; INNERMOST-NEXT: }
; INNERMOST: Statements { ; INNERMOST-NEXT: Alias Groups (0):
; INNERMOST: Stmt_bb16 ; INNERMOST-NEXT: n/a
; INNERMOST: Domain := ; INNERMOST-NEXT: Statements {
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] : ; INNERMOST-NEXT: Stmt_bb16
; INNERMOST-DAG: i0 >= 0 ; INNERMOST-NEXT: Domain :=
; INNERMOST-DAG: and ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] : i0 >= 0 and i0 <= -1 + p_0 };
; INNERMOST-DAG: i0 <= -1 + p_0 ; INNERMOST-NEXT: Schedule :=
; INNERMOST-DAG: }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> [0, i0] };
; INNERMOST: Schedule := ; INNERMOST-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> [0, i0] }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_1 };
; INNERMOST: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; INNERMOST-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_1 }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_2 };
; INNERMOST: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; INNERMOST-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[o0] : 4o0 = p_2 }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[i0] };
; INNERMOST: ReadAccess := [Reduction Type: +] [Scalar: 0] ; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[i0] }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[i0] };
; INNERMOST: MustWriteAccess := [Reduction Type: +] [Scalar: 0] ; INNERMOST-NEXT: Stmt_bb26
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb16[i0] -> MemRef_A[i0] }; ; INNERMOST-NEXT: Domain :=
; INNERMOST: Stmt_bb26 ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb26[] : p_0 >= 0 };
; INNERMOST: Domain := ; INNERMOST-NEXT: Schedule :=
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb26[] : p_0 >= 0 }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb26[] -> [1, 0] };
; INNERMOST: Schedule := ; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb26[] -> [1, 0] }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb26[] -> MemRef_indvars_iv_next6[] };
; INNERMOST: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; INNERMOST-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb26[] -> MemRef_indvars_iv_next6[] }; ; INNERMOST-NEXT: [p_0, p_1, p_2] -> { Stmt_bb26[] -> MemRef_indvars_iv_next4[] };
; INNERMOST: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; INNERMOST-NEXT: }
; INNERMOST: [p_0, p_1, p_2] -> { Stmt_bb26[] -> MemRef_indvars_iv_next4[] };
; INNERMOST: }
;
; ALL: Function: f ; ALL: Function: f
; ALL: Region: %bb11---%bb29 ; ALL-NEXT: Region: %bb11---%bb29
; ALL: Max Loop Depth: 2 ; ALL-NEXT: Max Loop Depth: 2
; ALL: Context: ; ALL-NEXT: Invariant Accesses: {
; ALL: { : } ; ALL-NEXT: }
; ALL: Assumed Context: ; ALL-NEXT: Context:
; ALL: { : } ; ALL-NEXT: { : }
; ALL: Alias Groups (0): ; ALL-NEXT: Assumed Context:
; ALL: n/a ; ALL-NEXT: { : }
; ALL: Statements { ; ALL-NEXT: Boundary Context:
; ALL: Stmt_bb15__TO__bb25 ; ALL-NEXT: { : }
; ALL: Domain := ; ALL-NEXT: Arrays {
; ALL: { Stmt_bb15__TO__bb25[i0, i1] : ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: i0 >= 0 ; ALL-NEXT: }
; ALL-DAG: and ; ALL-NEXT: Arrays (Bounds as pw_affs) {
; ALL-DAG: i0 <= 1023 ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: and ; ALL-NEXT: }
; ALL-DAG: i1 >= 0 ; ALL-NEXT: Alias Groups (0):
; ALL-DAG: and ; ALL-NEXT: n/a
; ALL-DAG: i1 <= 1023 ; ALL-NEXT: Statements {
; ALL: } ; ALL-NEXT: Stmt_bb15__TO__bb25
; ALL: Schedule := ; ALL-NEXT: Domain :=
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> [i0, i1] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0 };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Schedule :=
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i0] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> [i0, i1] };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i1] }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i0] };
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 4294967293 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[i1] };
; ALL: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 4294967293 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 4294967293 and o0 >= 0 };
; ALL: } ; ALL-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb15__TO__bb25[i0, i1] -> MemRef_A[o0] : o0 <= 4294967293 and o0 >= 0 };
; ALL-NEXT: }
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = 0; j < 1024; j++) ; for (int j = 0; j < 1024; j++)
; for (int k = 0; k < i * j; k++) ; for (int k = 0; k < i * j; k++)
; A[k] += A[i] + A[j]; ; A[k] += A[i] + A[j];
; } ; }
; ;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_access_with_range_2.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 128; i++) ; for (int i = 0; i < 128; i++)
; for (int j = 0; j < 16; j++) ; for (int j = 0; j < 16; j++)
; A[i * j]++; ; A[i * j]++;
; } ; }
; ;
; CHECK: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK: Statements {
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_A[o0] : o0 <= 2046 and o0 >= 0 }; ; CHECK-NEXT: Stmt_bb7
; CHECK: MayWriteAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_A[o0] : o0 <= 2046 and o0 >= 0 }; ; CHECK-NEXT: { Stmt_bb7[i0, i1] : i0 <= 127 and i0 >= 0 and i1 <= 15 and i1 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> [i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_A[o0] : o0 <= 2046 and o0 >= 0 };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_A[o0] : o0 <= 2046 and o0 >= 0 };
; CHECK-NEXT: }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A) { define void @f(i32* %A) {
bb: bb:
br label %bb4 br label %bb4
bb4: ; preds = %bb13, %bb bb4: ; preds = %bb13, %bb
Show All 34 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_but_sdiv.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: Statements {
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : 5o0 >= -4 + N + 5i0 and 5o0 <= N + 5i0 }; ; CHECK-NEXT: Stmt_for_body
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : 5o0 <= 4 - N + 5i0 and 5o0 >= -N + 5i0 }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : 5o0 >= -4 + N + 5i0 and 5o0 <= N + 5i0 };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : 5o0 <= 4 - N + 5i0 and 5o0 >= -N + 5i0 };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = A[i + (N / 5)] + A[i + (N / -5)]; ; A[i] = A[i + (N / 5)] + A[i + (N / -5)];
; } ; }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 35 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_but_srem.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-scops \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; void pos(float *A, long n) { ; void pos(float *A, long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[n % 42] += 1; ; A[n % 42] += 1;
; } ; }
; ;
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] :
; CHECK: exists (e0 = floor((-n + o0)/42):
; CHECK: 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] :
; CHECK: exists (e0 = floor((-n + o0)/42):
; CHECK: 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; ;
; void neg(float *A, long n) { ; void neg(float *A, long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[n % (-42)] += 1; ; A[n % (-42)] += 1;
; } ; }
; CHECK: Statements {
; CHECK-NEXT: Stmt_bb2
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [n] -> { Stmt_bb2[i0] : i0 <= 99 and i0 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : exists (e0 = floor((-n + o0)/42): 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : exists (e0 = floor((-n + o0)/42): 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; CHECK-NEXT: }
; ;
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: Statements {
; CHECK: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : ; CHECK-NEXT: Stmt_bb2
; CHECK: exists (e0 = floor((-n + o0)/42): ; CHECK-NEXT: Domain :=
; CHECK: 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) }; ; CHECK-NEXT: [n] -> { Stmt_bb2[i0] : i0 <= 99 and i0 >= 0 };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Schedule :=
; CHECK: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : ; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> [i0] };
; CHECK: exists (e0 = floor((-n + o0)/42): ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) }; ; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : exists (e0 = floor((-n + o0)/42): 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb2[i0] -> MemRef_A[o0] : exists (e0 = floor((-n + o0)/42): 42e0 = -n + o0 and o0 <= 41 and o0 >= 0) };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @pos(float* %A, i64 %n) { define void @pos(float* %A, i64 %n) {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb6, %bb bb1: ; preds = %bb6, %bb
%i.0 = phi i64 [ 0, %bb ], [ %tmp7, %bb6 ] %i.0 = phi i64 [ 0, %bb ], [ %tmp7, %bb6 ]
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_conditional_surrounding_affine_loop.ll

Show All 14 Lines
; Possible solutions could be: ; Possible solutions could be:
; - Do not optimistically assume it to be invariant (as before this commit), however we would loose ; - Do not optimistically assume it to be invariant (as before this commit), however we would loose
; a lot of invariant cases due to possible aliasing. ; a lot of invariant cases due to possible aliasing.
; - Reduce the size of the SCoP if an assumed invariant access is in fact not invariant instead of ; - Reduce the size of the SCoP if an assumed invariant access is in fact not invariant instead of
; rejecting the whole region. ; rejecting the whole region.
; ;
; INNERMOST-NOT: Function: f ; INNERMOST-NOT: Function: f
; ;
; ALL: Function: f ; ALL: Function: f
; ALL: Region: %bb3---%bb19 ; ALL-NEXT: Region: %bb3---%bb19
; ALL: Max Loop Depth: 1 ; ALL-NEXT: Max Loop Depth: 1
; ALL: Context: ; ALL-NEXT: Invariant Accesses: {
; ALL: { : } ; ALL-NEXT: }
; ALL: Assumed Context: ; ALL-NEXT: Context:
; ALL: { : } ; ALL-NEXT: { : }
; ALL: Alias Groups (0): ; ALL-NEXT: Assumed Context:
; ALL: n/a ; ALL-NEXT: { : }
; ALL: Statements { ; ALL-NEXT: Boundary Context:
; ALL: Stmt_bb4__TO__bb17 ; ALL-NEXT: { : }
; ALL: Domain := ; ALL-NEXT: Arrays {
; ALL: { Stmt_bb4__TO__bb17[i0] : ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: i0 >= 0 ; ALL-NEXT: }
; ALL-DAG: and ; ALL-NEXT: Arrays (Bounds as pw_affs) {
; ALL-DAG: i0 <= 1023 ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL: } ; ALL-NEXT: }
; ALL: Schedule := ; ALL-NEXT: Alias Groups (0):
; ALL: { Stmt_bb4__TO__bb17[i0] -> [i0] }; ; ALL-NEXT: n/a
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Statements {
; ALL: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[i0] }; ; ALL-NEXT: Stmt_bb4__TO__bb17
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Domain :=
; ALL: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb4__TO__bb17[i0] : i0 <= 1023 and i0 >= 0 };
; ALL: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Schedule :=
; ALL: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb4__TO__bb17[i0] -> [i0] };
; ALL: } ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[i0] };
; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= 0 };
; ALL-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb17[i0] -> MemRef_A[o0] : o0 <= 2147483645 and o0 >= 0 };
; ALL-NEXT: }
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; A[j]++; ; A[j]++;
; } ; }
; ;
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_conditional_surrounding_non_affine_loop.ll

Show All 18 Lines
; Possible solutions could be: ; Possible solutions could be:
; - Do not optimistically assume it to be invariant (as before this commit), however we would loose ; - Do not optimistically assume it to be invariant (as before this commit), however we would loose
; a lot of invariant cases due to possible aliasing. ; a lot of invariant cases due to possible aliasing.
; - Reduce the size of the SCoP if an assumed invariant access is in fact not invariant instead of ; - Reduce the size of the SCoP if an assumed invariant access is in fact not invariant instead of
; rejecting the whole region. ; rejecting the whole region.
; ;
; INNERMOST-NOT: Function: f ; INNERMOST-NOT: Function: f
; ;
; ALL: Function: f ; ALL: Function: f
; ALL: Region: %bb3---%bb20 ; ALL-NEXT: Region: %bb3---%bb20
; ALL: Max Loop Depth: 1 ; ALL-NEXT: Max Loop Depth: 1
; ALL: Context: ; ALL-NEXT: Invariant Accesses: {
; ALL: { : } ; ALL-NEXT: }
; ALL: Assumed Context: ; ALL-NEXT: Context:
; ALL: { : } ; ALL-NEXT: { : }
; ALL: Alias Groups (0): ; ALL-NEXT: Assumed Context:
; ALL: n/a ; ALL-NEXT: { : }
; ALL: Statements { ; ALL-NEXT: Boundary Context:
; ALL: Stmt_bb4__TO__bb18 ; ALL-NEXT: { : }
; ALL: Domain := ; ALL-NEXT: Arrays {
; ALL: { Stmt_bb4__TO__bb18[i0] : ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL-DAG: i0 >= 0 ; ALL-NEXT: }
; ALL-DAG: and ; ALL-NEXT: Arrays (Bounds as pw_affs) {
; ALL-DAG: i0 <= 1023 ; ALL-NEXT: i32 MemRef_A[*]; // Element size 4
; ALL: } ; ALL-NEXT: }
; ALL: Schedule := ; ALL-NEXT: Alias Groups (0):
; ALL: { Stmt_bb4__TO__bb18[i0] -> [i0] }; ; ALL-NEXT: n/a
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Statements {
; ALL: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] }; ; ALL-NEXT: Stmt_bb4__TO__bb18
; ALL: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Domain :=
; ALL: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[o0] : o0 <= 2199023254526 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb4__TO__bb18[i0] : i0 <= 1023 and i0 >= 0 };
; ALL: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; ALL-NEXT: Schedule :=
; ALL: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[o0] : o0 <= 2199023254526 and o0 >= 0 }; ; ALL-NEXT: { Stmt_bb4__TO__bb18[i0] -> [i0] };
; ALL: } ; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
; ALL-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[o0] : o0 <= 2199023254526 and o0 >= 0 };
; ALL-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ALL-NEXT: { Stmt_bb4__TO__bb18[i0] -> MemRef_A[o0] : o0 <= 2199023254526 and o0 >= 0 };
; ALL-NEXT: }
; ;
; PROFIT-NOT: Statements ; PROFIT-NOT: Statements
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; for (int j = 0; j < N * i; j++) ; for (int j = 0; j < N * i; j++)
; A[j]++; ; A[j]++;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_float_compare.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i] == A[i - 1]) ; if (A[i] == A[i - 1])
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK: Region: %bb1---%bb14 ; CHECK-NEXT: Region: %bb1---%bb14
; CHECK: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK: Statements { ; CHECK-NEXT: Invariant Accesses: {
; CHECK: Stmt_bb2__TO__bb12 ; CHECK-NEXT: }
; CHECK: Domain := ; CHECK-NEXT: Context:
; CHECK: { Stmt_bb2__TO__bb12[i0] : ; CHECK-NEXT: { : }
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Assumed Context:
; CHECK-DAG: and ; CHECK-NEXT: { : }
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: Boundary Context:
; CHECK: } ; CHECK-NEXT: { : }
; CHECK: Schedule := ; CHECK-NEXT: Arrays {
; CHECK: { Stmt_bb2__TO__bb12[i0] -> [i0] }; ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: }
; CHECK: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: Arrays (Bounds as pw_affs) {
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
; CHECK: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[-1 + i0] }; ; CHECK-NEXT: }
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Alias Groups (0):
; CHECK: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: n/a
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Statements {
; CHECK: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: Stmt_bb2__TO__bb12
; CHECK: } ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[-1 + i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2__TO__bb12[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(float* %A) { define void @f(float* %A) {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb13, %bb bb1: ; preds = %bb13, %bb
%indvars.iv = phi i64 [ %indvars.iv.next, %bb13 ], [ 0, %bb ] %indvars.iv = phi i64 [ %indvars.iv.next, %bb13 ], [ 0, %bb ]
Show All 29 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_loop_condition.ll

Show All 15 Lines
; ;
; void f(int *A, int *C) { ; void f(int *A, int *C) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; while (C[i]) ; while (C[i])
; A[i]++; ; A[i]++;
; } ; }
; } ; }
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK: Region: %bb1---%bb12 ; CHECK-NEXT: Region: %bb1---%bb12
; CHECK: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK: Statements { ; CHECK-NEXT: Invariant Accesses: {
; CHECK: Stmt_bb3__TO__bb10 ; CHECK-NEXT: }
; CHECK: Domain := ; CHECK-NEXT: Context:
; CHECK: { Stmt_bb3__TO__bb10[i0] : ; CHECK-NEXT: { : }
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Assumed Context:
; CHECK-DAG: and ; CHECK-NEXT: { : }
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: Boundary Context:
; CHECK: } ; CHECK-NEXT: { : }
; CHECK: Schedule := ; CHECK-NEXT: Arrays {
; CHECK: { Stmt_bb3__TO__bb10[i0] -> [i0] }; ; CHECK-NEXT: i32 MemRef_C[*]; // Element size 4
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: { Stmt_bb3__TO__bb10[i0] -> MemRef_C[i0] }; ; CHECK-NEXT: }
; CHECK: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: Arrays (Bounds as pw_affs) {
; CHECK: { Stmt_bb3__TO__bb10[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: i32 MemRef_C[*]; // Element size 4
; CHECK: MayWriteAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: { Stmt_bb3__TO__bb10[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: }
; CHECK: } ; CHECK-NEXT: Alias Groups (1):
; CHECK-NEXT: {{\[\[}} <{ MemRef_C[(0)] }, { MemRef_C[(1024)] }> <{ MemRef_A[(0)] }, { MemRef_A[(1024)] }> {{\]\]}}
; CHECK-NEXT: Statements {
; CHECK-NEXT: Stmt_bb3__TO__bb10
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb3__TO__bb10[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb3__TO__bb10[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb3__TO__bb10[i0] -> MemRef_C[i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb3__TO__bb10[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb3__TO__bb10[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; PROFIT-NOT: Statements ; PROFIT-NOT: Statements
; NO-REDUCTION-NOT: Reduction Type: + ; NO-REDUCTION-NOT: Reduction Type: +
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32* %C) { define void @f(i32* %A, i32* %C) {
Show All 34 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_loop_used_later.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-scops \
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \ ; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s ; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-process-unprofitable=false \ ; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \
; RUN: -analyze < %s | FileCheck %s --check-prefix=PROFIT ; RUN: -analyze < %s | FileCheck %s --check-prefix=PROFIT
; ;
; Verify that we over approximate the read acces of A[j] in the last statement as j is ; Verify that we over approximate the read acces of A[j] in the last statement as j is
; computed in a non-affine loop we do not model. ; computed in a non-affine loop we do not model.
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK: Region: %bb2---%bb24 ; CHECK-NEXT: Region: %bb2---%bb24
; CHECK: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK: Context: ; CHECK-NEXT: Invariant Accesses: {
; CHECK: [N] -> { : ; CHECK-NEXT: }
; CHECK-DAG: N >= -2147483648 ; CHECK-NEXT: Context:
; CHECK-DAG: and ; CHECK-NEXT: [N] -> { : N >= -2147483648 and N <= 2147483647 }
; CHECK-DAG: N <= 2147483647 ; CHECK-NEXT: Assumed Context:
; CHECK: } ; CHECK-NEXT: [N] -> { : }
; CHECK: Assumed Context: ; CHECK-NEXT: Boundary Context:
; CHECK: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK: p0: %N ; CHECK-NEXT: p0: %N
; CHECK: Alias Groups (0): ; CHECK-NEXT: Arrays {
; CHECK: n/a ; CHECK-NEXT: i32 MemRef_j_0__phi; // Element size 4
; CHECK: Statements { ; CHECK-NEXT: i32 MemRef_j_0; // Element size 4
; CHECK: Stmt_bb2 ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: [N] -> { Stmt_bb2[i0] -> MemRef_j_0__phi[] }; ; CHECK-NEXT: i32 MemRef_smax; // Element size 4
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: i32 MemRef_j_2__phi; // Element size 4
; CHECK: [N] -> { Stmt_bb2[i0] -> MemRef_j_0[] }; ; CHECK-NEXT: i32 MemRef_j_2; // Element size 4
; CHECK: Stmt_bb4__TO__bb18 ; CHECK-NEXT: }
; CHECK: Schedule := ; CHECK-NEXT: Arrays (Bounds as pw_affs) {
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> [i0, 1] }; ; CHECK-NEXT: i32 MemRef_j_0__phi; // Element size 4
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: i32 MemRef_j_0; // Element size 4
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: i32 MemRef_smax; // Element size 4
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: i32 MemRef_j_2__phi; // Element size 4
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: i32 MemRef_j_2; // Element size 4
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: }
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Alias Groups (0):
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_smax[] }; ; CHECK-NEXT: n/a
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Statements {
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_2__phi[] }; ; CHECK-NEXT: Stmt_bb2
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_0[] }; ; CHECK-NEXT: [N] -> { Stmt_bb2[i0] : i0 >= 0 and i0 <= N; Stmt_bb2[0] : N <= -1 };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_2__phi[] }; ; CHECK-NEXT: [N] -> { Stmt_bb2[i0] -> [i0, 0] : i0 <= N; Stmt_bb2[0] -> [0, 0] : N <= -1 };
; CHECK: Stmt_bb18 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_bb2[i0] -> MemRef_j_0__phi[] };
; CHECK: [N] -> { Stmt_bb18[i0] -> [i0, 2] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: [N] -> { Stmt_bb2[i0] -> MemRef_j_0[] };
; CHECK: [N] -> { Stmt_bb18[i0] -> MemRef_j_2[] }; ; CHECK-NEXT: Stmt_bb4__TO__bb18
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_bb18[i0] -> MemRef_j_2__phi[] }; ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_bb18[i0] -> MemRef_A[o0] : o0 >= -2147483648 and o0 <= 2147483645 }; ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> [i0, 1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N] -> { Stmt_bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
; CHECK: Stmt_bb23 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_bb23[i0] -> [i0, 3] }; ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_bb23[i0] -> MemRef_j_2[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_smax[] };
; CHECK: [N] -> { Stmt_bb23[i0] -> MemRef_j_0__phi[] }; ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_2__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_2__phi[] };
; CHECK-NEXT: Stmt_bb18
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] -> [i0, 2] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] -> MemRef_j_2[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] -> MemRef_j_2__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] -> MemRef_A[o0] : o0 >= -2147483648 and o0 <= 2147483645 };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_bb18[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_bb23
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_bb23[i0] : i0 <= -1 + N and i0 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_bb23[i0] -> [i0, 3] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb23[i0] -> MemRef_j_2[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_bb23[i0] -> MemRef_j_0__phi[] };
; CHECK-NEXT: }
; ;
; PROFIT-NOT: Statements ; PROFIT-NOT: Statements
; ;
; void f(int *A, int N, int M) { ; void f(int *A, int N, int M) {
; int i = 0, j = 0; ; int i = 0, j = 0;
; for (i = 0; i < N; i++) { ; for (i = 0; i < N; i++) {
; if (A[i]) ; if (A[i])
; for (j = 0; j < M; j++) ; for (j = 0; j < M; j++)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/NonAffine/non_affine_parametric_loop.ll

Show All 18 Linesfor.body:
%inc = add nsw i64 %i, 1 %inc = add nsw i64 %i, 1
%exitcond = icmp eq i64 %inc, %n %exitcond = icmp eq i64 %inc, %n
br i1 %exitcond, label %for.end, label %for.body br i1 %exitcond, label %for.end, label %for.body
for.end: for.end:
ret void ret void
} }
; CHECK: p0: %n ; CHECK: p0: %n
;
; CHECK: Schedule ; CHECK: Statements {
; CHECK: [n] -> { Stmt_for_body[i0] -> [i0] }; ; CHECK-NEXT: Stmt_for_body
; CHECK: ReadAccess ; CHECK-NEXT: Domain :=
; CHECK: [n] -> { Stmt_for_body[i0] -> MemRef_INDEX[i0] }; ; CHECK-NEXT: [n] -> { Stmt_for_body[i0] : i0 >= 0 and i0 <= -1 + n };
; CHECK: WriteAccess ; CHECK-NEXT: Schedule :=
; CHECK: [n] -> { Stmt_for_body[i0] -> MemRef_A[o0] : o0 >= -1152921504606846976 and o0 <= 1152921504606846973 }; ; CHECK-NEXT: [n] -> { Stmt_for_body[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_for_body[i0] -> MemRef_INDEX[i0] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_for_body[i0] -> MemRef_A[o0] : o0 >= -1152921504606846976 and o0 <= 1152921504606846973 };
; CHECK-NEXT: }

polly/trunk/test/ScopInfo/assume_gep_bounds_2.ll

Show All 9 Lines
; B[i][j] = i + j; ; B[i][j] = i + j;
; } ; }
; This code is within bounds either if m and p are smaller than the array sizes, ; This code is within bounds either if m and p are smaller than the array sizes,
; but also if only p is smaller than the size of the second B dimension and n ; but also if only p is smaller than the size of the second B dimension and n
; is such that the first loop is never executed and consequently A is never ; is such that the first loop is never executed and consequently A is never
; accessed. In this case the value of m does not matter. ; accessed. In this case the value of m does not matter.
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [n, m, p] -> { : ; CHECK-NEXT: [n, m, p] -> { : (n <= 0 and p <= 20) or (n >= 1 and m <= 20 and p <= 20) }
; CHECK-DAG: (n >= 1 and m <= 20 and p <= 20)
; CHECK-DAG: or
; CHECK-DAG: (n <= 0 and p <= 20)
; CHECK: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo([20 x float]* noalias %A, [20 x float]* noalias %B, i64 %n, i64 %m, i64 %p) { define void @foo([20 x float]* noalias %A, [20 x float]* noalias %B, i64 %n, i64 %m, i64 %p) {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc5, %entry for.cond: ; preds = %for.inc5, %entry
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/cfg_consequences.ll

Show All 37 Lines
; M_EQ: *A = 0; ; M_EQ: *A = 0;
; ;
; NEQ: *A = 0; ; NEQ: *A = 0;
; if (lhs != rhs) ; if (lhs != rhs)
; S_NEQ: *A = 0; ; S_NEQ: *A = 0;
; M_NEQ: *A = 0; ; M_NEQ: *A = 0;
; ;
; } ; }
; CHECK: Stmt_BC ; CHECK: Statements {
; CHECK-NEXT: Stmt_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] -> [0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] -> [0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_BC ; CHECK-NEXT: Stmt_S_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] : bool_cond <= -1 or bool_cond >= 1 }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] : bool_cond <= -1 or bool_cond >= 1 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] -> [1] : bool_cond <= -1 or bool_cond >= 1 }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] -> [1] : bool_cond <= -1 or bool_cond >= 1 };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_BC ; CHECK-NEXT: Stmt_M_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] -> [2] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] -> [2] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_NEG_BC ; CHECK-NEXT: Stmt_NEG_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] -> [3] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] -> [3] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEG_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_NEG_BC ; CHECK-NEXT: Stmt_S_NEG_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] : bool_cond = 0 }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] : bool_cond = 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] -> [4] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] -> [4] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEG_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_NEG_BC ; CHECK-NEXT: Stmt_M_NEG_BC
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] -> [5] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] -> [5] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEG_BC[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_SLT ; CHECK-NEXT: Stmt_SLT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] -> [6] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] -> [6] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_SLT ; CHECK-NEXT: Stmt_S_SLT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] : rhs >= 1 + lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] : rhs >= 1 + lhs };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] -> [7] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] -> [7] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_SLT ; CHECK-NEXT: Stmt_M_SLT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] -> [8] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] -> [8] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_SLE ; CHECK-NEXT: Stmt_SLE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] -> [9] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] -> [9] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SLE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_SLE ; CHECK-NEXT: Stmt_S_SLE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] : rhs >= lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] : rhs >= lhs };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] -> [10] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] -> [10] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SLE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_SLE ; CHECK-NEXT: Stmt_M_SLE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] -> [11] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] -> [11] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SLE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_SGT ; CHECK-NEXT: Stmt_SGT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] -> [12] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] -> [12] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_SGT ; CHECK-NEXT: Stmt_S_SGT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] : rhs <= -1 + lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] : rhs <= -1 + lhs };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] -> [13] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] -> [13] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_SGT ; CHECK-NEXT: Stmt_M_SGT
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] -> [14] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] -> [14] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGT[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_SGE ; CHECK-NEXT: Stmt_SGE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] -> [15] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] -> [15] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_SGE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_SGE ; CHECK-NEXT: Stmt_S_SGE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] : rhs <= lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] : rhs <= lhs };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] -> [16] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] -> [16] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_SGE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_SGE ; CHECK-NEXT: Stmt_M_SGE
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] -> [17] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] -> [17] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_SGE[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_EQ ; CHECK-NEXT: Stmt_EQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] -> [18] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] -> [18] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_EQ[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_EQ ; CHECK-NEXT: Stmt_S_EQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] : rhs = lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] : rhs = lhs };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] -> [19] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] -> [19] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_EQ[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_EQ ; CHECK-NEXT: Stmt_M_EQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] -> [20] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] -> [20] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_EQ[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_NEQ ; CHECK-NEXT: Stmt_NEQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] -> [21] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] -> [21] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_NEQ[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_S_NEQ ; CHECK-NEXT: Stmt_S_NEQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] : ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] : rhs >= 1 + lhs or rhs <= -1 + lhs };
; CHECK-DAG: rhs >= 1 + lhs
; CHECK-DAG: or
; CHECK-DAG: rhs <= -1 + lhs
; CHECK: };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] -> [22] : rhs >= 1 + lhs or rhs <= -1 + lhs }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] -> [22] : rhs >= 1 + lhs or rhs <= -1 + lhs };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_S_NEQ[] -> MemRef_A[0] };
; CHECK-NEXT: Stmt_M_NEQ ; CHECK-NEXT: Stmt_M_NEQ
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] -> [23] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] -> [23] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] -> MemRef_A[0] }; ; CHECK-NEXT: [bool_cond, lhs, rhs] -> { Stmt_M_NEQ[] -> MemRef_A[0] };
; CHECK-NEXT: }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @consequences(i32* %A, i32 %bool_cond, i32 %lhs, i32 %rhs) { define void @consequences(i32* %A, i32 %bool_cond, i32 %lhs, i32 %rhs) {
entry: entry:
br label %BC br label %BC
BC: ; preds = %entry BC: ; preds = %entry
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/complex-loop-nesting.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
;
; CHECK: Stmt_for_body_outer ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_for_body_outer
; CHECK: { Stmt_for_body_outer[i0] : i0 <= 257 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_for_body_outer[i0] : i0 <= 257 and i0 >= 0 };
; CHECK: { Stmt_for_body_outer[i0] -> [i0, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_body_outer[i0] -> [i0, 0, 0, 0] };
; CHECK: { Stmt_for_body_outer[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_body_outer[i0] -> MemRef_A[i0] };
; CHECK: { Stmt_for_body_outer[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Stmt_for_body ; CHECK-NEXT: { Stmt_for_body_outer[i0] -> MemRef_A[i0] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_for_body
; CHECK: { Stmt_for_body[257, i1] : i1 <= 1025 and i1 >= 0; Stmt_for_body[i0, 0] : i0 <= 256 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_for_body[257, i1] : i1 <= 1025 and i1 >= 0; Stmt_for_body[i0, 0] : i0 <= 256 and i0 >= 0 };
; CHECK: { Stmt_for_body[257, i1] -> [257, 1, i1, 0]; Stmt_for_body[i0, 0] -> [i0, 1, 0, 0] : i0 <= 256 }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_body[257, i1] -> [257, 1, i1, 0]; Stmt_for_body[i0, 0] -> [i0, 1, 0, 0] : i0 <= 256 };
; CHECK: { Stmt_for_body[i0, i1] -> MemRef_A[i1] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_body[i0, i1] -> MemRef_A[i1] };
; CHECK: { Stmt_for_body[i0, i1] -> MemRef_A[i1] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Stmt_for_inc ; CHECK-NEXT: { Stmt_for_body[i0, i1] -> MemRef_A[i1] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_for_inc
; CHECK: { Stmt_for_inc[257, i1] : i1 <= 1025 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_for_inc[257, i1] : i1 <= 1025 and i1 >= 0 };
; CHECK: { Stmt_for_inc[i0, i1] -> [257, 1, i1, 1] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> [257, 1, i1, 1] };
; CHECK: { Stmt_for_inc[i0, i1] -> MemRef_A[i1] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> MemRef_A[i1] };
; CHECK: { Stmt_for_inc[i0, i1] -> MemRef_A[i1] } ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> MemRef_A[i1] };
; ModuleID = 'bugpoint-reduced-simplified.bc' ; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128"
define void @foo(i32* %A) { define void @foo(i32* %A) {
entry: entry:
br label %for.body.outer br label %for.body.outer
for.body.outer: ; preds = %for.body, %entry for.body.outer: ; preds = %for.body, %entry
%indvar = phi i32 [0, %entry], [%indvar.next, %for.body] %indvar = phi i32 [0, %entry], [%indvar.next, %for.body]
Show All 25 Lines

polly/trunk/test/ScopInfo/eager-binary-and-or-conditions.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -analyze < %s
; ;
; void or(float *A, long n, long m) { ; void or(float *A, long n, long m) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; if (i < n || i < m) ; if (i < n || i < m)
; A[i] += i; ; A[i] += i;
; } ; }
; } ; }
; ;
; void and(float *A, long n, long m) { ; void and(float *A, long n, long m) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; if (i < n && i < m) ; if (i < n && i < m)
; A[i] += i; ; A[i] += i;
; } ; }
; } ; }
; CHECK-LABEL: Function: or
; ;
; CHECK: Function: or ; CHECK: Statements {
; CHECK: Stmt_if_then ; CHECK-NEXT: Stmt_if_then
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [n, m] -> { Stmt_if_then[i0] : (i0 <= 99 and i0 >= 0 and i0 <= -1 + m) or (i0 <= 99 and i0 >= 0 and i0 <= -1 + n) }; ; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] : (i0 <= 99 and i0 >= 0 and i0 <= -1 + m) or (i0 <= 99 and i0 >= 0 and i0 <= -1 + n) };
; ; CHECK-NEXT: Schedule :=
; CHECK: Function: and ; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> [i0] : i0 <= -1 + m or i0 <= -1 + n };
; CHECK: Stmt_if_then ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK: [n, m] -> { Stmt_if_then[i0] : i0 <= 99 and i0 >= 0 and i0 <= -1 + m and i0 <= -1 + n } ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; ; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> MemRef_A[i0] };
; ; CHECK-NEXT: }
;
; CHECK-LABEL: Function: and
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_if_then
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] : i0 <= 99 and i0 >= 0 and i0 <= -1 + m and i0 <= -1 + n };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n, m] -> { Stmt_if_then[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @or(float* nocapture %A, i64 %n, i64 %m) #0 { define void @or(float* nocapture %A, i64 %n, i64 %m) #0 {
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %for.inc, %entry for.body: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/exit_phi_accesses-2.ll

; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_body ; CHECK-NEXT: Stmt_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_body[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_body[i0] : i0 <= 100 and i0 >= 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_body[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_body[i0] -> [i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum__phi[] }; ; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum__phi[] }; ; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_body[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_body[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum_next[] }; ; CHECK-NEXT: { Stmt_body[i0] -> MemRef_sum_next[] };
; CHECK-NEXT: } ; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define float @foo(float* %A) { define float @foo(float* %A) {
entry: entry:
br label %header br label %header
Show All 23 Lines

polly/trunk/test/ScopInfo/exit_phi_accesses.ll

; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s
; Check that PHI nodes only create PHI access and nothing else (e.g. unnecessary ; Check that PHI nodes only create PHI access and nothing else (e.g. unnecessary
; SCALAR accesses). In this case, for a PHI in the exit node, hence there is no ; SCALAR accesses). In this case, for a PHI in the exit node, hence there is no
; PHI ReadAccess. ; PHI ReadAccess.
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_header ; CHECK-NEXT: Stmt_header
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_header[] }; ; CHECK-NEXT: { Stmt_header[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_header[] -> [0, 0] }; ; CHECK-NEXT: { Stmt_header[] -> [0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_header[] -> MemRef_phi[] }; ; CHECK-NEXT: { Stmt_header[] -> MemRef_phi[] };
; CHECK-NEXT: Stmt_body ; CHECK-NEXT: Stmt_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_body[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_body[i0] : i0 <= 100 and i0 >= 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_body[i0] -> [1, i0] }; ; CHECK-NEXT: { Stmt_body[i0] -> [1, i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_body[i0] -> MemRef_phi[] }; ; CHECK-NEXT: { Stmt_body[i0] -> MemRef_phi[] };
; CHECK-NEXT: } ; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define float @foo(float %sum, float* %A) { define float @foo(float %sum, float* %A) {
entry: entry:
br label %header br label %header
Show All 15 Lines

polly/trunk/test/ScopInfo/intra-non-affine-stmt-phi-node.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_loop__TO__backedge ; CHECK-NEXT: Stmt_loop__TO__backedge
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] : i0 <= 100 and i0 >= 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> MemRef_merge__phi[] };
; CHECK-NEXT: Stmt_backedge ; CHECK-NEXT: Stmt_backedge
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_backedge[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_backedge[i0] : i0 <= 100 and i0 >= 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_backedge[i0] -> [i0, 1] }; ; CHECK-NEXT: { Stmt_backedge[i0] -> [i0, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_backedge[i0] -> MemRef_merge__phi[] }; ; CHECK-NEXT: { Stmt_backedge[i0] -> MemRef_merge__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_backedge[i0] -> MemRef_A[0] }; ; CHECK-NEXT: { Stmt_backedge[i0] -> MemRef_A[0] };
; CHECK-NEXT: } ; CHECK-NEXT: }
define void @foo(float* %A, i1 %cond0, i1 %cond1) { define void @foo(float* %A, i1 %cond0, i1 %cond1) {
entry: entry:
br label %loop br label %loop
loop: loop:
%indvar = phi i64 [0, %entry], [%indvar.next, %backedge] %indvar = phi i64 [0, %entry], [%indvar.next, %backedge]
%val0 = fadd float 1.0, 2.0 %val0 = fadd float 1.0, 2.0
Show All 20 Lines

polly/trunk/test/ScopInfo/intra_and_inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init2 = *init_ptr; ; init2 = *init_ptr;
; A[i] = init + init2; ; A[i] = init + init2;
; } ; }
; } ; }
; } ; }
; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init_ptr[0] };
; CHECK-NEXT: Execution Context: [N] -> { : N <= -1 or N >= 1 }
; CHECK-NEXT: }
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_j
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
; CHECK-NEXT: }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
; CHECK: Invariant Accesses: {
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MemRef_init_ptr[0]
; CHECK-NOT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NOT: MemRef_init_ptr[0]
; CHECK: }
define void @f(i64* noalias %A, i64 %N, i64* noalias %init_ptr) #0 { define void @f(i64* noalias %A, i64 %N, i64* noalias %init_ptr) #0 {
entry: entry:
br label %for.i br label %for.i
for.i: ; preds = %for.i.end, %entry for.i: ; preds = %for.i.end, %entry
%indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ] %indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ]
%indvar.i.next = add nsw i64 %indvar.i, 1 %indvar.i.next = add nsw i64 %indvar.i, 1
br label %entry.next br label %entry.next
entry.next: ; preds = %for.i entry.next: ; preds = %for.i
%init = load i64, i64* %init_ptr %init = load i64, i64* %init_ptr
; CHECK-NOT: Stmt_entry_next
br label %for.j br label %for.j
for.j: ; preds = %for.j, %entry.next for.j: ; preds = %for.j, %entry.next
%indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ] %indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ]
%init_2 = load i64, i64* %init_ptr %init_2 = load i64, i64* %init_ptr
%init_sum = add i64 %init, %init_2 %init_sum = add i64 %init, %init_2
; CHECK: Stmt_for_j
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
%scevgep = getelementptr i64, i64* %A, i64 %indvar.j %scevgep = getelementptr i64, i64* %A, i64 %indvar.j
store i64 %init_sum, i64* %scevgep store i64 %init_sum, i64* %scevgep
%indvar.j.next = add nsw i64 %indvar.j, 1 %indvar.j.next = add nsw i64 %indvar.j, 1
%exitcond.j = icmp eq i64 %indvar.j.next, %N %exitcond.j = icmp eq i64 %indvar.j.next, %N
br i1 %exitcond.j, label %for.i.end, label %for.j br i1 %exitcond.j, label %for.i.end, label %for.j
for.i.end: ; preds = %for.j for.i.end: ; preds = %for.j
%exitcond.i = icmp eq i64 %indvar.i.next, %N %exitcond.i = icmp eq i64 %indvar.i.next, %N
br i1 %exitcond.i, label %return, label %for.i br i1 %exitcond.i, label %return, label %for.i
return: ; preds = %for.i.end return: ; preds = %for.i.end
ret void ret void
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }

polly/trunk/test/ScopInfo/invariant-loads-leave-read-only-statements.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -analyze < %s
;
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_top_split ; CHECK-NEXT: Stmt_top_split
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> [0, 0, 0, 0] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> [0, 0, 0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> MemRef_25[] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> MemRef_25[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> MemRef_26[] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_top_split[] -> MemRef_26[] };
; CHECK-NEXT: Stmt_L_4 ; CHECK-NEXT: Stmt_L_4
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] : i0 >= 0 and i0 <= -1 + p_0 and i1 >= 0 and i1 <= -1 + p_0 and i2 >= 0 and i2 <= -1 + p_0 }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] : i0 >= 0 and i0 <= -1 + p_0 and i1 >= 0 and i1 <= -1 + p_0 and i2 >= 0 and i2 <= -1 + p_0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> [1, i0, i1, i2] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> [1, i0, i1, i2] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_25[] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_25[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_19[i1, i0] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_19[i1, i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_5[i2, i0] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_5[i2, i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_12[i2, i1] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_12[i2, i1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_19[i1, i0] }; ; CHECK-NEXT: [p_0, p_1, p_2] -> { Stmt_L_4[i0, i1, i2] -> MemRef_19[i1, i0] };
; CHECK-NEXT: } ; CHECK-NEXT: }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%jl_value_t = type { %jl_value_t* } %jl_value_t = type { %jl_value_t* }
define %jl_value_t* @julia_gemm_22583(%jl_value_t*, %jl_value_t**, i32) { define %jl_value_t* @julia_gemm_22583(%jl_value_t*, %jl_value_t**, i32) {
top: top:
br label %top.split br label %top.split
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_load_access_classes_different_base_type_escaping.ll

Show All 12 Lines
; do { ; do {
; x = S.a; ; x = S.a;
; y = S.b; ; y = S.b;
; A[i] = x + y; ; A[i] = x + y;
; } while (i++ < 1000); ; } while (i++ < 1000);
; return x + y; ; return x + y;
; } ; }
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_do_body[i0] -> MemRef_S[0] }; ; CHECK-NEXT: { Stmt_do_body[i0] -> MemRef_S[0] };
; CHECK: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_do_body[i0] -> MemRef_S[1] }; ; CHECK-NEXT: { Stmt_do_body[i0] -> MemRef_S[1] };
; CHECK: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
; CHECK: } ; CHECK-NEXT: }
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NOT: Access ; CHECK-NEXT: Stmt_do_body
; CHECK: Stmt_do_body ; CHECK-NEXT: Domain :=
; CHECK: Domain := ; CHECK-NEXT: { Stmt_do_body[i0] : i0 <= 1000 and i0 >= 0 };
; CHECK: { Stmt_do_body[i0] : i0 <= 1000 and i0 >= 0 }; ; CHECK-NEXT: Schedule :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_do_body[i0] -> [i0] };
; CHECK: { Stmt_do_body[i0] -> [i0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_do_body[i0] -> MemRef_A[i0] };
; CHECK: { Stmt_do_body[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: }
; CHECK-NOT: Access
; CHECK: }
; ;
; CODEGEN: entry: ; CODEGEN: entry:
; CODEGEN: %S.b.preload.s2a = alloca float ; CODEGEN: %S.b.preload.s2a = alloca float
; CODEGEN: %S.a.preload.s2a = alloca i32 ; CODEGEN: %S.a.preload.s2a = alloca i32
; ;
; CODEGEN: polly.preload.begin: ; CODEGEN: polly.preload.begin:
; CODEGEN: %.load = load i32, i32* getelementptr inbounds (%struct.anon, %struct.anon* @S, i32 0, i32 0) ; CODEGEN: %.load = load i32, i32* getelementptr inbounds (%struct.anon, %struct.anon* @S, i32 0, i32 0)
; CODEGEN: store i32 %.load, i32* %S.a.preload.s2a ; CODEGEN: store i32 %.load, i32* %S.a.preload.s2a
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; int U; ; int U;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1000; i++) ; for (int i = 0; i < 1000; i++)
; A[i] = (*(int *)&U) + (int)(*(float *)&U); ; A[i] = (*(int *)&U) + (int)(*(float *)&U);
; } ; }
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NOT: ReadAccess ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_for_body[i0] -> MemRef_U[0] };
; CHECK: { Stmt_for_body[i0] -> MemRef_U[0] }; ; CHECK-NEXT: Execution Context: { : }
; CHECK: Execution Context: { : } ; CHECK-NEXT: }
; CHECK-NOT: ReadAccess
; CHECK: }
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_for_body[i0] : i0 <= 999 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_for_body[i0] : i0 <= 999 and i0 >= 0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_for_body[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_for_body[i0] -> [i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_for_body[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_for_body[i0] -> MemRef_A[i0] };
; CHECK: } ; CHECK-NEXT: }
; ;
; CODEGEN: entry: ; CODEGEN: entry:
; CODEGEN: %U.f.preload.s2a = alloca float ; CODEGEN: %U.f.preload.s2a = alloca float
; CODEGEN: br label %polly.split_new_and_old ; CODEGEN: br label %polly.split_new_and_old
; ;
; CODEGEN: polly.preload.begin: ; CODEGEN: polly.preload.begin:
; CODEGEN: %U.load1 = load float, float* bitcast (i32* @U to float*) ; CODEGEN: %U.load1 = load float, float* bitcast (i32* @U to float*)
; TODO FIXME There should not be a bitcast but either a real conversion or ; TODO FIXME There should not be a bitcast but either a real conversion or
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer_escaping.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; int U; ; int U;
; int f(int *A) { ; int f(int *A) {
; int i = 0, x, y; ; int i = 0, x, y;
; do { ; do {
; x = (*(int *)&U); ; x = (*(int *)&U);
; y = (int)(*(float *)&U); ; y = (int)(*(float *)&U);
; A[i] = x + y; ; A[i] = x + y;
; } while (i++ < 100); ; } while (i++ < 100);
; return x + y; ; return x + y;
; } ; }
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NOT: ReadAccess ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_do_body[i0] -> MemRef_U[0] };
; CHECK: { Stmt_do_body[i0] -> MemRef_U[0] }; ; CHECK-NEXT: Execution Context: { : }
; CHECK: Execution Context: { : } ; CHECK-NEXT: }
; CHECK-NOT: ReadAccess
; CHECK: }
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_do_body ; CHECK-NEXT: Stmt_do_body
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_do_body[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_do_body[i0] : i0 <= 100 and i0 >= 0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_do_body[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_do_body[i0] -> [i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_do_body[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_do_body[i0] -> MemRef_A[i0] };
; CHECK: } ; CHECK-NEXT: }
; ;
; CODEGEN: entry: ; CODEGEN: entry:
; CODEGEN: %U.f.preload.s2a = alloca float ; CODEGEN: %U.f.preload.s2a = alloca float
; CODEGEN: br label %polly.split_new_and_old ; CODEGEN: br label %polly.split_new_and_old
; ;
; CODEGEN: polly.preload.begin: ; CODEGEN: polly.preload.begin:
; CODEGEN: %U.load1 = load float, float* bitcast (i32* @U to float*) ; CODEGEN: %U.load1 = load float, float* bitcast (i32* @U to float*)
; CODEGEN: %0 = bitcast float %U.load1 to i32 ; CODEGEN: %0 = bitcast float %U.load1 to i32
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_loads_complicated_dependences.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_for_body[i0] -> MemRef_LBptr[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_for_body[i0] -> MemRef_LBptr[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_do_cond[i0, i1] -> MemRef_UBptr[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_do_cond[i0, i1] -> MemRef_UBptr[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_if_then[i0, i1] -> MemRef_V[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_if_then[i0, i1] -> MemRef_V[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : (UB >= 1 + LB and UB >= 6) or LB >= 6 } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : (UB >= 1 + LB and UB >= 6) or LB >= 6 }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_if_else[i0, i1] -> MemRef_U[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_if_else[i0, i1] -> MemRef_U[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : LB <= 5 } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : LB <= 5 }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; void f(int *restrict A, int *restrict V, int *restrict U, int *restrict UB, ; void f(int *restrict A, int *restrict V, int *restrict U, int *restrict UB,
; int *restrict LB) { ; int *restrict LB) {
; for (int i = 0; i < 100; i++) { ; for (int i = 0; i < 100; i++) {
; int j = /* invariant load */ *LB; ; int j = /* invariant load */ *LB;
; do { ; do {
; if (j > 5) ; if (j > 5)
; A[i] += /* invariant load */ *V; ; A[i] += /* invariant load */ *V;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[2] ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond[i0] -> MemRef_bounds[2] };
; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : } ; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[1] ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_1[i0, i1] -> MemRef_bounds[1] };
; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : bounds2 >= 1 } ; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : bounds2 >= 1 }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[0] ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_4[i0, i1, i2] -> MemRef_bounds[0] };
; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : bounds1 >= 1 and bounds2 >= 1 } ; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : bounds1 >= 1 and bounds2 >= 1 }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK: p0: %bounds2 ; CHECK: p0: %bounds2
; CHECK: p1: %bounds1 ; CHECK-NEXT: p1: %bounds1
; CHECK: p2: %bounds0 ; CHECK-NEXT: p2: %bounds0
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body_6 ; CHECK-NEXT: Stmt_for_body_6
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] : i0 >= 0 and i0 <= -1 + bounds2 and i1 >= 0 and i1 <= -1 + bounds1 and i2 >= 0 and i2 <= -1 + bounds0 }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] : i0 >= 0 and i0 <= -1 + bounds2 and i1 >= 0 and i1 <= -1 + bounds1 and i2 >= 0 and i2 <= -1 + bounds0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: } ; CHECK-NEXT: }
; ;
; int bounds[3]; ; int bounds[3];
; double data[1024][1024][1024]; ; double data[1024][1024][1024];
; ;
; void foo() { ; void foo() {
; int i, j, k; ; int i, j, k;
; for (k = 0; k < bounds[2]; k++) ; for (k = 0; k < bounds[2]; k++)
; for (j = 0; j < bounds[1]; j++) ; for (j = 0; j < bounds[1]; j++)
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_same_loop_bound_multiple_times-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify that we only have one parameter and one invariant load for all ; Verify that we only have one parameter and one invariant load for all
; three loads that occure in the region but actually access the same ; three loads that occure in the region but actually access the same
; location. Also check that the execution context is the most generic ; location. Also check that the execution context is the most generic
; one, e.g., here the universal set. ; one, e.g., here the universal set.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[0] ; CHECK-NEXT: [bounds0l0] -> { Stmt_for_cond_4[i0, i1, i2] -> MemRef_bounds[0] };
; CHECK-NEXT: Execution Context: [bounds0l0] -> { : } ; CHECK-NEXT: Execution Context: [bounds0l0] -> { : }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK: p0: %bounds0l0 ; CHECK: p0: %bounds0l0
; CHECK-NOT: p1 ; CHECK-NOT: p1
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body_6 ; CHECK-NEXT: Stmt_for_body_6
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] : i0 >= 0 and i0 <= -1 + bounds0l0 and i1 >= 0 and i1 <= -1 + bounds0l0 and i2 >= 0 and i2 <= -1 + bounds0l0 }; ; CHECK-NEXT: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] : i0 >= 0 and i0 <= -1 + bounds0l0 and i1 >= 0 and i1 <= -1 + bounds0l0 and i2 >= 0 and i2 <= -1 + bounds0l0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: } ; CHECK-NEXT: }
; ;
; int bounds[1]; ; int bounds[1];
; double data[1024][1024][1024]; ; double data[1024][1024][1024];
; ;
; void foo() { ; void foo() {
; int i, j, k; ; int i, j, k;
; for (k = 0; k < bounds[0]; k++) ; for (k = 0; k < bounds[0]; k++)
; for (j = 0; j < bounds[0]; j++) ; for (j = 0; j < bounds[0]; j++)
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/invariant_same_loop_bound_multiple_times-2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify that we only have one parameter and one invariant load for all ; Verify that we only have one parameter and one invariant load for all
; three loads that occure in the region but actually access the same ; three loads that occure in the region but actually access the same
; location. Also check that the execution context is the most generic ; location. Also check that the execution context is the most generic
; one, e.g., here the universal set. ; one, e.g., here the universal set.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[0] ; CHECK-NEXT: [bounds0l0, p] -> { Stmt_for_cond_4[i0, i1, i2] -> MemRef_bounds[0] };
; CHECK-NEXT: Execution Context: [bounds0l0, p] -> { : } ; CHECK-NEXT: Execution Context: [bounds0l0, p] -> { : }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK: p0: %bounds0l0 ; CHECK: p0: %bounds0l0
; CHECK: p1: %p ; CHECK-NEXT: p1: %p
; CHECK-NOT: p2: ; CHECK-NOT: p2
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body_6 ; CHECK-NEXT: Stmt_for_body_6
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] : p = 0 and i0 >= 0 and i0 <= -1 + bounds0l0 and i1 >= 0 and i1 <= -1 + bounds0l0 and i2 >= 0 and i2 <= -1 + bounds0l0 }; ; CHECK-NEXT: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] : p = 0 and i0 >= 0 and i0 <= -1 + bounds0l0 and i1 >= 0 and i1 <= -1 + bounds0l0 and i2 >= 0 and i2 <= -1 + bounds0l0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] }; ; CHECK-NEXT: [bounds0l0, p] -> { Stmt_for_body_6[i0, i1, i2] -> MemRef_data[i0, i1, i2] };
; CHECK: } ; CHECK-NEXT: }
; ;
; int bounds[1]; ; int bounds[1];
; double data[1024][1024][1024]; ; double data[1024][1024][1024];
; ;
; void foo(int p) { ; void foo(int p) {
; int i, j, k; ; int i, j, k;
; for (k = 0; k < bounds[0]; k++) ; for (k = 0; k < bounds[0]; k++)
; if (p == 0) ; if (p == 0)
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/isl_trip_count_03.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Test comes from a bug (15771) or better a feature request. It was not allowed ; Test comes from a bug (15771) or better a feature request. It was not allowed
; in Polly in the old domain generation as ScalarEvolution cannot figure out the ; in Polly in the old domain generation as ScalarEvolution cannot figure out the
; loop bounds. However, the new domain generation will detect the SCoP. ; loop bounds. However, the new domain generation will detect the SCoP.
;
; CHECK: Context: ; CHECK: Context:
; CHECK: [n] -> { : n <= 2147483647 and n >= -2147483648 } ; CHECK-NEXT: [n] -> { : n <= 2147483647 and n >= -2147483648 }
;
; CHECK: p0: %n ; CHECK: p0: %n
; CHECK: Statements {
; CHECK: Stmt_for_next
; CHECK: Domain :=
; CHECK: [n] -> { Stmt_for_next[i0] : i0 >= 0 and 2i0 <= -3 + n };
; CHECK: Schedule :=
; CHECK: [n] -> { Stmt_for_next[i0] -> [i0] };
; CHECK: ReadAccess :=
; CHECK: [n] -> { Stmt_for_next[i0] -> MemRef_A[i0] };
; CHECK: WriteAccess :=
; CHECK: [n] -> { Stmt_for_next[i0] -> MemRef_A[i0] };
; CHECK: }
; ;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_next
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [n] -> { Stmt_for_next[i0] : i0 >= 0 and 2i0 <= -3 + n };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [n] -> { Stmt_for_next[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_for_next[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_for_next[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
@A = common global [100 x i32] zeroinitializer, align 16 @A = common global [100 x i32] zeroinitializer, align 16
define void @foo(i32 %n) #0 { define void @foo(i32 %n) #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
%cmp2 = icmp sgt i32 %n, 0 %cmp2 = icmp sgt i32 %n, 0
Show All 27 Lines

polly/trunk/test/ScopInfo/long-sequence-of-error-blocks.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 } %struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 }
; The assumed context of this test case is still very large and should be ; The assumed context of this test case is still very large and should be
; reduced. ; reduced.
; CHECK: Assumed Context:
; CHECK: {{.*}} or {{.*}} or {{.*}} or {{.*}} or {{.*}}
; This test case contains a long sequence of branch instructions together with ; This test case contains a long sequence of branch instructions together with
; function calls that are considered 'error blocks'. We verify that the ; function calls that are considered 'error blocks'. We verify that the
; iteration spaces are not overly complicated. ; iteration spaces are not overly complicated.
; CHECK: Assumed Context:
; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { : (tmp17 = 0 and tmp27 >= 4) or (tmp17 = 0 and tmp27 <= 2) or (tmp21 = 0 and tmp17 <= -1 and tmp27 >= 4) or (tmp21 = 0 and tmp17 <= -1 and tmp27 <= 2) or (tmp21 = 0 and tmp17 >= 1 and tmp27 >= 4) or (tmp21 = 0 and tmp17 >= 1 and tmp27 <= 2) or (tmp17 = 0 and tmp27 = 3 and tmp31 >= 144) or (tmp21 = 0 and tmp27 = 3 and tmp17 <= -1 and tmp31 >= 144) or (tmp21 = 0 and tmp27 = 3 and tmp17 >= 1 and tmp31 >= 144) }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb15 ; CHECK-NEXT: Stmt_bb15
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] -> [0] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] -> [0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] -> MemRef_A[0] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb15[] -> MemRef_A[0] };
; CHECK: Stmt_bb19 ; CHECK-NEXT: Stmt_bb19
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] : tmp17 <= -1 or tmp17 >= 1 }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] : tmp17 <= -1 or tmp17 >= 1 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] -> [1] : tmp17 <= -1 or tmp17 >= 1 }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] -> [1] : tmp17 <= -1 or tmp17 >= 1 };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] -> MemRef_A[0] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb19[] -> MemRef_A[0] };
; CHECK: Stmt_bb24 ; CHECK-NEXT: Stmt_bb24
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] -> [2] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] -> [2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] -> MemRef_A[0] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb24[] -> MemRef_A[0] };
; CHECK: Stmt_bb29 ; CHECK-NEXT: Stmt_bb29
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] : tmp27 = 3 }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] : tmp27 = 3 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] -> [3] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] -> [3] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] -> MemRef_A[0] }; ; CHECK-NEXT: [tmp17, tmp21, tmp27, tmp31] -> { Stmt_bb29[] -> MemRef_A[0] };
; CHECK-NEXT: }
@global = external global [300 x i8], align 16 @global = external global [300 x i8], align 16
@global1 = external global %struct.hoge*, align 8 @global1 = external global %struct.hoge*, align 8
@global2 = external unnamed_addr constant [79 x i8], align 1 @global2 = external unnamed_addr constant [79 x i8], align 1
@global3 = external unnamed_addr constant [57 x i8], align 1 @global3 = external unnamed_addr constant [57 x i8], align 1
declare void @widget() #0 declare void @widget() #0
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/loop_affine_bound_0.ll

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
bb2.preheader: ; preds = %bb.nph8.split, %bb3 bb2.preheader: ; preds = %bb.nph8.split, %bb3
%10 = phi i64 [ 0, %bb.nph8.split ], [ %6, %bb3 ] ; <i64> [#uses=2] %10 = phi i64 [ 0, %bb.nph8.split ], [ %6, %bb3 ] ; <i64> [#uses=2]
br label %bb1 br label %bb1
return: ; preds = %bb.nph8, %bb3, %entry return: ; preds = %bb.nph8, %bb3, %entry
ret void ret void
} }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: p1: %M ; CHECK-NEXT: p1: %M
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb1 ; CHECK-NEXT: Stmt_bb1
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 >= 0 and i1 <= 1 + 5N };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] };
; CHECK-DAG: i0 <= 2 + 4N + 7M ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, i0] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= 1 + 5N
; CHECK: }
; CHECK: Schedule :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] };
; CHECK-NOT: 128i1
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, i0] };
; CHECK-NOT: 128i1
; CHECK: }

polly/trunk/test/ScopInfo/loop_affine_bound_1.ll

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linesbb2.preheader: ; preds = %bb.nph8, %bb3
%tmp9 = sub i64 %7, %8 ; <i64> [#uses=1] %tmp9 = sub i64 %7, %8 ; <i64> [#uses=1]
%9 = icmp sgt i64 %7, %8 ; <i1> [#uses=1] %9 = icmp sgt i64 %7, %8 ; <i1> [#uses=1]
br i1 %9, label %bb1, label %bb3 br i1 %9, label %bb1, label %bb3
return: ; preds = %bb3, %entry return: ; preds = %bb3, %entry
ret void ret void
} }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: p1: %M ; CHECK-NEXT: p1: %M
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb1 ; CHECK-NEXT: Stmt_bb1
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 >= 0 and i1 <= 1 + 5N - i0; Stmt_bb1[0, i1] : 7M <= -3 - 4N and i1 >= 0 and i1 <= 1 + 5N };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] : i0 <= 2 + 4N + 7M; Stmt_bb1[0, i1] -> [0, i1] : 7M <= -3 - 4N };
; CHECK-DAG: i0 <= 2 + 4N + 7M ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, 129i0] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= 1 + 5N - i0
; CHECK-DAG: Stmt_bb1[0, i1] :
; CHECK-DAG: 7M <= -3 - 4N
; CHECK-DAG: and
; CHECK-DAG: i1 >= 0
; CHECK-DAG: and
; CHECK-DAG: i1 <= 1 + 5N
; CHECK: }
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[i1, 129i0] };
; CHECK: }

polly/trunk/test/ScopInfo/loop_affine_bound_2.ll

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesbb3: ; preds = %bb1, %bb
%6 = add nsw i64 %j.07, 1 %6 = add nsw i64 %j.07, 1
%exitcond22 = icmp eq i64 %6, %tmp21 %exitcond22 = icmp eq i64 %6, %tmp21
br i1 %exitcond22, label %return, label %bb br i1 %exitcond22, label %return, label %bb
return: ; preds = %bb3, %entry return: ; preds = %bb3, %entry
ret void ret void
} }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: p1: %M ; CHECK-NEXT: p1: %M
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb1 ; CHECK-NEXT: Stmt_bb1
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] : ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] : i0 >= 0 and i0 <= 2 + 4N + 7M and i1 <= 10 + 5N - 6M - 4i0 and i1 >= 0 };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1] };
; CHECK-DAG: i0 <= 2 + 4N + 7M ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + i1, 897i0] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= 10 + 5N - 6M - 4i0
; CHECK-DAG: }
; CHECK: Schedule :=
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> [i0, i1]
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [N, M] -> { Stmt_bb1[i0, i1] -> MemRef_a[-9 + 6M + i1, 897i0]
; CHECK: }

polly/trunk/test/ScopInfo/loop_carry.ll

Show All 39 Linesbb: ; preds = %bb, %bb.nph
%5 = add nsw i64 %3, %4 ; <i64> [#uses=1] %5 = add nsw i64 %3, %4 ; <i64> [#uses=1]
%exitcond = icmp eq i64 %tmp6, %tmp ; <i1> [#uses=1] %exitcond = icmp eq i64 %tmp6, %tmp ; <i1> [#uses=1]
br i1 %exitcond, label %bb2, label %bb br i1 %exitcond, label %bb2, label %bb
bb2: ; preds = %bb, %entry bb2: ; preds = %bb, %entry
ret i64 0 ret i64 0
} }
; CHECK: Statements {
; CHECK: Stmt_bb
; CHECK: Domain :=
; CHECK: [n] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -2 + n };
; CHECK: Schedule :=
; CHECK: [n] -> { Stmt_bb[i0] -> [i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_1__phi[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_1__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_k_05__phi[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_k_05__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_a[1 + i0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_a[2 + 2i0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_bb[i0] -> MemRef_a[4 + i0] };
; CHECK: Statements {
; CHECK-NEXT: Stmt_bb
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [n] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -2 + n };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> [i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_1__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_1__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_k_05__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_k_05__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_a[1 + i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_a[2 + 2i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n] -> { Stmt_bb[i0] -> MemRef_a[4 + i0] };
; CHECK-NEXT: }

polly/trunk/test/ScopInfo/many-scalar-dependences.ll

Show All 13 Lines
; } ; }
; } ; }
; } ; }
; The scop we generate for this kernel has a very large number of statements ; The scop we generate for this kernel has a very large number of statements
; and scalar data-dependences due to x being passed along as SSA value or PHI ; and scalar data-dependences due to x being passed along as SSA value or PHI
; node. ; node.
; CHECK: Stmt_bb5 ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb5
; CHECK: { Stmt_bb5[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb5[i0] : i0 <= 100 and i0 >= 0 };
; CHECK: { Stmt_bb5[i0] -> [i0, 0, 0, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb5[i0] -> [i0, 0, 0, 0, 0, 0] };
; CHECK: { Stmt_bb5[i0] -> MemRef_x_0__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb5[i0] -> MemRef_x_0__phi[] };
; CHECK: { Stmt_bb5[i0] -> MemRef_x_0[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb6 ; CHECK-NEXT: { Stmt_bb5[i0] -> MemRef_x_0[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb6
; CHECK: { Stmt_bb6[i0] : i0 <= 99 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb6[i0] : i0 <= 99 and i0 >= 0 };
; CHECK: { Stmt_bb6[i0] -> [i0, 1, 0, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb6[i0] -> [i0, 1, 0, 0, 0, 0] };
; CHECK: { Stmt_bb6[i0] -> MemRef_x_0[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb6[i0] -> MemRef_x_0[] };
; CHECK: { Stmt_bb6[i0] -> MemRef_x_1__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb7 ; CHECK-NEXT: { Stmt_bb6[i0] -> MemRef_x_1__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb7
; CHECK: { Stmt_bb7[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 100 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb7[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 100 and i1 >= 0 };
; CHECK: { Stmt_bb7[i0, i1] -> [i0, 2, i1, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> [i0, 2, i1, 0, 0, 0] };
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_x_1__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_x_1__phi[] };
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_x_1[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_x_1[] };
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_x_1_lcssa__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb8 ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_x_1_lcssa__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb8
; CHECK: { Stmt_bb8[i0, i1] : i1 <= 99 and i0 <= 99 and i0 >= 0 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb8[i0, i1] : i1 <= 99 and i0 <= 99 and i0 >= 0 and i1 >= 0 };
; CHECK: { Stmt_bb8[i0, i1] -> [i0, 2, i1, 1, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb8[i0, i1] -> [i0, 2, i1, 1, 0, 0] };
; CHECK: { Stmt_bb8[i0, i1] -> MemRef_x_1[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb8[i0, i1] -> MemRef_x_1[] };
; CHECK: { Stmt_bb8[i0, i1] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb9 ; CHECK-NEXT: { Stmt_bb8[i0, i1] -> MemRef_x_2__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb9
; CHECK: { Stmt_bb9[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 100 and i2 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb9[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 100 and i2 >= 0 };
; CHECK: { Stmt_bb9[i0, i1, i2] -> [i0, 2, i1, 2, i2, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb9[i0, i1, i2] -> [i0, 2, i1, 2, i2, 0] };
; CHECK: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2__phi[] };
; CHECK: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2[] };
; CHECK: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2_lcssa__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb10 ; CHECK-NEXT: { Stmt_bb9[i0, i1, i2] -> MemRef_x_2_lcssa__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb10
; CHECK: { Stmt_bb10[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb10[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 };
; CHECK: { Stmt_bb10[i0, i1, i2] -> [i0, 2, i1, 2, i2, 1] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb10[i0, i1, i2] -> [i0, 2, i1, 2, i2, 1] };
; CHECK: { Stmt_bb10[i0, i1, i2] -> MemRef_x_2[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb10[i0, i1, i2] -> MemRef_x_2[] };
; CHECK: { Stmt_bb10[i0, i1, i2] -> MemRef_x_3__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb11 ; CHECK-NEXT: { Stmt_bb10[i0, i1, i2] -> MemRef_x_3__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb11
; CHECK: { Stmt_bb11[i0, i1, 0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb11[i0, i1, 0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 };
; CHECK: { Stmt_bb11[i0, i1, i2] -> [i0, 2, i1, 2, 0, 2] }; ; CHECK-NEXT: Schedule :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb11[i0, i1, i2] -> [i0, 2, i1, 2, 0, 2] };
; CHECK: { Stmt_bb11[i0, i1, i2] -> MemRef_x_3__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb12 ; CHECK-NEXT: { Stmt_bb11[i0, i1, i2] -> MemRef_x_3__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb12
; CHECK: { Stmt_bb12[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 };
; CHECK: { Stmt_bb12[i0, i1, i2] -> [i0, 2, i1, 2, i2, 3] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] -> [i0, 2, i1, 2, i2, 3] };
; CHECK: { Stmt_bb12[i0, i1, i2] -> MemRef_x_3__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] -> MemRef_x_3__phi[] };
; CHECK: { Stmt_bb12[i0, i1, i2] -> MemRef_x_3[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] -> MemRef_x_3[] };
; CHECK: { Stmt_bb12[i0, i1, i2] -> MemRef_a[i0, i1] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] -> MemRef_a[i0, i1] };
; CHECK: { Stmt_bb12[i0, i1, i2] -> MemRef_a[i0, i1] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Stmt_bb16 ; CHECK-NEXT: { Stmt_bb12[i0, i1, i2] -> MemRef_a[i0, i1] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb16
; CHECK: { Stmt_bb16[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb16[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 and i2 <= 99 and i2 >= 0 };
; CHECK: { Stmt_bb16[i0, i1, i2] -> [i0, 2, i1, 2, i2, 4] }; ; CHECK-NEXT: Schedule :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb16[i0, i1, i2] -> [i0, 2, i1, 2, i2, 4] };
; CHECK: { Stmt_bb16[i0, i1, i2] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb16[i0, i1, i2] -> MemRef_x_2__phi[] };
; CHECK: { Stmt_bb16[i0, i1, i2] -> MemRef_x_3[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb19 ; CHECK-NEXT: { Stmt_bb16[i0, i1, i2] -> MemRef_x_3[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb19
; CHECK: { Stmt_bb19[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb19[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 };
; CHECK: { Stmt_bb19[i0, i1] -> [i0, 2, i1, 3, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb19[i0, i1] -> [i0, 2, i1, 3, 0, 0] };
; CHECK: { Stmt_bb19[i0, i1] -> MemRef_x_2_lcssa[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb19[i0, i1] -> MemRef_x_2_lcssa[] };
; CHECK: { Stmt_bb19[i0, i1] -> MemRef_x_2_lcssa__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb20 ; CHECK-NEXT: { Stmt_bb19[i0, i1] -> MemRef_x_2_lcssa__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb20
; CHECK: { Stmt_bb20[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb20[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 };
; CHECK: { Stmt_bb20[i0, i1] -> [i0, 2, i1, 4, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb20[i0, i1] -> [i0, 2, i1, 4, 0, 0] };
; CHECK: { Stmt_bb20[i0, i1] -> MemRef_x_2_lcssa[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb20[i0, i1] -> MemRef_x_2_lcssa[] };
; CHECK: { Stmt_bb20[i0, i1] -> MemRef_x_1__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb21 ; CHECK-NEXT: { Stmt_bb20[i0, i1] -> MemRef_x_1__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb21
; CHECK: { Stmt_bb21[i0] : i0 <= 99 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb21[i0] : i0 <= 99 and i0 >= 0 };
; CHECK: { Stmt_bb21[i0] -> [i0, 3, 0, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb21[i0] -> [i0, 3, 0, 0, 0, 0] };
; CHECK: { Stmt_bb21[i0] -> MemRef_x_1_lcssa[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb21[i0] -> MemRef_x_1_lcssa[] };
; CHECK: { Stmt_bb21[i0] -> MemRef_x_1_lcssa__phi[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb22 ; CHECK-NEXT: { Stmt_bb21[i0] -> MemRef_x_1_lcssa__phi[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb22
; CHECK: { Stmt_bb22[i0] : i0 <= 99 and i0 >= 0 }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb22[i0] : i0 <= 99 and i0 >= 0 };
; CHECK: { Stmt_bb22[i0] -> [i0, 4, 0, 0, 0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb22[i0] -> [i0, 4, 0, 0, 0, 0] };
; CHECK: { Stmt_bb22[i0] -> MemRef_x_1_lcssa[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb22[i0] -> MemRef_x_1_lcssa[] };
; CHECK: { Stmt_bb22[i0] -> MemRef_x_0__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_bb22[i0] -> MemRef_x_0__phi[] };
; CHECK-NEXT: }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f([100 x float]* %a) { define void @f([100 x float]* %a) {
bb: bb:
br label %bb5 br label %bb5
bb5: ; preds = %bb22, %bb bb5: ; preds = %bb22, %bb
%indvars.iv2 = phi i64 [ %indvars.iv.next3, %bb22 ], [ 0, %bb ] %indvars.iv2 = phi i64 [ %indvars.iv.next3, %bb22 ], [ 0, %bb ]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_2d_outer_parametric_offset.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, long p, double A[n][m]) { ; void foo(long n, long m, long p, double A[n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; A[i+p][j] = 1.0; ; A[i+p][j] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [m, p] -> { : p <= 9223372036854775708 } ; CHECK-NEXT: [m, p] -> { : }
;
; CHECK: p0: %m ; CHECK: p0: %m
; CHECK: p1: %p ; CHECK-NEXT: p1: %p
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_j ; CHECK-NEXT: Stmt_for_j
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [m, p] -> { Stmt_for_j[i0, i1] : ; CHECK-NEXT: [m, p] -> { Stmt_for_j[i0, i1] : i0 <= 99 and i0 >= 0 and i1 >= 0 and i1 <= -1 + m };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [m, p] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-DAG: i0 <= 99 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [m, p] -> { Stmt_for_j[i0, i1] -> MemRef_A[p + i0, i1] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= -1 + m
; CHECK: }
; CHECK: Schedule :=
; CHECK: [m, p] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m, p] -> { Stmt_for_j[i0, i1] -> MemRef_A[p + i0, i1] };
; CHECK: }
define void @foo(i64 %n, i64 %m, i64 %p, double* %A) { define void @foo(i64 %n, i64 %m, i64 %p, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
%add = add nsw i64 %i, %p %add = add nsw i64 %i, %p
Show All 20 Lines

polly/trunk/test/ScopInfo/multidim_2d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double A[n][m]) { ; void foo(long n, long m, double A[n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 150; j++) ; for (long j = 0; j < 150; j++)
; A[i][j] = 1.0; ; A[i][j] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [m] -> { : m >= 150 } ; CHECK-NEXT: [m] -> { : m >= 150 }
;
; CHECK: p0: %m ; CHECK: p0: %m
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_j ; CHECK-NEXT: Stmt_for_j
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [m] -> { Stmt_for_j[i0, i1] ; CHECK-NEXT: [m] -> { Stmt_for_j[i0, i1] : i0 <= 99 and i0 >= 0 and i1 <= 149 and i1 >= 0 };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [m] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-DAG: i0 <= 99 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [m] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= 149
; CHECK: }
; CHECK: Schedule :=
; CHECK: [m] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
define void @foo(i64 %n, i64 %m, double* %A) { define void @foo(i64 %n, i64 %m, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
%tmp = mul nsw i64 %i, %m %tmp = mul nsw i64 %i, %m
Show All 19 Lines

polly/trunk/test/ScopInfo/multidim_3d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 150; j++) ; for (long j = 0; j < 150; j++)
; for (long k = 0; k < 200; k++) ; for (long k = 0; k < 200; k++)
; A[i][j][k] = 1.0; ; A[i][j][k] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [m, o] -> { : ; CHECK-NEXT: [m, o] -> { : m >= 150 and o >= 200 }
; CHECK-DAG: m >= 150 ;
; CHECK-DAG: and
; CHECK-DAG: o >= 200
; CHECK: }
; CHECK: p0: %m ; CHECK: p0: %m
; CHECK: p1: %o ; CHECK-NEXT: p1: %o
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_k ; CHECK-NEXT: Stmt_for_k
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] : ; CHECK-NEXT: [m, o] -> { Stmt_for_k[i0, i1, i2] : i0 <= 99 and i0 >= 0 and i1 <= 149 and i1 >= 0 and i2 <= 199 and i2 >= 0 };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [m, o] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: i0 <= 99 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i1 <= 149
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= 199
; CHECK: }
; CHECK: Schedule :=
; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: MustWriteAccess := [Reduction Type: NONE]
; CHECK: [m, o] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j br label %for.j
Show All 33 Lines

polly/trunk/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; #define N 400 ; #define N 400
; ;
; void first_higher_dimensional(float A[][N]) { ; void first_higher_dimensional(float A[][N]) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++) ; for (long j = 0; j < N; j++)
; A[i][j] += i + j; ; A[i][j] += i + j;
; ;
; A[0][0] += A[100][100]; ; A[0][0] += A[100][100];
; ;
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++) ; for (long j = 0; j < N; j++)
; A[i][j] += i + j; ; A[i][j] += i + j;
; } ; }
; CHECK: Stmt_bb7
; CHECK: Domain :=
; CHECK: { Stmt_bb7[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK: Schedule :=
; CHECK: { Stmt_bb7[i0, i1] -> [0, i0, i1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: Stmt_bb17
; CHECK: Domain :=
; CHECK: { Stmt_bb17[] };
; CHECK: Schedule :=
; CHECK: { Stmt_bb17[] -> [1, 0, 0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_A[100, 100] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK: Stmt_bb26
; CHECK: Domain :=
; CHECK: { Stmt_bb26[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK: Schedule :=
; CHECK: { Stmt_bb26[i0, i1] -> [2, i0, i1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; void first_lower_dimensional(float A[][N], float B[][N]) { ; void first_lower_dimensional(float A[][N], float B[][N]) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++) ; for (long j = 0; j < N; j++)
; B[i][j] += i + j; ; B[i][j] += i + j;
; ;
; A[0][0] += B[100][100]; ; A[0][0] += B[100][100];
; ;
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++) ; for (long j = 0; j < N; j++)
; A[i][j] += i + j; ; A[i][j] += i + j;
; } ; }
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb7 ; CHECK-NEXT: Stmt_bb7
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb7[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 }; ; CHECK-NEXT: { Stmt_bb7[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_bb7[i0, i1] -> [0, i0, i1] }; ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> [0, i0, i1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] }; ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] }; ; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: Stmt_bb17 ; CHECK-NEXT: Stmt_bb17
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb17[] }; ; CHECK-NEXT: { Stmt_bb17[] };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_bb17[] -> [1, 0, 0] }; ; CHECK-NEXT: { Stmt_bb17[] -> [1, 0, 0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_B[100, 100] }; ; CHECK-NEXT: { Stmt_bb17[] -> MemRef_A[100, 100] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_A[0, 0] }; ; CHECK-NEXT: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb17[] -> MemRef_A[0, 0] }; ; CHECK-NEXT: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK: Stmt_bb26 ; CHECK-NEXT: Stmt_bb26
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb26[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 }; ; CHECK-NEXT: { Stmt_bb26[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_bb26[i0, i1] -> [2, i0, i1] }; ; CHECK-NEXT: { Stmt_bb26[i0, i1] -> [2, i0, i1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] }; ; CHECK-NEXT: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] }; ; CHECK-NEXT: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-NEXT: }
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_bb7
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb7[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> [0, i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] };
; CHECK-NEXT: Stmt_bb17
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb17[] };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb17[] -> [1, 0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb17[] -> MemRef_B[100, 100] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb17[] -> MemRef_A[0, 0] };
; CHECK-NEXT: Stmt_bb26
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb26[i0, i1] : i0 <= 399 and i0 >= 0 and i1 <= 399 and i1 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_bb26[i0, i1] -> [2, i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb26[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @first_higher_dimensional([400 x float]* %A) { define void @first_higher_dimensional([400 x float]* %A) {
bb: bb:
br label %bb4 br label %bb4
bb4: ; preds = %bb15, %bb bb4: ; preds = %bb15, %bb
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_fortran_srem.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: Statements {
; CHECK: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp173[o0, 1 + i1, 1 + i2] : exists (e0 = floor((-i0 + o0)/3): 3e0 = -i0 + o0 and o0 <= 2 and o0 >= 0) }; ; CHECK-NEXT: Stmt_bb188
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Domain :=
; CHECK: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp173[o0, 1 + i1, 1 + i2] : exists (e0 = floor((-2 - i0 + o0)/3): 3e0 = -2 - i0 + o0 and o0 <= 2 and o0 >= 0) }; ; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] : i0 >= 0 and i0 <= -3 + tmp183 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> [i0, 0, 0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> MemRef_tmp192[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> MemRef_tmp194[] };
; CHECK-NEXT: Stmt_bb203
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] : i0 >= 0 and i0 <= -3 + tmp183 and i1 >= 0 and i1 <= -3 + tmp180 and i2 >= 0 and i2 <= -3 + tmp177 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> [i0, 1, i1, i2] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp192[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp194[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp173[o0, 1 + i1, 1 + i2] : exists (e0 = floor((-i0 + o0)/3): 3e0 = -i0 + o0 and o0 <= 2 and o0 >= 0) };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_tmp173[o0, 1 + i1, 1 + i2] : exists (e0 = floor((-2 - i0 + o0)/3): 3e0 = -2 - i0 + o0 and o0 <= 2 and o0 >= 0) };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_arg56[1 + i0, 1 + i1, 1 + i2] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb203[i0, i1, i2] -> MemRef_arg55[1 + i0, 1 + i1, 1 + i2] };
; CHECK-NEXT: }
define void @pluto(i32* noalias %arg, [0 x i32]* noalias %arg2, [0 x i32]* noalias %arg3, [0 x i32]* noalias %arg4, [0 x i32]* noalias %arg5, [0 x i32]* noalias %arg6, [0 x i32]* noalias %arg7, [0 x i32]* noalias %arg8, [0 x i32]* noalias %arg9, double* noalias %arg10, double* noalias %arg11, [0 x double]* noalias %arg12, [0 x double]* noalias %arg13, [0 x i32]* noalias %arg14, i32* noalias %arg15, [0 x i32]* noalias %arg16, i32* noalias %arg17, i32* noalias %arg18, i32* noalias %arg19, i32* noalias %arg20, i32* noalias %arg21, i32* noalias %arg22, i32* noalias %arg23, i32* noalias %arg24, i32* noalias %arg25, i32* noalias %arg26, i32* noalias %arg27, [0 x double]* noalias %arg28, [0 x double]* noalias %arg29, [0 x double]* noalias %arg30, [0 x double]* noalias %arg31, [0 x double]* noalias %arg32, [0 x double]* noalias %arg33, [0 x double]* noalias %arg34, [0 x double]* noalias %arg35, [0 x double]* noalias %arg36, [0 x double]* noalias %arg37, [0 x double]* noalias %arg38, [0 x double]* noalias %arg39, [0 x double]* noalias %arg40, [0 x double]* noalias %arg41, [0 x double]* noalias %arg42, [0 x double]* noalias %arg43, [0 x double]* noalias %arg44, [0 x double]* noalias %arg45, [0 x double]* noalias %arg46, [0 x double]* noalias %arg47, [0 x double]* noalias %arg48, [0 x double]* noalias %arg49, [0 x double]* noalias %arg50, [0 x double]* noalias %arg51, [0 x double]* noalias %arg52, [0 x double]* noalias %arg53, [0 x double]* noalias %arg54, [0 x double]* noalias %arg55, [0 x double]* noalias %arg56, [0 x double]* noalias %arg57, [0 x double]* noalias %arg58, [0 x double]* noalias %arg59, [0 x double]* noalias %arg60, [0 x double]* noalias %arg61, [0 x double]* noalias %arg62, [0 x double]* noalias %arg63, [0 x double]* noalias %arg64, [0 x double]* noalias %arg65, [0 x double]* noalias %arg66, [0 x double]* noalias %arg67, [0 x double]* noalias %arg68, [0 x double]* noalias %arg69, i32* noalias %arg70, i32* noalias %arg71, i32* noalias %arg72, i32* noalias %arg73, i32* noalias %arg74, i32* noalias %arg75, i32* noalias %arg76, i32* noalias %arg77, i32* noalias %arg78, i32* noalias %arg79, i32* noalias %arg80, i32* noalias %arg81, i32* noalias %arg82, i32* noalias %arg83, i32* noalias %arg84, i32* noalias %arg85, i32* noalias %arg86, i32* noalias %arg87, i32* noalias %arg88, i32* noalias %arg89, i32* noalias %arg90, i32* noalias %arg91, i32* noalias %arg92, i32* noalias %arg93, i32* noalias %arg94, i32* noalias %arg95, i32* noalias %arg96, i32* noalias %arg97, [0 x double]* noalias %arg98, [0 x double]* noalias %arg99, [0 x double]* noalias %arg100, [0 x double]* noalias %arg101, double* noalias %arg102, double* noalias %arg103, double* noalias %arg104, i32* noalias %arg105, double* noalias %arg106, double* noalias %arg107, [0 x double]* noalias %arg108, [0 x double]* noalias %arg109, [0 x double]* noalias %arg110, [0 x double]* noalias %arg111, [0 x double]* noalias %arg112, [0 x double]* noalias %arg113, [0 x double]* noalias %arg114, [0 x double]* noalias %arg115, [0 x double]* noalias %arg116, [0 x double]* noalias %arg117, [0 x double]* noalias %arg118, [0 x double]* noalias %arg119, [0 x double]* noalias %arg120, [0 x double]* noalias %arg121, [0 x double]* noalias %arg122, [0 x double]* noalias %arg123, [0 x double]* noalias %arg124, [0 x double]* noalias %arg125, [0 x double]* noalias %arg126, [0 x double]* noalias %arg127, [0 x double]* noalias %arg128, [0 x double]* noalias %arg129, [0 x double]* noalias %arg130, [0 x double]* noalias %arg131, i32* noalias %arg132, [0 x double]* noalias %arg133, [0 x double]* noalias %arg134, [0 x double]* noalias %arg135) { define void @pluto(i32* noalias %arg, [0 x i32]* noalias %arg2, [0 x i32]* noalias %arg3, [0 x i32]* noalias %arg4, [0 x i32]* noalias %arg5, [0 x i32]* noalias %arg6, [0 x i32]* noalias %arg7, [0 x i32]* noalias %arg8, [0 x i32]* noalias %arg9, double* noalias %arg10, double* noalias %arg11, [0 x double]* noalias %arg12, [0 x double]* noalias %arg13, [0 x i32]* noalias %arg14, i32* noalias %arg15, [0 x i32]* noalias %arg16, i32* noalias %arg17, i32* noalias %arg18, i32* noalias %arg19, i32* noalias %arg20, i32* noalias %arg21, i32* noalias %arg22, i32* noalias %arg23, i32* noalias %arg24, i32* noalias %arg25, i32* noalias %arg26, i32* noalias %arg27, [0 x double]* noalias %arg28, [0 x double]* noalias %arg29, [0 x double]* noalias %arg30, [0 x double]* noalias %arg31, [0 x double]* noalias %arg32, [0 x double]* noalias %arg33, [0 x double]* noalias %arg34, [0 x double]* noalias %arg35, [0 x double]* noalias %arg36, [0 x double]* noalias %arg37, [0 x double]* noalias %arg38, [0 x double]* noalias %arg39, [0 x double]* noalias %arg40, [0 x double]* noalias %arg41, [0 x double]* noalias %arg42, [0 x double]* noalias %arg43, [0 x double]* noalias %arg44, [0 x double]* noalias %arg45, [0 x double]* noalias %arg46, [0 x double]* noalias %arg47, [0 x double]* noalias %arg48, [0 x double]* noalias %arg49, [0 x double]* noalias %arg50, [0 x double]* noalias %arg51, [0 x double]* noalias %arg52, [0 x double]* noalias %arg53, [0 x double]* noalias %arg54, [0 x double]* noalias %arg55, [0 x double]* noalias %arg56, [0 x double]* noalias %arg57, [0 x double]* noalias %arg58, [0 x double]* noalias %arg59, [0 x double]* noalias %arg60, [0 x double]* noalias %arg61, [0 x double]* noalias %arg62, [0 x double]* noalias %arg63, [0 x double]* noalias %arg64, [0 x double]* noalias %arg65, [0 x double]* noalias %arg66, [0 x double]* noalias %arg67, [0 x double]* noalias %arg68, [0 x double]* noalias %arg69, i32* noalias %arg70, i32* noalias %arg71, i32* noalias %arg72, i32* noalias %arg73, i32* noalias %arg74, i32* noalias %arg75, i32* noalias %arg76, i32* noalias %arg77, i32* noalias %arg78, i32* noalias %arg79, i32* noalias %arg80, i32* noalias %arg81, i32* noalias %arg82, i32* noalias %arg83, i32* noalias %arg84, i32* noalias %arg85, i32* noalias %arg86, i32* noalias %arg87, i32* noalias %arg88, i32* noalias %arg89, i32* noalias %arg90, i32* noalias %arg91, i32* noalias %arg92, i32* noalias %arg93, i32* noalias %arg94, i32* noalias %arg95, i32* noalias %arg96, i32* noalias %arg97, [0 x double]* noalias %arg98, [0 x double]* noalias %arg99, [0 x double]* noalias %arg100, [0 x double]* noalias %arg101, double* noalias %arg102, double* noalias %arg103, double* noalias %arg104, i32* noalias %arg105, double* noalias %arg106, double* noalias %arg107, [0 x double]* noalias %arg108, [0 x double]* noalias %arg109, [0 x double]* noalias %arg110, [0 x double]* noalias %arg111, [0 x double]* noalias %arg112, [0 x double]* noalias %arg113, [0 x double]* noalias %arg114, [0 x double]* noalias %arg115, [0 x double]* noalias %arg116, [0 x double]* noalias %arg117, [0 x double]* noalias %arg118, [0 x double]* noalias %arg119, [0 x double]* noalias %arg120, [0 x double]* noalias %arg121, [0 x double]* noalias %arg122, [0 x double]* noalias %arg123, [0 x double]* noalias %arg124, [0 x double]* noalias %arg125, [0 x double]* noalias %arg126, [0 x double]* noalias %arg127, [0 x double]* noalias %arg128, [0 x double]* noalias %arg129, [0 x double]* noalias %arg130, [0 x double]* noalias %arg131, i32* noalias %arg132, [0 x double]* noalias %arg133, [0 x double]* noalias %arg134, [0 x double]* noalias %arg135) {
bb: bb:
br label %bb136 br label %bb136
bb136: ; preds = %bb bb136: ; preds = %bb
%tmp = load i32, i32* %arg19, align 4 %tmp = load i32, i32* %arg19, align 4
%tmp137 = sext i32 %tmp to i64 %tmp137 = sext i32 %tmp to i64
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_ivs_and_integer_offsets_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n-3; i++) ; for (long i = 0; i < n-3; i++)
; for (long j = 4; j < m; j++) ; for (long j = 4; j < m; j++)
; for (long k = 0; k < o-7; k++) ; for (long k = 0; k < o-7; k++)
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: { : } ; CHECK-NEXT: [o, m, n] -> { : }
;
; CHECK: p0: %o ; CHECK: p0: %o
; CHECK: p1: %m ; CHECK-NEXT: p1: %m
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK-NOT: p3 ; CHECK-NOT: p3
;
; CHECK: Domain ; CHECK: Statements {
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : ; CHECK-NEXT: Stmt_for_k
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -4 + n and i1 >= 0 and i1 <= -5 + m and i2 >= 0 and i2 <= -8 + o };
; CHECK-DAG: i0 <= -4 + n ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
; CHECK-DAG: i1 <= -5 + m ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -8 + o
; CHECK: }
; CHECK: Schedule
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j br label %for.j
Show All 38 Lines

polly/trunk/test/ScopInfo/multidim_ivs_and_parameteric_offsets_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) { ; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
; A[i+p][j+q][k+r] = 1.0; ; A[i+p][j+q][k+r] = 1.0;
; } ; }
; ;
; Access function: ; Access function:
; {{{((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+, ; {{{((8 * ((((%m * %p) + %q) * %o) + %r)) + %A),+,(8 * %m * %o)}<%for.i>,+,
; (8 * %o)}<%for.j>,+,8}<%for.k> ; (8 * %o)}<%for.j>,+,8}<%for.k>
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [o, m, n, p, q, r] -> { : (q <= 0 and q >= 1 - m and r <= -1 and r >= 1 - o) or (r = 0 and q <= 0 and q >= -m) or (r = -o and q <= 1 and q >= 1 - m) } ; CHECK-NEXT: [o, m, n, p, q, r] -> { : (q <= 0 and q >= 1 - m and r <= -1 and r >= 1 - o) or (r = 0 and q <= 0 and q >= -m) or (r = -o and q <= 1 and q >= 1 - m) }
; ;
; CHECK: p0: %o ; CHECK: p0: %o
; CHECK: p1: %m ; CHECK-NEXT: p1: %m
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK: p3: %p ; CHECK-NEXT: p3: %p
; CHECK: p4: %q ; CHECK-NEXT: p4: %q
; CHECK: p5: %r ; CHECK-NEXT: p5: %r
; CHECK-NOT: p6 ; CHECK-NOT: p6
; ;
; CHECK: Domain ; CHECK: Statements {
; CHECK: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] : ; CHECK-NEXT: Stmt_for_k
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK-DAG: i0 <= -1 + n ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[-1 + p + i0, -1 + m + q + i1, o + r + i2] : i1 <= -q and i2 <= -1 - r; Stmt_for_k[i0, i1, i2] -> MemRef_A[p + i0, -1 + q + i1, o + r + i2] : i1 >= 1 - q and i2 <= -1 - r; Stmt_for_k[i0, i1, i2] -> MemRef_A[-1 + p + i0, m + q + i1, r + i2] : i1 <= -1 - q and i2 >= -r; Stmt_for_k[i0, i1, i2] -> MemRef_A[p + i0, q + i1, r + i2] : i1 >= -q and i2 >= -r };
; CHECK-DAG: i1 <= -1 + m ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -1 + o
; CHECK: }
; CHECK: Schedule
; CHECK: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [o, m, n, p, q, r] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[-1 + p + i0, -1 + m + q + i1, o + r + i2] : i1 <= -q and i2 <= -1 - r; Stmt_for_k[i0, i1, i2] -> MemRef_A[p + i0, -1 + q + i1, o + r + i2] : i1 >= 1 - q and i2 <= -1 - r; Stmt_for_k[i0, i1, i2] -> MemRef_A[-1 + p + i0, m + q + i1, r + i2] : i1 <= -1 - q and i2 >= -r; Stmt_for_k[i0, i1, i2] -> MemRef_A[p + i0, q + i1, r + i2] : i1 >= -q and i2 >= -r };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A, i64 %p, i64 %q, i64 %r) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A, i64 %p, i64 %q, i64 %r) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j br label %for.j
Show All 36 Lines

polly/trunk/test/ScopInfo/multidim_nested_start_integer.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; for (long i = 0; i < n - 3; i++) ; for (long i = 0; i < n - 3; i++)
; for (long j = 4; j < m; j++) ; for (long j = 4; j < m; j++)
; for (long k = 0; k < o - 7; k++) ; for (long k = 0; k < o - 7; k++)
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: { : } ; CHECK-NEXT: [o, m, n] -> { : }
;
; CHECK: p0: %o ; CHECK: p0: %o
; CHECK: p1: %m ; CHECK-NEXT: p1: %m
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK-NOT: p3 ; CHECK-NOT: p3
; CHECK: Domain ;
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : ; CHECK: Statements {
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Stmt_for_k
; CHECK-DAG: and ; CHECK-NEXT: Domain :=
; CHECK-DAG: i0 <= -4 + n ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -4 + n and i1 >= 0 and i1 <= -5 + m and i2 >= 0 and i2 <= -8 + o };
; CHECK-DAG: and ; CHECK-NEXT: Schedule :=
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: and ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: i1 <= -5 + m ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
; CHECK-DAG: and ; CHECK-NEXT: }
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -8 + o
; CHECK: }
; CHECK: Schedule
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: MustWriteAccess
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[3 + i0, i1, 7 + i2] };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j br label %for.j
Show All 38 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_2d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double A[n][m]) { ; void foo(long n, long m, double A[n][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; A[i][j] = 1.0; ; A[i][j] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [m, n] -> { : } ; CHECK-NEXT: [m, n] -> { : }
;
; CHECK: p0: %m ; CHECK: p0: %m
; CHECK: p1: %n ; CHECK-NEXT: p1: %n
; CHECK-NOT: p3 ; CHECK-NOT: p3
;
; CHECK: Domain ; CHECK: Statements {
; CHECK: [m, n] -> { Stmt_for_j[i0, i1] : ; CHECK-NEXT: Stmt_for_j
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [m, n] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m };
; CHECK-DAG: i0 <= -1 + n ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [m, n] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [m, n] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
; CHECK-DAG: i1 <= -1 + m ; CHECK-NEXT: }
; CHECK: }
; CHECK: Schedule
; CHECK: [m, n] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK: MustWriteAccess
; CHECK: [m, n] -> { Stmt_for_j[i0, i1] -> MemRef_A[i0, i1] };
define void @foo(i64 %n, i64 %m, double* %A) { define void @foo(i64 %n, i64 %m, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
%tmp = mul nsw i64 %i, %m %tmp = mul nsw i64 %i, %m
Show All 19 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
; A[i][j][k] = 1.0; ; A[i][j][k] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [o, m, n] -> { : } ; CHECK-NEXT: [o, m, n] -> { : }
;
; CHECK: p0: %o ; CHECK: p0: %o
; CHECK: p1: %m ; CHECK-NEXT: p1: %m
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK-NOT: p3 ; CHECK-NOT: p3
; ;
; CHECK: Domain ; CHECK: Statements {
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : ; CHECK-NEXT: Stmt_for_k
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK-DAG: i0 <= -1 + n ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK-DAG: i1 <= -1 + m ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -1 + o
; CHECK: }
; CHECK: Schedule
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [o, m, n] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.j br label %for.j
Show All 33 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d_cast.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
; void foo(int n, int m, int o, double A[n][m][o]) { ; void foo(int n, int m, int o, double A[n][m][o]) {
; ;
; for (int i = 0; i < n; i++) ; for (int i = 0; i < n; i++)
; for (int j = 0; j < m; j++) ; for (int j = 0; j < m; j++)
; for (int k = 0; k < o; k++) ; for (int k = 0; k < o; k++)
; A[i][j][k] = 1.0; ; A[i][j][k] = 1.0;
; } ; }
; We currently fail to get the relation between the 32 and 64 bit versions of ; We currently fail to get the relation between the 32 and 64 bit versions of
; m and o, such that we generate unnecessary run-time checks. This is not a ; m and o, such that we generate unnecessary run-time checks. This is not a
; correctness issue, but could be improved. ; correctness issue, but could be improved.
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: [o, m, n, p_3, p_4] -> { : ; CHECK-NEXT: [o, m, n, p_3, p_4] -> { : p_3 >= m and p_4 >= o }
; CHECK-DAG: p_3 >= m ;
; CHECK-DAG: p_4 >= o
; CHECK: }
; CHECK: p0: %o ; CHECK: p0: %o
; CHECK: p1: %m ; CHECK-NEXT: p1: %m
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK: p3: (zext i32 %m to i64) ; CHECK-NEXT: p3: (zext i32 %m to i64)
; CHECK: p4: (zext i32 %o to i64) ; CHECK-NEXT: p4: (zext i32 %o to i64)
; CHECK-NOT: p5 ; CHECK-NOT: p5
;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK: double MemRef_A[*][(zext i32 %m to i64)][(zext i32 %o to i64)]; // Element size 8 ; CHECK-NEXT: double MemRef_A[*][(zext i32 %m to i64)][(zext i32 %o to i64)]; // Element size 8
; CHECK: } ; CHECK-NEXT: }
;
; CHECK: Arrays (Bounds as pw_affs) { ; CHECK: Arrays (Bounds as pw_affs) {
; CHECK: double MemRef_A[*][ [p_3] -> { [] -> [(p_3)] } ][ [p_4] -> { [] -> [(p_4)] } ]; // Element size 8 ; CHECK-NEXT: double MemRef_A[*][ [p_3] -> { [] -> [(p_3)] } ][ [p_4] -> { [] -> [(p_4)] } ]; // Element size 8
; CHECK: } ; CHECK-NEXT: }
;
; CHECK: Statements {
; CHECK: Domain ; CHECK-NEXT: Stmt_for_k
; CHECK: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] : ; CHECK-NEXT: Domain :=
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + m and i2 >= 0 and i2 <= -1 + o };
; CHECK-DAG: and ; CHECK-NEXT: Schedule :=
; CHECK-DAG: i0 <= -1 + n ; CHECK-NEXT: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: and ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
; CHECK-DAG: and ; CHECK-NEXT: }
; CHECK-DAG: i1 <= -1 + m
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -1 + o
; CHECK: }
; CHECK: Schedule
; CHECK: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [o, m, n, p_3, p_4] -> { Stmt_for_k[i0, i1, i2] -> MemRef_A[i0, i1, i2] };
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define void @foo(i32 %n, i32 %m, i32 %o, double* %A) { define void @foo(i32 %n, i32 %m, i32 %o, double* %A) {
entry: entry:
%m_zext = zext i32 %m to i64 %m_zext = zext i32 %m to i64
%n_zext = zext i32 %o to i64 %n_zext = zext i32 %o to i64
br label %for.i br label %for.i
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d_reverse.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This test case checks for array access functions where the order in which the ; This test case checks for array access functions where the order in which the
; loop ivs appear in the array subscript does not follow the order of the ; loop ivs appear in the array subscript does not follow the order of the
; the loops in which they are defined. This (very common) case caused problems ; the loops in which they are defined. This (very common) case caused problems
; in the delinearization pass. ; in the delinearization pass.
; ;
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; A[i][j][k] = 1.0; ; A[i][j][k] = 1.0;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: { : } ; CHECK-NEXT: [m, o, n] -> { : }
;
; CHECK: p0: %m ; CHECK: p0: %m
; CHECK: p1: %o ; CHECK-NEXT: p1: %o
; CHECK: p2: %n ; CHECK-NEXT: p2: %n
; CHECK-NOT: p3 ; CHECK-NOT: p3
; ;
; CHECK: Domain ; CHECK: Statements {
; CHECK: [m, o, n] -> { Stmt_for_j[i0, i1, i2] : ; CHECK-NEXT: Stmt_for_j
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [m, o, n] -> { Stmt_for_j[i0, i1, i2] : i0 >= 0 and i0 <= -1 + n and i1 >= 0 and i1 <= -1 + o and i2 >= 0 and i2 <= -1 + m };
; CHECK-DAG: i0 <= -1 + n ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [m, o, n] -> { Stmt_for_j[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: [m, o, n] -> { Stmt_for_j[i0, i1, i2] -> MemRef_A[i0, i2, i1] };
; CHECK-DAG: i1 <= -1 + o ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: i2 >= 0
; CHECK-DAG: and
; CHECK-DAG: i2 <= -1 + m
; CHECK: }
; CHECK: Schedule
; CHECK: [m, o, n] -> { Stmt_for_j[i0, i1, i2] -> [i0, i1, i2] };
; CHECK: WriteAccess
; CHECK: [m, o, n] -> { Stmt_for_j[i0, i1, i2] -> MemRef_A[i0, i2, i1] };
define void @foo(i64 %n, i64 %m, i64 %o, double* %A) { define void @foo(i64 %n, i64 %m, i64 %o, double* %A) {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ] %i = phi i64 [ 0, %entry ], [ %i.inc, %for.i.inc ]
br label %for.k br label %for.k
Show All 33 Lines

polly/trunk/test/ScopInfo/multidim_single_and_multidim_array.ll

Show All 13 Lines
; } ; }
; ;
; In previous versions of Polly, the second access was detected as single ; In previous versions of Polly, the second access was detected as single
; dimensional access whereas the first one was detected as multi-dimensional. ; dimensional access whereas the first one was detected as multi-dimensional.
; This test case checks that we now consistently delinearize the array accesses. ; This test case checks that we now consistently delinearize the array accesses.
; CHECK-NOT: Stmt_for_i_1 ; CHECK-NOT: Stmt_for_i_1
; NONAFFINE: p0: %n ; NONAFFINE: p0: %n
; NONAFFINE: p1: ((-1 + %n) * %n) ; NONAFFINE-NEXT: p1: ((-1 + %n) * %n)
;
; NONAFFINE: Statements { ; NONAFFINE: Statements {
; NONAFFINE: Stmt_for_i_1 ; NONAFFINE-NEXT: Stmt_for_i_1
; NONAFFINE: MayWriteAccess := [Reduction Type: NONE] ; NONAFFINE-NEXT: Domain :=
; NONAFFINE: [n, p_1] -> { Stmt_for_i_1[i0] -> MemRef_X[o0] : o0 >= -2305843009213693952 and o0 <= 2305843009213693949 }; ; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_1[i0] : i0 >= 0 and i0 <= -1 + n };
; NONAFFINE: Stmt_for_i_2 ; NONAFFINE-NEXT: Schedule :=
; NONAFFINE: MustWriteAccess := [Reduction Type: NONE] ; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_1[i0] -> [0, i0] };
; NONAFFINE: [n, p_1] -> { Stmt_for_i_2[i0] -> MemRef_X[p_1 + i0] }; ; NONAFFINE-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_1[i0] -> MemRef_X[o0] : o0 >= -2305843009213693952 and o0 <= 2305843009213693949 };
; DELIN: Stmt_for_i_1 ; NONAFFINE-NEXT: Stmt_for_i_2
; DELIN: MustWriteAccess := ; NONAFFINE-NEXT: Domain :=
; DELIN: [n] -> { Stmt_for_i_1[i0] -> MemRef_X[i0, 0] }; ; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_2[i0] : i0 >= 0 and i0 <= -1 + n };
; DELIN: Stmt_for_i_2 ; NONAFFINE-NEXT: Schedule :=
; DELIN: MustWriteAccess := ; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_2[i0] -> [1, i0] };
; DELIN: [n] -> { Stmt_for_i_2[i0] -> MemRef_X[-1 + n, i0] }; ; NONAFFINE-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; NONAFFINE-NEXT: [n, p_1] -> { Stmt_for_i_2[i0] -> MemRef_X[p_1 + i0] };
; NONAFFINE-NEXT: }
; DELIN: Statements {
; DELIN-NEXT: Stmt_for_i_1
; DELIN-NEXT: Domain :=
; DELIN-NEXT: [n] -> { Stmt_for_i_1[i0] : i0 >= 0 and i0 <= -1 + n };
; DELIN-NEXT: Schedule :=
; DELIN-NEXT: [n] -> { Stmt_for_i_1[i0] -> [0, i0] };
; DELIN-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; DELIN-NEXT: [n] -> { Stmt_for_i_1[i0] -> MemRef_X[i0, 0] };
; DELIN-NEXT: Stmt_for_i_2
; DELIN-NEXT: Domain :=
; DELIN-NEXT: [n] -> { Stmt_for_i_2[i0] : i0 >= 0 and i0 <= -1 + n };
; DELIN-NEXT: Schedule :=
; DELIN-NEXT: [n] -> { Stmt_for_i_2[i0] -> [1, i0] };
; DELIN-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; DELIN-NEXT: [n] -> { Stmt_for_i_2[i0] -> MemRef_X[-1 + n, i0] };
; DELIN-NEXT: }
define void @single-and-multi-dimensional-array(i64 %n, float* %X) { define void @single-and-multi-dimensional-array(i64 %n, float* %X) {
entry: entry:
br label %for.i.1 br label %for.i.1
for.i.1: for.i.1:
%indvar.1 = phi i64 [ 0, %entry ], [ %indvar.next.1, %for.i.1 ] %indvar.1 = phi i64 [ 0, %entry ], [ %indvar.next.1, %for.i.1 ]
%offset.1 = mul i64 %n, %indvar.1 %offset.1 = mul i64 %n, %indvar.1
Show All 23 Lines

polly/trunk/test/ScopInfo/multidim_srem.ll

; RUN: opt %loadPolly -analyze -polly-scops -S < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops -S < %s | FileCheck %s
; ;
; void foo(long n, float A[][n][n]) { ; void foo(long n, float A[][n][n]) {
; for (long i = 0; i < 200; i++) ; for (long i = 0; i < 200; i++)
; for (long j = 0; j < n; j++) ; for (long j = 0; j < n; j++)
; for (long k = 0; k < n; k++) ; for (long k = 0; k < n; k++)
; A[i % 2][j][k] += 10; ; A[i % 2][j][k] += 10;
; } ; }
;
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: Statements {
; CHECK: [n] -> { Stmt_for_body_8[i0, i1, i2] -> MemRef_A[o0, i1, i2] : exists (e0 = floor((-i0 + o0)/2): ; CHECK-NEXT: Stmt_for_body_8
; CHECK-DAG: 2e0 = -i0 + o0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [n] -> { Stmt_for_body_8[i0, i1, i2] : i0 <= 199 and i0 >= 0 and i1 >= 0 and i1 <= -1 + n and i2 >= 0 and i2 <= -1 + n };
; CHECK-DAG: o0 <= 1 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: [n] -> { Stmt_for_body_8[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-DAG: o0 >= 0 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: }; ; CHECK-NEXT: [n] -> { Stmt_for_body_8[i0, i1, i2] -> MemRef_A[o0, i1, i2] : exists (e0 = floor((-i0 + o0)/2): 2e0 = -i0 + o0 and o0 <= 1 and o0 >= 0) };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [n] -> { Stmt_for_body_8[i0, i1, i2] -> MemRef_A[o0, i1, i2] : exists (e0 = floor((-i0 + o0)/2): ; CHECK-NEXT: [n] -> { Stmt_for_body_8[i0, i1, i2] -> MemRef_A[o0, i1, i2] : exists (e0 = floor((-i0 + o0)/2): 2e0 = -i0 + o0 and o0 <= 1 and o0 >= 0) };
; CHECK-DAG: 2e0 = -i0 + o0 ; CHECK-NEXT: }
; CHECK-DAG: and
; CHECK-DAG: o0 <= 1
; CHECK-DAG: and
; CHECK-DAG: o0 >= 0
; CHECK: };
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(i64 %n, float* %A) #0 { define void @foo(i64 %n, float* %A) #0 {
entry: entry:
br label %entry.split br label %entry.split
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/nested-loops.ll

Show All 21 Linesbody:
%scevgep = getelementptr i64, i64* %a, i64 %j %scevgep = getelementptr i64, i64* %a, i64 %j
store i64 %j, i64* %scevgep store i64 %j, i64* %scevgep
br label %for.j br label %for.j
return: return:
ret void ret void
} }
; CHECK: body
; CHECK: Domain := ; CHECK: Statements {
; CHECK: { Stmt_body[i0, i1] : ; CHECK-NEXT: Stmt_body
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_body[i0, i1] : i0 <= 2046 and i0 >= 0 and i1 <= 1022 and i1 >= 0 };
; CHECK-DAG: i0 <= 2046 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_body[i0, i1] -> [i0, i1] };
; CHECK-DAG: i1 >= 0 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_body[i0, i1] -> MemRef_a[i1] };
; CHECK-DAG: i1 <= 1022 ; CHECK-NEXT: }
; CHECK: }

polly/trunk/test/ScopInfo/non_affine_region_1.ll

Show All 12 Lines
; else ; else
; x = b; ; x = b;
; ;
; if (A[x]) ; if (A[x])
; A[x] = 0; ; A[x] = 0;
; } ; }
; } ; }
; ;
; CHECK: Region: %bb1---%bb21 ; TODO: We build a complicated representation of Stmt_bb10__TO__bb18's domain that will also complicate the schedule.
; CHECK: Stmt_bb3 ; Once the domain is simple this test should fail and this TODO can be removed.
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [b] -> { Stmt_bb3[i0] -> MemRef_x_1__phi[] }; ; CHECK: Statements {
; CHECK: Stmt_bb7 ; CHECK-NEXT: Stmt_bb3
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [b] -> { Stmt_bb7[i0] -> MemRef_x_1__phi[] };
; CHECK: Stmt_bb8
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [b] -> { Stmt_bb8[i0] -> MemRef_x_1__phi[] };
; CHECK: Stmt_bb10__TO__bb18
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] : ; CHECK-NEXT: [b] -> { Stmt_bb3[i0] : i0 <= 1023 and i0 >= 0 and i0 <= -1 + b };
; CHECK-DAG: i0 >= 0
; CHECK-DAG: and
; CHECK-DAG: i0 <= 1023
; CHECK: };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; TODO: We build a complicated representation of the domain that will also complicate the schedule. ; CHECK-NEXT: [b] -> { Stmt_bb3[i0] -> [i0, 2] };
; Once the domain is as simple as shown above this test should fail and this TODO can be removed. ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: [b] -> { Stmt_bb10__TO__bb18[i0] -> [i0, 3] }; ; CHECK-NEXT: [b] -> { Stmt_bb3[i0] -> MemRef_x_1__phi[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Stmt_bb7
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_x_1__phi[] } ; CHECK-NEXT: Domain :=
; CHECK-NOT: [Scalar: 1] ; CHECK-NEXT: [b] -> { Stmt_bb7[i0] : i0 >= b and 2i0 >= 1 + b and i0 <= 1023 and i0 >= 0 };
; ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [b] -> { Stmt_bb7[i0] -> [i0, 1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [b] -> { Stmt_bb7[i0] -> MemRef_x_1__phi[] };
; CHECK-NEXT: Stmt_bb8
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [b] -> { Stmt_bb8[0] : b = 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [b] -> { Stmt_bb8[i0] -> [0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [b] -> { Stmt_bb8[i0] -> MemRef_b[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [b] -> { Stmt_bb8[i0] -> MemRef_x_1__phi[] };
; CHECK-NEXT: Stmt_bb10__TO__bb18
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] : (i0 <= 1023 and i0 >= 0 and i0 <= -1 + b) or (i0 >= b and 2i0 >= 1 + b and i0 <= 1023 and i0 >= 0); Stmt_bb10__TO__bb18[0] : b = 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] -> [i0, 3] : i0 <= -1 + b or (i0 >= b and 2i0 >= 1 + b); Stmt_bb10__TO__bb18[0] -> [0, 3] : b = 0 };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_x_1__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_A[o0] : o0 >= -2147483648 and o0 <= 2147483645 };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [b] -> { Stmt_bb10__TO__bb18[i0] -> MemRef_A[o0] : o0 >= -2147483648 and o0 <= 2147483645 };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %b) { define void @f(i32* %A, i32 %b) {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb19, %bb bb1: ; preds = %bb19, %bb
%i.0 = phi i32 [ 0, %bb ], [ %tmp20, %bb19 ] %i.0 = phi i32 [ 0, %bb ], [ %tmp20, %bb19 ]
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/non_affine_region_2.ll

Show All 12 Lines
; else if (b < 2 * i) ; else if (b < 2 * i)
; x = i; ; x = i;
; else ; else
; x = b; ; x = b;
; } ; }
; A[i] = x; ; A[i] = x;
; } ; }
; } ; }
; CHECK-LABEL: Region: %bb2---%bb21
; ;
; CHECK: Region: %bb2---%bb21 ; CHECK: Statements {
; CHECK: Stmt_bb3__TO__bb18 ; CHECK-NEXT: Stmt_bb3__TO__bb18
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb3__TO__bb18[i0] : ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> [i0, 0] };
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: };
; CHECK: Schedule :=
; CHECK: { Stmt_bb3__TO__bb18[i0] -> [i0, 0] };
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_0[] };
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_1[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_A[i0] };
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_0[] }; ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_1[] };
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_0[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_1[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_0[] }; ; CHECK-NEXT: Stmt_bb18
; CHECK-NOT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_1[] }; ; CHECK-NEXT: Domain :=
; CHECK: Stmt_bb18 ; CHECK-NEXT: { Stmt_bb18[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK: Domain := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_bb18[i0] : ; CHECK-NEXT: { Stmt_bb18[i0] -> [i0, 1] };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_bb18[i0] -> MemRef_x_2__phi[] };
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: }; ; CHECK-NEXT: { Stmt_bb18[i0] -> MemRef_A[i0] };
; CHECK: Schedule := ; CHECK-NEXT: }
; CHECK: { Stmt_bb18[i0] -> [i0, 1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb18[i0] -> MemRef_A[i0] };
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %b) { define void @f(i32* %A, i32 %b) {
bb: bb:
%tmp = sext i32 %b to i64 %tmp = sext i32 %b to i64
%tmp1 = sext i32 %b to i64 %tmp1 = sext i32 %b to i64
br label %bb2 br label %bb2
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/non_affine_region_3.ll

Show All 12 Lines
; else if (b < 2 * i) ; else if (b < 2 * i)
; x = i; ; x = i;
; else ; else
; x = b; ; x = b;
; } ; }
; A[i] = x; ; A[i] = x;
; } ; }
; } ; }
; CHECK-LABEL: Region: %bb2---%bb21
; ;
; CHECK: Region: %bb2---%bb21 ; CHECK: Statements {
; CHECK: Stmt_bb3__TO__bb18 ; CHECK-NEXT: Stmt_bb3__TO__bb18
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb3__TO__bb18[i0] : ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: Schedule :=
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> [i0, 0] };
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_A[i0] };
; CHECK: Schedule := ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb3__TO__bb18[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb3__TO__bb18[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_b[] };
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Stmt_bb18
; CHECK: { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] }; ; CHECK-NEXT: Domain :=
; CHECK: Stmt_bb18 ; CHECK-NEXT: { Stmt_bb18[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK: Domain := ; CHECK-NEXT: Schedule :=
; CHECK: { Stmt_bb18[i0] : ; CHECK-NEXT: { Stmt_bb18[i0] -> [i0, 1] };
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-DAG: and ; CHECK-NEXT: { Stmt_bb18[i0] -> MemRef_x_2__phi[] };
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: { Stmt_bb18[i0] -> MemRef_A[i0] };
; CHECK: Schedule := ; CHECK-NEXT: }
; CHECK: { Stmt_bb18[i0] -> [i0, 1] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb18[i0] -> MemRef_x_2__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb18[i0] -> MemRef_A[i0] };
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %b) { define void @f(i32* %A, i32 %b) {
bb: bb:
%tmp = sext i32 %b to i64 %tmp = sext i32 %b to i64
%tmp1 = sext i32 %b to i64 %tmp1 = sext i32 %b to i64
br label %bb2 br label %bb2
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/non_affine_region_4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify that both scalars (x and y) are properly written in the non-affine ; Verify that both scalars (x and y) are properly written in the non-affine
; region and read afterwards. ; region and read afterwards.
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; int x = 0, y = 0; ; int x = 0, y = 0;
; if ((x = 1 + A[i])) ; if ((x = 1 + A[i]))
; y++; ; y++;
; A[i] = x + y; ; A[i] = x + y;
; } ; }
; } ; }
;
; CHECK: Region: %bb1---%bb11 ; CHECK-LABEL: Region: %bb1---%bb11
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK: i32 MemRef_A[*]; ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: i32 MemRef_x; [BasePtrOrigin: MemRef_A] ; CHECK-NEXT: i32 MemRef_x; [BasePtrOrigin: MemRef_A] // Element size 4
; CHECK: i32 MemRef_y__phi; ; CHECK-NEXT: i32 MemRef_y__phi; // Element size 4
; CHECK: } ; CHECK-NEXT: }
; ;
; CHECK: Arrays (Bounds as pw_affs) { ; CHECK: Arrays (Bounds as pw_affs) {
; CHECK: i32 MemRef_A[*]; ; CHECK-NEXT: i32 MemRef_A[*]; // Element size 4
; CHECK: i32 MemRef_x; [BasePtrOrigin: MemRef_A] ; CHECK-NEXT: i32 MemRef_x; [BasePtrOrigin: MemRef_A] // Element size 4
; CHECK: i32 MemRef_y__phi; ; CHECK-NEXT: i32 MemRef_y__phi; // Element size 4
; CHECK: } ; CHECK-NEXT: }
; ;
; CHECK: Stmt_bb2__TO__bb7 ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb2__TO__bb7
; CHECK: { Stmt_bb2__TO__bb7[i0] : ; CHECK-NEXT: Domain :=
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK-DAG: and ; CHECK-NEXT: Schedule :=
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] -> [i0, 0] };
; CHECK: }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] -> MemRef_A[i0] };
; CHECK: { Stmt_bb2__TO__bb7[i0] -> [i0, 0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] -> MemRef_x[] };
; CHECK: { Stmt_bb2__TO__bb7[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] -> MemRef_y__phi[] };
; CHECK: { Stmt_bb2__TO__bb7[i0] -> MemRef_x[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MayWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb2__TO__bb7[i0] -> MemRef_y__phi[] };
; CHECK: { Stmt_bb2__TO__bb7[i0] -> MemRef_y__phi[] }; ; CHECK-NEXT: Stmt_bb7
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Domain :=
; CHECK: { Stmt_bb2__TO__bb7[i0] -> MemRef_y__phi[] }; ; CHECK-NEXT: { Stmt_bb7[i0] : i0 <= 1023 and i0 >= 0 };
; CHECK: Stmt_bb7 ; CHECK-NEXT: Schedule :=
; CHECK: Domain := ; CHECK-NEXT: { Stmt_bb7[i0] -> [i0, 1] };
; CHECK: { Stmt_bb7[i0] : ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: { Stmt_bb7[i0] -> MemRef_x[] };
; CHECK-DAG: and ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-DAG: i0 <= 1023 ; CHECK-NEXT: { Stmt_bb7[i0] -> MemRef_y__phi[] };
; CHECK: }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_bb7[i0] -> MemRef_A[i0] };
; CHECK: { Stmt_bb7[i0] -> [i0, 1] }; ; CHECK-NEXT: }
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb7[i0] -> MemRef_x[] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb7[i0] -> MemRef_y__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: { Stmt_bb7[i0] -> MemRef_A[i0] };
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %b) { define void @f(i32* %A, i32 %b) {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb10, %bb bb1: ; preds = %bb10, %bb
%indvars.iv = phi i64 [ %indvars.iv.next, %bb10 ], [ 0, %bb ] %indvars.iv = phi i64 [ %indvars.iv.next, %bb10 ], [ 0, %bb ]
Show All 28 Lines

polly/trunk/test/ScopInfo/phi_condition_modeling_2.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; ;
; void f(int *A, int c, int N) { ; void f(int *A, int c, int N) {
; int tmp; ; int tmp;
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i > c) ; if (i > c)
; tmp = 3; ; tmp = 3;
; else ; else
; tmp = 5; ; tmp = 5;
; A[i] = tmp; ; A[i] = tmp;
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-LABEL: Stmt_bb6 ; CHECK-NEXT: Stmt_bb6
; CHECK-NOT: Access ; CHECK-NEXT: Domain :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: [N, c] -> { Stmt_bb6[i0] : i0 >= 1 + c and i0 >= 0 and i0 <= -1 + N };
; CHECK: [N, c] -> { Stmt_bb6[i0] -> MemRef_tmp_0__phi[] }; ; CHECK-NEXT: Schedule :=
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb6[i0] -> [i0, 1] };
; CHECK-LABEL: Stmt_bb7 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb6[i0] -> MemRef_tmp_0__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Stmt_bb7
; CHECK: [N, c] -> { Stmt_bb7[i0] -> MemRef_tmp_0__phi[] }; ; CHECK-NEXT: Domain :=
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb7[i0] : i0 >= 0 and i0 <= c and i0 <= -1 + N };
; CHECK-LABEL: Stmt_bb8 ; CHECK-NEXT: Schedule :=
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb7[i0] -> [i0, 0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_bb8[i0] -> MemRef_tmp_0__phi[] }; ; CHECK-NEXT: [N, c] -> { Stmt_bb7[i0] -> MemRef_tmp_0__phi[] };
; CHECK-NOT: Access ; CHECK-NEXT: Stmt_bb8
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: Domain :=
; CHECK: [N, c] -> { Stmt_bb8[i0] -> MemRef_tmp_0[] }; ; CHECK-NEXT: [N, c] -> { Stmt_bb8[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK-NOT: Access ; CHECK-NEXT: Schedule :=
; CHECK-LABEL: Stmt_bb8b ; CHECK-NEXT: [N, c] -> { Stmt_bb8[i0] -> [i0, 2] };
; CHECK-NOT: Access ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: [N, c] -> { Stmt_bb8[i0] -> MemRef_tmp_0__phi[] };
; CHECK: [N, c] -> { Stmt_bb8b[i0] -> MemRef_tmp_0[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb8[i0] -> MemRef_tmp_0[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: Stmt_bb8b
; CHECK: [N, c] -> { Stmt_bb8b[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: Domain :=
; CHECK-NOT: Access ; CHECK-NEXT: [N, c] -> { Stmt_bb8b[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: } ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_bb8b[i0] -> [i0, 3] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_bb8b[i0] -> MemRef_tmp_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, c] -> { Stmt_bb8b[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %c, i32 %N) { define void @f(i32* %A, i32 %c, i32 %N) {
bb: bb:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
%tmp1 = sext i32 %c to i64 %tmp1 = sext i32 %c to i64
br label %bb2 br label %bb2
Show All 32 Lines

polly/trunk/test/ScopInfo/phi_loop_carried_float.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; float f(float *A, int N) { ; float f(float *A, int N) {
; float tmp = 0; ; float tmp = 0;
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; tmp += A[i]; ; tmp += A[i];
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-LABEL: Stmt_bb1 ; CHECK-NEXT: Stmt_bb1
; CHECK-NOT: Access ; CHECK-NEXT: Domain :=
; CHECK: ReadAccess := [Reduction Type: NONE] ; CHECK-NEXT: [N] -> { Stmt_bb1[i0] : i0 >= 0 and i0 <= N; Stmt_bb1[0] : N <= -1 };
; CHECK: [N] -> { Stmt_bb1[i0] -> MemRef_tmp_0__phi[] }; ; CHECK-NEXT: Schedule :=
; CHECK-NOT: Access ; CHECK-NEXT: [N] -> { Stmt_bb1[i0] -> [i0, 0] : i0 <= N; Stmt_bb1[0] -> [0, 0] : N <= -1 };
; CHECK: MustWriteAccess := [Reduction Type: NONE] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_bb1[i0] -> MemRef_tmp_0[] }; ; CHECK-NEXT: [N] -> { Stmt_bb1[i0] -> MemRef_tmp_0__phi[] };
; CHECK-NOT: Access ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-LABEL: Stmt_bb4 ; CHECK-NEXT: [N] -> { Stmt_bb1[i0] -> MemRef_tmp_0[] };
; CHECK-NOT: Access ; CHECK-NEXT: Stmt_bb4
; CHECK: MustWriteAccess := [Reduction Type: NONE] ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_bb4[i0] -> MemRef_tmp_0__phi[] }; ; CHECK-NEXT: [N] -> { Stmt_bb4[i0] : i0 <= -1 + N and i0 >= 0 };
; CHECK-NOT: Access ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] ; CHECK-NEXT: [N] -> { Stmt_bb4[i0] -> [i0, 1] };
; CHECK: [N] -> { Stmt_bb4[i0] -> MemRef_tmp_0[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: Access ; CHECK-NEXT: [N] -> { Stmt_bb4[i0] -> MemRef_tmp_0__phi[] };
; CHECK: ReadAccess := [Reduction Type: NONE] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_bb4[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: [N] -> { Stmt_bb4[i0] -> MemRef_tmp_0[] };
; CHECK-NOT: Access ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_bb4[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(float* %A, i32 %N) { define void @f(float* %A, i32 %N) {
bb: bb:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %bb1 br label %bb1
bb1: ; preds = %bb4, %bb bb1: ; preds = %bb4, %bb
Show All 21 Lines

polly/trunk/test/ScopInfo/phi_scalar_simple_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; The assumed context should be empty since the <nsw> flags on the IV ; The assumed context should be empty since the <nsw> flags on the IV
; increments already guarantee that there is no wrap in the loop trip ; increments already guarantee that there is no wrap in the loop trip
; count. ; count.
; ;
; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : }
;
; int jd(int *restrict A, int x, int N) { ; int jd(int *restrict A, int x, int N) {
; for (int i = 1; i < N; i++) ; for (int i = 1; i < N; i++)
; for (int j = 3; j < N; j++) ; for (int j = 3; j < N; j++)
; x += A[i]; ; x += A[i];
; return x; ; return x;
; } ; }
; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : }
; ;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_cond
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_cond[i0] : N >= 2 and i0 >= 0 and i0 <= -1 + N; Stmt_for_cond[0] : N <= 1 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_cond[i0] -> [i0, 0, 0, 0] : N >= 2 and i0 <= -1 + N; Stmt_for_cond[0] -> [0, 0, 0, 0] : N <= 1 };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: Stmt_for_body
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : i0 <= -2 + N and i0 >= 0 and N >= 2 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0, 1, 0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: Stmt_for_cond1
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_cond1[i0, i1] : i0 >= 0 and i0 <= -2 + N and i1 >= 0 and i1 <= -3 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_cond1[i0, i1] -> [i0, 2, i1, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1_lcssa__phi[] };
; CHECK-NEXT: Stmt_for_inc
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_inc[i0, i1] : i0 >= 0 and i0 <= -2 + N and i1 >= 0 and i1 <= -4 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_inc[i0, i1] -> [i0, 2, i1, 1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_A[1 + i0] };
; CHECK-NEXT: Stmt_for_end
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_end[i0] : N >= 3 and i0 >= 0 and i0 <= -2 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_end[i0] -> [i0, 3, 0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_end[i0] -> MemRef_x_addr_1_lcssa[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_end[i0] -> MemRef_x_addr_1_lcssa__phi[] };
; CHECK-NEXT: Stmt_for_inc4
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_inc4[i0] : N >= 3 and i0 >= 0 and i0 <= -2 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_inc4[i0] -> [i0, 4, 0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_inc4[i0] -> MemRef_x_addr_1_lcssa[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_inc4[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define i32 @jd(i32* noalias %A, i32 %x, i32 %N) { define i32 @jd(i32* noalias %A, i32 %x, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc4, %entry for.cond: ; preds = %for.inc4, %entry
; CHECK-LABEL: Stmt_for_cond
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
%indvars.iv = phi i64 [ %indvars.iv.next, %for.inc4 ], [ 1, %entry ] %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc4 ], [ 1, %entry ]
%x.addr.0 = phi i32 [ %x, %entry ], [ %x.addr.1.lcssa, %for.inc4 ] %x.addr.0 = phi i32 [ %x, %entry ], [ %x.addr.1.lcssa, %for.inc4 ]
%cmp = icmp slt i64 %indvars.iv, %tmp %cmp = icmp slt i64 %indvars.iv, %tmp
br i1 %cmp, label %for.body, label %for.end6 br i1 %cmp, label %for.body, label %for.end6
for.body: ; preds = %for.cond for.body: ; preds = %for.cond
; CHECK-LABEL: Stmt_for_body
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_x_addr_1__phi[] };
; CHECK-NOT: Access
br label %for.cond1 br label %for.cond1
for.cond1: ; preds = %for.inc, %for.body for.cond1: ; preds = %for.inc, %for.body
; CHECK-LABEL: Stmt_for_cond1
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1_lcssa__phi[] };
; CHECK-NOT: Access
%x.addr.1 = phi i32 [ %x.addr.0, %for.body ], [ %add, %for.inc ] %x.addr.1 = phi i32 [ %x.addr.0, %for.body ], [ %add, %for.inc ]
%j.0 = phi i32 [ 3, %for.body ], [ %inc, %for.inc ] %j.0 = phi i32 [ 3, %for.body ], [ %inc, %for.inc ]
%exitcond = icmp ne i32 %j.0, %N %exitcond = icmp ne i32 %j.0, %N
br i1 %exitcond, label %for.body3, label %for.end br i1 %exitcond, label %for.body3, label %for.end
for.body3: ; preds = %for.cond1 for.body3: ; preds = %for.cond1
br label %for.inc br label %for.inc
for.inc: ; preds = %for.body3 for.inc: ; preds = %for.body3
; CHECK-LABEL: Stmt_for_inc
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N] -> { Stmt_for_inc[i0, i1] -> MemRef_A[1 + i0] };
; CHECK-NOT: Access
%arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
%tmp1 = load i32, i32* %arrayidx, align 4 %tmp1 = load i32, i32* %arrayidx, align 4
%add = add nsw i32 %x.addr.1, %tmp1 %add = add nsw i32 %x.addr.1, %tmp1
%inc = add nsw i32 %j.0, 1 %inc = add nsw i32 %j.0, 1
br label %for.cond1 br label %for.cond1
for.end: ; preds = %for.cond1 for.end: ; preds = %for.cond1
; CHECK-LABEL: Stmt_for_end
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_end[i0] -> MemRef_x_addr_1_lcssa[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_end[i0] -> MemRef_x_addr_1_lcssa__phi[] };
; CHECK-NOT: Access
%x.addr.1.lcssa = phi i32 [ %x.addr.1, %for.cond1 ] %x.addr.1.lcssa = phi i32 [ %x.addr.1, %for.cond1 ]
br label %for.inc4 br label %for.inc4
for.inc4: ; preds = %for.end for.inc4: ; preds = %for.end
; CHECK-LABEL: Stmt_for_inc4
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_inc4[i0] -> MemRef_x_addr_1_lcssa[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N] -> { Stmt_for_inc4[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NOT: Access
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br label %for.cond br label %for.cond
for.end6: ; preds = %for.cond for.end6: ; preds = %for.cond
ret i32 %x.addr.0 ret i32 %x.addr.0
} }

polly/trunk/test/ScopInfo/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; int jd(int *restrict A, int x, int N, int c) { ; int jd(int *restrict A, int x, int N, int c) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; if (i < c) ; if (i < c)
; x += A[i]; ; x += A[i];
; return x; ; return x;
; } ; }
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_cond
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] : i0 >= 0 and i0 <= N; Stmt_for_cond[0] : N <= -1 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] -> [i0, 0, 0, 0] : i0 <= N; Stmt_for_cond[0] -> [0, 0, 0, 0] : N <= -1 };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: Stmt_for_body
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_body[i0] : i0 <= -1 + N and i0 >= 0 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_body[i0] -> [i0, 1, 0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_body[i0] -> MemRef_x_addr_0[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_body[i0] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: Stmt_for_cond1
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] -> [i0, 2, i1, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: Stmt_for_body3
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_body3[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_body3[i0, i1] -> [i0, 2, i1, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_body3[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_body3[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NEXT: Stmt_if_then
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_if_then[i0, i1] : i0 >= 0 and i0 <= -1 + c and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_if_then[i0, i1] -> [i0, 2, i1, 2] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NEXT: Stmt_if_end
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_if_end[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_if_end[i0, i1] -> [i0, 2, i1, 3] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_if_end[i0, i1] -> MemRef_x_addr_2[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_if_end[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NEXT: Stmt_for_inc
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_inc[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_inc[i0, i1] -> [i0, 2, i1, 4] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_2[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NEXT: Stmt_for_inc5
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N, c] -> { Stmt_for_inc5[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N, c] -> { Stmt_for_inc5[i0] -> [i0, 3, 0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_inc5[i0] -> MemRef_x_addr_1[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N, c] -> { Stmt_for_inc5[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define i32 @jd(i32* noalias %A, i32 %x, i32 %N, i32 %c) { define i32 @jd(i32* noalias %A, i32 %x, i32 %N, i32 %c) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
%tmp1 = sext i32 %c to i64 %tmp1 = sext i32 %c to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc5, %entry for.cond: ; preds = %for.inc5, %entry
; CHECK-LABEL: Stmt_for_cond
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0__phi[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N, c] -> { Stmt_for_cond[i0] -> MemRef_A[i0] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
%indvars.iv = phi i64 [ %indvars.iv.next, %for.inc5 ], [ 0, %entry ] %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc5 ], [ 0, %entry ]
%x.addr.0 = phi i32 [ %x, %entry ], [ %x.addr.1, %for.inc5 ] %x.addr.0 = phi i32 [ %x, %entry ], [ %x.addr.1, %for.inc5 ]
%arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
store i32 %x.addr.0, i32* %arrayidx2 store i32 %x.addr.0, i32* %arrayidx2
%cmp = icmp slt i64 %indvars.iv, %tmp %cmp = icmp slt i64 %indvars.iv, %tmp
br i1 %cmp, label %for.body, label %for.end7 br i1 %cmp, label %for.body, label %for.end7
for.body: ; preds = %for.cond for.body: ; preds = %for.cond
; CHECK-LABEL: Stmt_for_body
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_body[i0] -> MemRef_x_addr_0[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_body[i0] -> MemRef_x_addr_1__phi[] };
; CHECK-NOT: Access
br label %for.cond1 br label %for.cond1
for.cond1: ; preds = %for.inc, %for.body for.cond1: ; preds = %for.inc, %for.body
; CHECK-LABEL: Stmt_for_cond1
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1__phi[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_cond1[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
%x.addr.1 = phi i32 [ %x.addr.0, %for.body ], [ %x.addr.2, %for.inc ] %x.addr.1 = phi i32 [ %x.addr.0, %for.body ], [ %x.addr.2, %for.inc ]
%j.0 = phi i32 [ 0, %for.body ], [ %inc, %for.inc ] %j.0 = phi i32 [ 0, %for.body ], [ %inc, %for.inc ]
%exitcond = icmp ne i32 %j.0, %N %exitcond = icmp ne i32 %j.0, %N
br i1 %exitcond, label %for.body3, label %for.end br i1 %exitcond, label %for.body3, label %for.end
for.body3: ; preds = %for.cond1 for.body3: ; preds = %for.cond1
; CHECK-LABEL: Stmt_for_body3
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_body3[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_body3[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NOT: Access
%cmp4 = icmp slt i64 %indvars.iv, %tmp1 %cmp4 = icmp slt i64 %indvars.iv, %tmp1
br i1 %cmp4, label %if.then, label %if.end br i1 %cmp4, label %if.then, label %if.end
if.then: ; preds = %for.body3 if.then: ; preds = %for.body3
; CHECK-LABEL: Stmt_if_then
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_x_addr_1[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_A[i0] };
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_if_then[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NOT: Access
%arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
%tmp2 = load i32, i32* %arrayidx, align 4 %tmp2 = load i32, i32* %arrayidx, align 4
%add = add nsw i32 %x.addr.1, %tmp2 %add = add nsw i32 %x.addr.1, %tmp2
br label %if.end br label %if.end
if.end: ; preds = %if.then, %for.body3 if.end: ; preds = %if.then, %for.body3
; CHECK-LABEL: Stmt_if_end
; CHECK-NOT: Access
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_if_end[i0, i1] -> MemRef_x_addr_2[] };
; CHECK-NOT: Access
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_if_end[i0, i1] -> MemRef_x_addr_2__phi[] };
; CHECK-NOT: Access
%x.addr.2 = phi i32 [ %add, %if.then ], [ %x.addr.1, %for.body3 ] %x.addr.2 = phi i32 [ %add, %if.then ], [ %x.addr.1, %for.body3 ]
br label %for.inc br label %for.inc
for.inc: ; preds = %if.end for.inc: ; preds = %if.end
; CHECK-LABEL: Stmt_for_inc
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_2[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_inc[i0, i1] -> MemRef_x_addr_1__phi[] };
%inc = add nsw i32 %j.0, 1 %inc = add nsw i32 %j.0, 1
br label %for.cond1 br label %for.cond1
for.end: ; preds = %for.cond1 for.end: ; preds = %for.cond1
br label %for.inc5 br label %for.inc5
for.inc5: ; preds = %for.end for.inc5: ; preds = %for.end
; CHECK-LABEL: Stmt_for_inc5
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_inc5[i0] -> MemRef_x_addr_1[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [N, c] -> { Stmt_for_inc5[i0] -> MemRef_x_addr_0__phi[] };
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br label %for.cond br label %for.cond
for.end7: ; preds = %for.cond for.end7: ; preds = %for.cond
ret i32 %x.addr.0 ret i32 %x.addr.0
} }

polly/trunk/test/ScopInfo/pointer-used-as-base-pointer-and-scalar-read.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; In this test case we pass a pointer %A into a PHI node and also use this ; In this test case we pass a pointer %A into a PHI node and also use this
; pointer as base pointer of an array store. As a result, we get both scalar ; pointer as base pointer of an array store. As a result, we get both scalar
; and array memory accesses to A[] and A[0]. ; and array memory accesses to A[] and A[0].
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK: float MemRef_A[*]; // Element size 4 ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
; CHECK: float* MemRef_A; // Element size 8 ; CHECK-NEXT: float* MemRef_A; // Element size 8
; CHECK: float* MemRef_x__phi; // Element size 8 ; CHECK-NEXT: float* MemRef_x__phi; // Element size 8
; CHECK: float* MemRef_B; // Element size 8 ; CHECK-NEXT: float* MemRef_B; // Element size 8
; CHECK: float* MemRef_C[*]; // Element size 8 ; CHECK-NEXT: float* MemRef_C[*]; // Element size 8
; CHECK: } ; CHECK-NEXT: }
; CHECK: Arrays (Bounds as pw_affs) { ; CHECK: Arrays (Bounds as pw_affs) {
; CHECK: float MemRef_A[*]; // Element size 4 ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
; CHECK: float* MemRef_A; // Element size 8 ; CHECK-NEXT: float* MemRef_A; // Element size 8
; CHECK: float* MemRef_x__phi; // Element size 8 ; CHECK-NEXT: float* MemRef_x__phi; // Element size 8
; CHECK: float* MemRef_B; // Element size 8 ; CHECK-NEXT: float* MemRef_B; // Element size 8
; CHECK: float* MemRef_C[*]; // Element size 8 ; CHECK-NEXT: float* MemRef_C[*]; // Element size 8
; CHECK: } ; CHECK-NEXT: }
; CHECK: Alias Groups (0): ; CHECK: Alias Groups (0):
; CHECK: n/a ; CHECK-NEXT: n/a
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_then ; CHECK-NEXT: Stmt_then
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [p] -> { Stmt_then[i0] : p = 32 and i0 <= 999 and i0 >= 0 }; ; CHECK-NEXT: [p] -> { Stmt_then[i0] : p = 32 and i0 <= 999 and i0 >= 0 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [p] -> { Stmt_then[i0] -> [i0, 1] }; ; CHECK-NEXT: [p] -> { Stmt_then[i0] -> [i0, 1] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [p] -> { Stmt_then[i0] -> MemRef_A[0] }; ; CHECK-NEXT: [p] -> { Stmt_then[i0] -> MemRef_A[0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [p] -> { Stmt_then[i0] -> MemRef_A[] }; ; CHECK-NEXT: [p] -> { Stmt_then[i0] -> MemRef_A[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [p] -> { Stmt_then[i0] -> MemRef_x__phi[] }; ; CHECK-NEXT: [p] -> { Stmt_then[i0] -> MemRef_x__phi[] };
; CHECK: Stmt_else ; CHECK-NEXT: Stmt_else
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [p] -> { Stmt_else[i0] : (p >= 33 and i0 <= 999 and i0 >= 0) or (p <= 31 and i0 <= 999 and i0 >= 0) }; ; CHECK-NEXT: [p] -> { Stmt_else[i0] : (p >= 33 and i0 <= 999 and i0 >= 0) or (p <= 31 and i0 <= 999 and i0 >= 0) };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [p] -> { Stmt_else[i0] -> [i0, 0] : p >= 33 or p <= 31 }; ; CHECK-NEXT: [p] -> { Stmt_else[i0] -> [i0, 0] : p >= 33 or p <= 31 };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [p] -> { Stmt_else[i0] -> MemRef_A[0] }; ; CHECK-NEXT: [p] -> { Stmt_else[i0] -> MemRef_A[0] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [p] -> { Stmt_else[i0] -> MemRef_B[] }; ; CHECK-NEXT: [p] -> { Stmt_else[i0] -> MemRef_B[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [p] -> { Stmt_else[i0] -> MemRef_x__phi[] }; ; CHECK-NEXT: [p] -> { Stmt_else[i0] -> MemRef_x__phi[] };
; CHECK: Stmt_bb8 ; CHECK-NEXT: Stmt_bb8
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [p] -> { Stmt_bb8[i0] : (p >= 33 and i0 <= 999 and i0 >= 0) or (p <= 32 and i0 <= 999 and i0 >= 0) }; ; CHECK-NEXT: [p] -> { Stmt_bb8[i0] : (p >= 33 and i0 <= 999 and i0 >= 0) or (p <= 32 and i0 <= 999 and i0 >= 0) };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [p] -> { Stmt_bb8[i0] -> [i0, 2] }; ; CHECK-NEXT: [p] -> { Stmt_bb8[i0] -> [i0, 2] };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: [p] -> { Stmt_bb8[i0] -> MemRef_x__phi[] }; ; CHECK-NEXT: [p] -> { Stmt_bb8[i0] -> MemRef_x__phi[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [p] -> { Stmt_bb8[i0] -> MemRef_C[0] }; ; CHECK-NEXT: [p] -> { Stmt_bb8[i0] -> MemRef_C[0] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(float* noalias %A, float* noalias %B, float ** noalias %C, i32 %p) { define void @foo(float* noalias %A, float* noalias %B, float ** noalias %C, i32 %p) {
bb: bb:
br label %bb1 br label %bb1
bb1: bb1:
Show All 25 Lines

polly/trunk/test/ScopInfo/read-only-scalar-used-in-phi.ll

; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -analyze -polly-scops \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; float foo(float sum, float A[]) { ; float foo(float sum, float A[]) {
; ;
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; sum += A[i]; ; sum += A[i];
; ;
; return sum; ; return sum;
; } ; }
; CHECK: Stmt_next ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_next
; CHECK: { Stmt_next[] }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: { Stmt_next[] };
; CHECK: { Stmt_next[] -> [0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_next[] -> [0, 0] };
; CHECK: { Stmt_next[] -> MemRef_sum[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_next[] -> MemRef_sum[] };
; CHECK: { Stmt_next[] -> MemRef_phisum__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_bb1 ; CHECK-NEXT: { Stmt_next[] -> MemRef_phisum__phi[] };
; CHECK: Domain := ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: { Stmt_bb1[i0] : i0 <= 100 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_next[] -> MemRef_phisummerge[] };
; CHECK: Schedule := ; CHECK-NEXT: Stmt_bb1
; CHECK: { Stmt_bb1[i0] -> [1, i0] }; ; CHECK-NEXT: Domain :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb1[i0] : i0 <= 100 and i0 >= 0 };
; CHECK: { Stmt_bb1[i0] -> MemRef_phisum__phi[] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: { Stmt_bb1[i0] -> [1, i0] };
; CHECK: { Stmt_bb1[i0] -> MemRef_phisum__phi[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_phisum__phi[] };
; CHECK: { Stmt_bb1[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_phisum__phi[] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_phisummerge[] };
; CHECK-NEXT: }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define float @foo(float %sum, float* %A) { define float @foo(float %sum, float* %A) {
bb: bb:
br label %next br label %next
next: next:
Show All 16 Lines

polly/trunk/test/ScopInfo/read-only-statements.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check we remove read only statements. ; Check we remove read only statements.
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body_2 ; CHECK-NEXT: Stmt_for_body_2
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body_2[i0] : i0 <= 99 and i0 >= 0 }; ; CHECK-NEXT: { Stmt_for_body_2[i0] : i0 <= 99 and i0 >= 0 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_for_body_2[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_for_body_2[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body_2[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_for_body_2[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: { Stmt_for_body_2[i0] -> MemRef_A[i0] }; ; CHECK-NEXT: { Stmt_for_body_2[i0] -> MemRef_A[i0] };
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; int g(int); ; int g(int);
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 100; i++) { ; for (int i = 0; i < 100; i++) {
; (A[i]); ; (A[i]);
; /* Split BB */ ; /* Split BB */
; (A[i]); ; (A[i]);
; /* Split BB */ ; /* Split BB */
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/remarks.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: remark: test/ScopInfo/remarks.c:4:7: SCoP begins here. ; CHECK: remark: test/ScopInfo/remarks.c:4:7: SCoP begins here.
; CHECK: remark: test/ScopInfo/remarks.c:8:5: Finite loop assumption: [M, N, Debug] -> { : M >= 0 or (M <= -2 and N <= 0) or (M = -1 and N <= 0) } ; CHECK: remark: test/ScopInfo/remarks.c:8:5: Finite loop assumption: [M, N, Debug] -> { : M >= 0 or (M <= -2 and N <= 0) or (M = -1 and N <= 0) }
; CHECK: remark: test/ScopInfo/remarks.c:13:7: No-error assumption: [M, N, Debug] -> { : M <= -1 or (M >= 0 and N <= 0) or (Debug = 0 and M >= 0 and N >= 1) } ; CHECK: remark: test/ScopInfo/remarks.c:13:7: No-error assumption: [M, N, Debug] -> { : M <= -1 or (M >= 0 and N <= 0) or (Debug = 0 and M >= 0 and N >= 1) }
; CHECK: remark: test/ScopInfo/remarks.c:9:7: Inbounds assumption: [M, N, Debug] -> { : M <= 100 or (M >= 1 and N <= 0) } ; CHECK: remark: test/ScopInfo/remarks.c:9:7: Inbounds assumption: [M, N, Debug] -> { : M <= 100 or (M >= 1 and N <= 0) }
; CHECK: remark: <unknown>:0:0: No-overflows assumption: [N, M, Debug] -> { : M <= 2147483647 - N and M >= -2147483648 - N } ; CHECK: remark: <unknown>:0:0: No-overflows assumption: [N, M, Debug] -> { : M <= 2147483647 - N and M >= -2147483648 - N }
; CHECK: remark: test/ScopInfo/remarks.c:9:18: Possibly aliasing pointer, use restrict keyword. ; CHECK: remark: test/ScopInfo/remarks.c:9:18: Possibly aliasing pointer, use restrict keyword.
; CHECK: remark: test/ScopInfo/remarks.c:9:33: Possibly aliasing pointer, use restrict keyword. ; CHECK: remark: test/ScopInfo/remarks.c:9:33: Possibly aliasing pointer, use restrict keyword.
; CHECK: remark: test/ScopInfo/remarks.c:9:15: Possibly aliasing pointer, use restrict keyword. ; CHECK: remark: test/ScopInfo/remarks.c:9:15: Possibly aliasing pointer, use restrict keyword.
; CHECK: remark: test/ScopInfo/remarks.c:14:3: SCoP ends here. ; CHECK: remark: test/ScopInfo/remarks.c:14:3: SCoP ends here.
; CHECK: remark: test/ScopInfo/remarks.c:19:3: SCoP begins here. ; CHECK: remark: test/ScopInfo/remarks.c:19:3: SCoP begins here.
; CHECK: remark: test/ScopInfo/remarks.c:21:11: Invariant load assumption: [tmp] -> { : 1 = 0 } ; CHECK: remark: test/ScopInfo/remarks.c:21:11: Invariant load assumption: [tmp] -> { : 1 = 0 }
; CHECK: remark: test/ScopInfo/remarks.c:22:16: SCoP ends here but was dismissed. ; CHECK: remark: test/ScopInfo/remarks.c:22:16: SCoP ends here but was dismissed.
; ;
; #include <stdio.h> ; #include <stdio.h>
; ;
; void valid(int *A, int *B, int N, int M, int C[100][100], int Debug) { ; void valid(int *A, int *B, int N, int M, int C[100][100], int Debug) {
; if (N + M == -1) ; if (N + M == -1)
; C[0][0] = 0; ; C[0][0] = 0;
; ;
▲ Show 20 Lines • Show All 296 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/scalar.ll

Show All 23 Linesfor.backedge:
%indvar.next = add nsw i64 %indvar, 1 %indvar.next = add nsw i64 %indvar, 1
%exitcond = icmp eq i64 %indvar.next, %N %exitcond = icmp eq i64 %indvar.next, %N
br i1 %exitcond, label %return, label %for br i1 %exitcond, label %return, label %for
return: return:
ret void ret void
} }
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK: i64 MemRef_a[*]; ; CHECK-NEXT: i64 MemRef_a[*]; // Element size 8
; CHECK: i64 MemRef_val; [BasePtrOrigin: MemRef_a] ; CHECK-NEXT: i64 MemRef_val; [BasePtrOrigin: MemRef_a] // Element size 8
; CHECK: } ; CHECK-NEXT: }
; ;
; CHECK: Arrays (Bounds as pw_affs) { ; CHECK: Arrays (Bounds as pw_affs) {
; CHECK: i64 MemRef_a[*]; ; CHECK-NEXT: i64 MemRef_a[*]; // Element size 8
; CHECK: i64 MemRef_val; [BasePtrOrigin: MemRef_a] ; CHECK-NEXT: i64 MemRef_val; [BasePtrOrigin: MemRef_a] // Element size 8
; CHECK: } ; CHECK-NEXT: }
;
; CHECK: Stmt_S1 ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_S1
; CHECK: [N] -> { Stmt_S1[i0] : i0 >= 0 and i0 <= -1 + N }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_S1[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: [N] -> { Stmt_S1[i0] -> [i0, 0] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := ; CHECK-NEXT: [N] -> { Stmt_S1[i0] -> [i0, 0] };
; CHECK: [N] -> { Stmt_S1[i0] -> MemRef_a[i0] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MustWriteAccess := ; CHECK-NEXT: [N] -> { Stmt_S1[i0] -> MemRef_a[i0] };
; CHECK: [N] -> { Stmt_S1[i0] -> MemRef_val[] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: Stmt_S2 ; CHECK-NEXT: [N] -> { Stmt_S1[i0] -> MemRef_val[] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_S2
; CHECK: [N] -> { Stmt_S2[i0] : i0 >= 0 and i0 <= -1 + N }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_S2[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: [N] -> { Stmt_S2[i0] -> [i0, 1] }; ; CHECK-NEXT: Schedule :=
; CHECK: ReadAccess := ; CHECK-NEXT: [N] -> { Stmt_S2[i0] -> [i0, 1] };
; CHECK: [N] -> { Stmt_S2[i0] -> MemRef_val[] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK: MustWriteAccess := ; CHECK-NEXT: [N] -> { Stmt_S2[i0] -> MemRef_val[] };
; CHECK: [N] -> { Stmt_S2[i0] -> MemRef_a[i0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_S2[i0] -> MemRef_a[i0] };
; CHECK-NEXT: }

polly/trunk/test/ScopInfo/simple_loop_1.ll

Show All 18 Linesbb: ; preds = %bb, %entry
%i.inc = add nsw i64 %i, 1 %i.inc = add nsw i64 %i, 1
%exitcond = icmp eq i64 %i.inc, %N %exitcond = icmp eq i64 %i.inc, %N
br i1 %exitcond, label %return, label %bb br i1 %exitcond, label %return, label %bb
return: ; preds = %bb, %entry return: ; preds = %bb, %entry
ret void ret void
} }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK: { : } ; CHECK-NEXT: [N] -> { : }
;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK: i64 MemRef_a[*]; // Element size 8 ; CHECK-NEXT: i64 MemRef_a[*]; // Element size 8
; CHECK: } ; CHECK-NEXT: }
;
; CHECK: Stmt_bb ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_bb
; CHECK: [N] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -1 + N }; ; CHECK-NEXT: Domain :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_bb[i0] : i0 >= 0 and i0 <= -1 + N };
; CHECK: [N] -> { Stmt_bb[i0] -> [i0] }; ; CHECK-NEXT: Schedule :=
; CHECK: MustWriteAccess := [Reduction Type: NONE] ; CHECK-NEXT: [N] -> { Stmt_bb[i0] -> [i0] };
; CHECK: [N] -> { Stmt_bb[i0] -> MemRef_a[i0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_bb[i0] -> MemRef_a[i0] };
; CHECK-NEXT: }

polly/trunk/test/ScopInfo/switch-1.ll

Show All 11 Lines
; case 2: ; case 2:
; A[i] += 2; ; A[i] += 2;
; break; ; break;
; case 3: ; case 3:
; A[i] += 3; ; A[i] += 3;
; break; ; break;
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_sw_bb_1 ; CHECK-NEXT: Stmt_sw_bb_1
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((-1 + i0)/4): 4e0 = -1 + i0 and i0 >= 1 and i0 <= -1 + N) }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((-1 + i0)/4): 4e0 = -1 + i0 and i0 >= 1 and i0 <= -1 + N) };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 2] }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 2] };
; CHECK: Stmt_sw_bb_2 ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_2[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_2[i0] -> [i0, 1] }; ; CHECK-NEXT: Stmt_sw_bb_2
; CHECK: Stmt_sw_bb_6 ; CHECK-NEXT: Domain :=
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) };
; CHECK: [N] -> { Stmt_sw_bb_6[i0] : exists (e0 = floor((-3 + i0)/4): 4e0 = -3 + i0 and i0 >= 0 and i0 <= -1 + N) }; ; CHECK-NEXT: Schedule :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> [i0, 1] };
; CHECK: [N] -> { Stmt_sw_bb_6[i0] -> [i0, 0] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> MemRef_A[i0] };
; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_sw_bb_6
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_6[i0] : exists (e0 = floor((-3 + i0)/4): 4e0 = -3 + i0 and i0 >= 0 and i0 <= -1 + N) };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_6[i0] -> [i0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_6[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_6[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: { ; AST: {
; AST: for (int c0 = 1; c0 < N - 2; c0 += 4) { ; AST-NEXT: for (int c0 = 1; c0 < N - 2; c0 += 4) {
; AST: Stmt_sw_bb_1(c0); ; AST-NEXT: Stmt_sw_bb_1(c0);
; AST: Stmt_sw_bb_2(c0 + 1); ; AST-NEXT: Stmt_sw_bb_2(c0 + 1);
; AST: Stmt_sw_bb_6(c0 + 2); ; AST-NEXT: Stmt_sw_bb_6(c0 + 2);
; AST: } ; AST-NEXT: }
; AST: if (N >= 2) ; AST-NEXT: if (N >= 2)
; AST: if (N % 4 >= 2) { ; AST-NEXT: if (N % 4 >= 2) {
; AST: Stmt_sw_bb_1(-(N % 4) + N + 1); ; AST-NEXT: Stmt_sw_bb_1(-(N % 4) + N + 1);
; AST: if ((N - 3) % 4 == 0) ; AST-NEXT: if ((N - 3) % 4 == 0)
; AST: Stmt_sw_bb_2(N - 1); ; AST-NEXT: Stmt_sw_bb_2(N - 1);
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; ;
; AST: else
; AST-NEXT: { /* original code */ }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %N) { define void @f(i32* %A, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/switch-2.ll

Show All 10 Lines
; break; ; break;
; case 2: ; case 2:
; A[i] += 2; ; A[i] += 2;
; break; ; break;
; case 3: ; case 3:
; break; ; break;
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NOT: Stmt_sw_bb1 ; CHECK-NEXT: Stmt_sw_bb
; CHECK: Stmt_sw_bb ; CHECK-NEXT: Domain :=
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) };
; CHECK: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) }; ; CHECK-NEXT: Schedule :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> [i0, 1] };
; CHECK: [N] -> { Stmt_sw_bb[i0] -> [i0, 1] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NOT: Stmt_sw_bb1 ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: Stmt_sw_bb_2 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_2[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) }; ; CHECK-NEXT: Stmt_sw_bb_2
; CHECK: Schedule := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb_2[i0] -> [i0, 0] }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) };
; CHECK-NOT: Stmt_sw_bb1 ; CHECK-NEXT: Schedule :=
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> [i0, 0] };
; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_2[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: for (int c0 = 0; c0 < N; c0 += 4) { ; AST: for (int c0 = 0; c0 < N; c0 += 4) {
; AST: Stmt_sw_bb(c0); ; AST-NEXT: Stmt_sw_bb(c0);
; AST: if (N >= c0 + 3) ; AST-NEXT: if (N >= c0 + 3)
; AST: Stmt_sw_bb_2(c0 + 2); ; AST-NEXT: Stmt_sw_bb_2(c0 + 2);
; AST: } ; AST-NEXT: }
; ;
; AST: else ; AST: else
; AST: { /* original code */ } ; AST-NEXT: { /* original code */ }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %N) { define void @f(i32* %A, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/switch-3.ll

Show All 10 Lines
; break; ; break;
; case 2: ; case 2:
; A[i] += 3; ; A[i] += 3;
; case 3: ; case 3:
; A[i] += 4; ; A[i] += 4;
; break; ; break;
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_sw_bb ; CHECK-NEXT: Stmt_sw_bb
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_sw_bb[i0] -> [i0, 2] }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> [i0, 2] };
; CHECK: Stmt_sw_bb_1 ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((2 + i0)/4): i0 >= 0 and i0 <= -1 + N and 4e0 >= -1 + i0 and 4e0 <= i0) }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 3] }; ; CHECK-NEXT: Stmt_sw_bb_1
; CHECK: Stmt_sw_bb_5 ; CHECK-NEXT: Domain :=
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((2 + i0)/4): i0 >= 0 and i0 <= -1 + N and 4e0 >= -1 + i0 and 4e0 <= i0) };
; CHECK: [N] -> { Stmt_sw_bb_5[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) }; ; CHECK-NEXT: Schedule :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 3] };
; CHECK: [N] -> { Stmt_sw_bb_5[i0] -> [i0, 0] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Stmt_sw_bb_9 ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: Domain := ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: [N] -> { Stmt_sw_bb_9[i0] : exists (e0 = floor((i0)/4): i0 >= 0 and i0 <= -1 + N and 4e0 >= -3 + i0 and 4e0 <= -2 + i0) }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: Schedule := ; CHECK-NEXT: Stmt_sw_bb_5
; CHECK: [N] -> { Stmt_sw_bb_9[i0] -> [i0, 1] }; ; CHECK-NEXT: Domain :=
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) };
; ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> [i0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_sw_bb_9
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] : exists (e0 = floor((i0)/4): i0 >= 0 and i0 <= -1 + N and 4e0 >= -3 + i0 and 4e0 <= -2 + i0) };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> [i0, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: for (int c0 = 0; c0 < N; c0 += 1) { ; AST: for (int c0 = 0; c0 < N; c0 += 1) {
; AST: if ((c0 - 2) % 4 == 0) ; AST-NEXT: if ((c0 - 2) % 4 == 0)
; AST: Stmt_sw_bb_5(c0); ; AST-NEXT: Stmt_sw_bb_5(c0);
; AST: if (c0 % 4 >= 2) { ; AST-NEXT: if (c0 % 4 >= 2) {
; AST: Stmt_sw_bb_9(c0); ; AST-NEXT: Stmt_sw_bb_9(c0);
; AST: } else { ; AST-NEXT: } else {
; AST: if (c0 % 4 == 0) ; AST-NEXT: if (c0 % 4 == 0)
; AST: Stmt_sw_bb(c0); ; AST-NEXT: Stmt_sw_bb(c0);
; AST: Stmt_sw_bb_1(c0); ; AST-NEXT: Stmt_sw_bb_1(c0);
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; ;
; AST: else ; AST: else
; AST: { /* original code */ } ; AST-NEXT: { /* original code */ }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %N) { define void @f(i32* %A, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/switch-4.ll

Show All 14 Lines
; break; ; break;
; case 3: ; case 3:
; A[i] += 4; ; A[i] += 4;
; break; ; break;
; default: ; default:
; A[i - 1] += A[i + 1]; ; A[i - 1] += A[i + 1];
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NOT: Stmt_sw_default ; CHECK-NEXT: Stmt_sw_bb
; CHECK: Stmt_sw_bb ; CHECK-NEXT: Domain :=
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) };
; CHECK: [N] -> { Stmt_sw_bb[i0] : exists (e0 = floor((i0)/4): 4e0 = i0 and i0 >= 0 and i0 <= -1 + N) }; ; CHECK-NEXT: Schedule :=
; CHECK: Schedule := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> [i0, 3] };
; CHECK: [N] -> { Stmt_sw_bb[i0] -> [i0, 3] }; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Stmt_sw_bb_1 ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: Domain := ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((-1 + i0)/4): 4e0 = -1 + i0 and i0 >= 1 and i0 <= -1 + N) }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[i0] };
; CHECK: Schedule := ; CHECK-NEXT: Stmt_sw_bb_1
; CHECK: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 2] }; ; CHECK-NEXT: Domain :=
; CHECK: Stmt_sw_bb_5 ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] : exists (e0 = floor((-1 + i0)/4): 4e0 = -1 + i0 and i0 >= 1 and i0 <= -1 + N) };
; CHECK: Domain := ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_sw_bb_5[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> [i0, 2] };
; CHECK: Schedule := ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: [N] -> { Stmt_sw_bb_5[i0] -> [i0, 1] }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: Stmt_sw_bb_9 ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[i0] };
; CHECK: [N] -> { Stmt_sw_bb_9[i0] : exists (e0 = floor((-3 + i0)/4): 4e0 = -3 + i0 and i0 >= 0 and i0 <= -1 + N) }; ; CHECK-NEXT: Stmt_sw_bb_5
; CHECK: Schedule := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb_9[i0] -> [i0, 0] }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] : exists (e0 = floor((-2 + i0)/4): 4e0 = -2 + i0 and i0 >= 2 and i0 <= -1 + N) };
; CHECK: } ; CHECK-NEXT: Schedule :=
; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> [i0, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[i0] };
; CHECK-NEXT: Stmt_sw_bb_9
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] : exists (e0 = floor((-3 + i0)/4): 4e0 = -3 + i0 and i0 >= 0 and i0 <= -1 + N) };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> [i0, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[i0] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: { ; AST: {
; AST: for (int c0 = 0; c0 < N - 3; c0 += 4) { ; AST-NEXT: for (int c0 = 0; c0 < N - 3; c0 += 4) {
; AST: Stmt_sw_bb(c0); ; AST-NEXT: Stmt_sw_bb(c0);
; AST: Stmt_sw_bb_1(c0 + 1); ; AST-NEXT: Stmt_sw_bb_1(c0 + 1);
; AST: Stmt_sw_bb_5(c0 + 2); ; AST-NEXT: Stmt_sw_bb_5(c0 + 2);
; AST: Stmt_sw_bb_9(c0 + 3); ; AST-NEXT: Stmt_sw_bb_9(c0 + 3);
; AST: } ; AST-NEXT: }
; AST: if (N >= 1) ; AST-NEXT: if (N >= 1)
; AST: if (N % 4 >= 1) { ; AST-NEXT: if (N % 4 >= 1) {
; AST: Stmt_sw_bb(-((N - 1) % 4) + N - 1); ; AST-NEXT: Stmt_sw_bb(-((N - 1) % 4) + N - 1);
; AST: if (N % 4 >= 2) { ; AST-NEXT: if (N % 4 >= 2) {
; AST: Stmt_sw_bb_1(-((N - 1) % 4) + N); ; AST-NEXT: Stmt_sw_bb_1(-((N - 1) % 4) + N);
; AST: if ((N - 3) % 4 == 0) ; AST-NEXT: if ((N - 3) % 4 == 0)
; AST: Stmt_sw_bb_5(N - 1); ; AST-NEXT: Stmt_sw_bb_5(N - 1);
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; ;
; AST: else ; AST: else
; AST: { /* original code */ } ; AST-NEXT: { /* original code */ }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %N) { define void @f(i32* %A, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/switch-5.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int *B, int N) { ; void f(int *A, int *B, int N) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; A[i]++; ; A[i]++;
; switch (N) { ; switch (N) {
; case 0: ; case 0:
; B[i]++; ; B[i]++;
; break; ; break;
; default: ; default:
; return; ; return;
; } ; }
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_for_body[0] : N >= 1 }; ; CHECK-NEXT: [N] -> { Stmt_for_body[0] : N >= 1 };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [N] -> { Stmt_for_body[i0] -> [0] }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [0] };
; CHECK-NOT: Stmt_sw_bb ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_A[0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> MemRef_A[0] };
; CHECK-NEXT: }
; AST: if (1)
; ;
; AST: if (N >= 1) ; AST: if (N >= 1)
; AST: Stmt_for_body(0); ; AST-NEXT: Stmt_for_body(0);
; ;
; AST: else
; AST-NEXT: { /* original code */ }
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32* %B, i32 %N) { define void @f(i32* %A, i32* %B, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
Show All 36 Lines

polly/trunk/test/ScopInfo/switch-6.ll

Show All 14 Lines
; break; ; break;
; case 3: ; case 3:
; A[i] += 4; ; A[i] += 4;
; break; ; break;
; default:; ; default:;
; } ; }
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_sw_bb ; CHECK-NEXT: Stmt_sw_bb
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb[0] : N >= 1 }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb[0] : N >= 1 };
; CHECK: Stmt_sw_bb_1 ; CHECK-NEXT: Schedule :=
; CHECK: Domain := ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> [0, 3] };
; CHECK: [N] -> { Stmt_sw_bb_1[1] : N >= 2 }; ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: Stmt_sw_bb_5 ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[0] };
; CHECK: Domain := ; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK: [N] -> { Stmt_sw_bb_5[2] : N >= 3 }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb[i0] -> MemRef_A[0] };
; CHECK: Stmt_sw_bb_9 ; CHECK-NEXT: Stmt_sw_bb_1
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [N] -> { Stmt_sw_bb_9[3] : N >= 4 }; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[1] : N >= 2 };
; CHECK: } ; CHECK-NEXT: Schedule :=
; ; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> [1, 2] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[1] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_1[i0] -> MemRef_A[1] };
; CHECK-NEXT: Stmt_sw_bb_5
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[2] : N >= 3 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> [2, 1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[2] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_5[i0] -> MemRef_A[2] };
; CHECK-NEXT: Stmt_sw_bb_9
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[3] : N >= 4 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> [3, 0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[3] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_sw_bb_9[i0] -> MemRef_A[3] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: if (N >= 1) { ; AST: if (N >= 1) {
; AST: Stmt_sw_bb(0); ; AST-NEXT: Stmt_sw_bb(0);
; AST: if (N >= 2) { ; AST-NEXT: if (N >= 2) {
; AST: Stmt_sw_bb_1(1); ; AST-NEXT: Stmt_sw_bb_1(1);
; AST: if (N >= 3) { ; AST-NEXT: if (N >= 3) {
; AST: Stmt_sw_bb_5(2); ; AST-NEXT: Stmt_sw_bb_5(2);
; AST: if (N >= 4) ; AST-NEXT: if (N >= 4)
; AST: Stmt_sw_bb_9(3); ; AST-NEXT: Stmt_sw_bb_9(3);
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; AST: } ; AST-NEXT: }
; ;
; AST: else ; AST: else
; AST: { /* original code */ } ; AST-NEXT: { /* original code */ }
;
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %N) { define void @f(i32* %A, i32 %N) {
entry: entry:
%tmp = sext i32 %N to i64 %tmp = sext i32 %N to i64
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/switch-7.ll

Show All 10 Lines
; } ; }
; case 1: { ; case 1: {
; for (int j = 1; j <= N; j++) ; for (int j = 1; j <= N; j++)
; A[j] += A[j - 1]; ; A[j] += A[j - 1];
; break; ; break;
; } ; }
; } ; }
; } ; }
;
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
; CHECK: Domain := ; CHECK-NEXT: Domain :=
; CHECK: [c, N] -> { Stmt_for_body[i0] : c = -1 and i0 >= 0 and i0 <= -1 + N }; ; CHECK-NEXT: [c, N] -> { Stmt_for_body[i0] : c = -1 and i0 >= 0 and i0 <= -1 + N };
; CHECK: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK: [c, N] -> { Stmt_for_body[i0] -> [1, i0] }; ; CHECK-NEXT: [c, N] -> { Stmt_for_body[i0] -> [1, i0] };
; CHECK: Stmt_for_body_7 ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Domain := ; CHECK-NEXT: [c, N] -> { Stmt_for_body[i0] -> MemRef_A[-1 + N - i0] };
; CHECK: [c, N] -> { Stmt_for_body_7[i0] : c = 1 and i0 >= 0 and i0 <= -1 + N }; ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Schedule := ; CHECK-NEXT: [c, N] -> { Stmt_for_body[i0] -> MemRef_A[N - i0] };
; CHECK: [c, N] -> { Stmt_for_body_7[i0] -> [0, i0] }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: } ; CHECK-NEXT: [c, N] -> { Stmt_for_body[i0] -> MemRef_A[N - i0] };
; ; CHECK-NEXT: Stmt_for_body_7
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [c, N] -> { Stmt_for_body_7[i0] : c = 1 and i0 >= 0 and i0 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [c, N] -> { Stmt_for_body_7[i0] -> [0, i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c, N] -> { Stmt_for_body_7[i0] -> MemRef_A[i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c, N] -> { Stmt_for_body_7[i0] -> MemRef_A[1 + i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c, N] -> { Stmt_for_body_7[i0] -> MemRef_A[1 + i0] };
; CHECK-NEXT: }
; AST: if (1) ; AST: if (1)
; ;
; AST: if (c == 1) { ; AST: if (c == 1) {
; AST: for (int c0 = 0; c0 < N; c0 += 1) ; AST-NEXT: for (int c0 = 0; c0 < N; c0 += 1)
; AST: Stmt_for_body_7(c0); ; AST-NEXT: Stmt_for_body_7(c0);
; AST: } else if (c == -1) ; AST-NEXT: } else if (c == -1)
; AST: for (int c0 = 0; c0 < N; c0 += 1) ; AST-NEXT: for (int c0 = 0; c0 < N; c0 += 1)
; AST: Stmt_for_body(c0); ; AST-NEXT: Stmt_for_body(c0);
; ;
; AST: else ; AST: else
; AST: { /* original code */ } ; AST-NEXT: { /* original code */ }
;
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @f(i32* %A, i32 %c, i32 %N) { define void @f(i32* %A, i32 %c, i32 %N) {
entry: entry:
br label %entry.split br label %entry.split
entry.split: entry.split:
switch i32 %c, label %sw.epilog [ switch i32 %c, label %sw.epilog [
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/tempscop-printing.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = init + 2; ; A[i] = init + 2;
; } ; }
; } ; }
; } ; }
; CHECK-LABEL: Function: f
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_j
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
; CHECK-NEXT: }
;
; CHECK-LABEL: Function: g
;
; CHECK: Statements {
; CHECK-NEXT: Stmt_for_j
; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> [i0, i1] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
; CHECK-NEXT: }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
; CHECK-LABEL: Function: f
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_init_ptr[0]
; CHECK-NEXT: Execution Context: [N] -> { : N >= 1 or N <= -1 }
define void @f(i64* noalias %A, i64 %N, i64* noalias %init_ptr) nounwind { define void @f(i64* noalias %A, i64 %N, i64* noalias %init_ptr) nounwind {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ] %indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ]
%indvar.i.next = add nsw i64 %indvar.i, 1 %indvar.i.next = add nsw i64 %indvar.i, 1
br label %entry.next br label %entry.next
entry.next: entry.next:
; CHECK-NOT: Stmt_entry_next
%init = load i64, i64* %init_ptr %init = load i64, i64* %init_ptr
br label %for.j br label %for.j
for.j: for.j:
%indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ] %indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ]
; CHECK: Stmt_for_j
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
%init_plus_two = add i64 %init, 2 %init_plus_two = add i64 %init, 2
%scevgep = getelementptr i64, i64* %A, i64 %indvar.j %scevgep = getelementptr i64, i64* %A, i64 %indvar.j
store i64 %init_plus_two, i64* %scevgep store i64 %init_plus_two, i64* %scevgep
%indvar.j.next = add nsw i64 %indvar.j, 1 %indvar.j.next = add nsw i64 %indvar.j, 1
%exitcond.j = icmp eq i64 %indvar.j.next, %N %exitcond.j = icmp eq i64 %indvar.j.next, %N
br i1 %exitcond.j, label %for.i.end, label %for.j br i1 %exitcond.j, label %for.i.end, label %for.j
for.i.end: for.i.end:
%exitcond.i = icmp eq i64 %indvar.i.next, %N %exitcond.i = icmp eq i64 %indvar.i.next, %N
br i1 %exitcond.i, label %return, label %for.i br i1 %exitcond.i, label %return, label %for.i
return: return:
ret void ret void
} }
; CHECK-LABEL: Function: g
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_init_ptr[0]
; CHECK-NEXT: Execution Context: [N] -> { : N >= 1 or N <= -1 }
define void @g(i64* noalias %A, i64 %N, i64* noalias %init_ptr) nounwind { define void @g(i64* noalias %A, i64 %N, i64* noalias %init_ptr) nounwind {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
%indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ] %indvar.i = phi i64 [ 0, %entry ], [ %indvar.i.next, %for.i.end ]
%indvar.i.next = add nsw i64 %indvar.i, 1 %indvar.i.next = add nsw i64 %indvar.i, 1
br label %entry.next br label %entry.next
entry.next: entry.next:
; CHECK-NOT: Stmt_entry_next
%init = load i64, i64* %init_ptr %init = load i64, i64* %init_ptr
br label %for.j br label %for.j
for.j: for.j:
; CHECK: Stmt_for_j
%indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ] %indvar.j = phi i64 [ 0, %entry.next ], [ %indvar.j.next, %for.j ]
%scevgep = getelementptr i64, i64* %A, i64 %indvar.j %scevgep = getelementptr i64, i64* %A, i64 %indvar.j
store i64 %init, i64* %scevgep store i64 %init, i64* %scevgep
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_init[] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_for_j[i0, i1] -> MemRef_A[i1] };
%indvar.j.next = add nsw i64 %indvar.j, 1 %indvar.j.next = add nsw i64 %indvar.j, 1
%exitcond.j = icmp eq i64 %indvar.j.next, %N %exitcond.j = icmp eq i64 %indvar.j.next, %N
br i1 %exitcond.j, label %for.i.end, label %for.j br i1 %exitcond.j, label %for.i.end, label %for.j
for.i.end: for.i.end:
%exitcond.i = icmp eq i64 %indvar.i.next, %N %exitcond.i = icmp eq i64 %indvar.i.next, %N
br i1 %exitcond.i, label %return, label %for.i br i1 %exitcond.i, label %return, label %for.i
return: return:
ret void ret void
} }

polly/trunk/test/ScopInfo/two-loops-right-after-each-other.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK: Stmt_loop_1 ; CHECK: Statements {
; CHECK: Domain := ; CHECK-NEXT: Stmt_loop_1
; CHECK: [N] -> { Stmt_loop_1[i0] : ; CHECK-NEXT: Domain :=
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] : N <= 100 and i0 <= 101 and i0 >= 0 };
; CHECK-DAG: and ; CHECK-NEXT: Schedule :=
; CHECK-DAG: i0 <= 101 ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] -> [0, i0] };
; CHECK-DAG: and ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: N <= 100 ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] -> MemRef_A[0] };
; CHECK-DAG: }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: Stmt_loop_2 ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] -> MemRef_A[0] };
; CHECK: Domain := ; CHECK-NEXT: Stmt_loop_2
; CHECK: [N] -> { Stmt_loop_2[i0] : ; CHECK-NEXT: Domain :=
; CHECK-DAG: i0 >= 0 ; CHECK-NEXT: [N] -> { Stmt_loop_2[i0] : N <= 100 and i0 <= 301 and i0 >= 0 };
; CHECK-DAG: and ; CHECK-NEXT: Schedule :=
; CHECK-DAG: i0 <= 301 ; CHECK-NEXT: [N] -> { Stmt_loop_2[i0] -> [1, i0] };
; CHECK-DAG: and ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-DAG: N <= 100 ; CHECK-NEXT: [N] -> { Stmt_loop_2[i0] -> MemRef_A[0] };
; CHECK-DAG: }; ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_loop_2[i0] -> MemRef_A[0] };
; CHECK-NEXT: }
define void @foo(float* %A, i64 %N) { define void @foo(float* %A, i64 %N) {
entry: entry:
br label %branch br label %branch
branch: branch:
%cond = icmp sle i64 %N, 100 %cond = icmp sle i64 %N, 100
br i1 %cond, label %loop.1, label %merge br i1 %cond, label %loop.1, label %merge
Show All 25 Lines

polly/trunk/test/ScopInfo/unsigned-condition.ll

Show All 26 Linesbb.backedge:
%i.inc = add nsw i64 %i, 1 %i.inc = add nsw i64 %i, 1
%exitcond = icmp eq i64 %i.inc, %N %exitcond = icmp eq i64 %i.inc, %N
br i1 %exitcond, label %return, label %bb br i1 %exitcond, label %return, label %bb
return: return:
ret void ret void
} }
; CHECK: Assumed Context:
; CHECK: { : }
; CHECK: Stmt_store ; CHECK: Assumed Context:
; CHECK: Domain := ; CHECK-NEXT: [P, N] -> { : }
; CHECK: [P, N] -> { Stmt_store[i0] : ;
; CHECK-DAG: i0 >= 0 ; CHECK: Statements {
; CHECK-DAG: and ; CHECK-NEXT: Stmt_store
; CHECK-DAG: i0 <= -1 + N ; CHECK-NEXT: Domain :=
; CHECK-DAG: and ; CHECK-NEXT: [P, N] -> { Stmt_store[i0] : P >= 42 and i0 >= 0 and i0 <= -1 + N };
; CHECK-DAG: P >= 42 ; CHECK-NEXT: Schedule :=
; CHECK: }; ; CHECK-NEXT: [P, N] -> { Stmt_store[i0] -> [i0] };
; CHECK: Schedule := ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [P, N] -> { Stmt_store[i0] -> [i0] }; ; CHECK-NEXT: [P, N] -> { Stmt_store[i0] -> MemRef_a[i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] ; CHECK-NEXT: }
; CHECK: [P, N] -> { Stmt_store[i0] -> MemRef_a[i0] };

polly/trunk/test/ScopInfo/user_context.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-context='[N] -> {: N = 1024}' -analyze < %s | FileCheck %s --check-prefix=CTX ; RUN: opt %loadPolly -polly-scops -polly-context='[N] -> {: N = 1024}' -analyze < %s | FileCheck %s --check-prefix=CTX
; RUN: opt %loadPolly -polly-scops -polly-context='[N,M] -> {: 1 = 0}' -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-context='[N,M] -> {: 1 = 0}' -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-context='[] -> {: 1 = 0}' -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-context='[] -> {: 1 = 0}' -analyze < %s | FileCheck %s
; void f(int a[], int N) { ; void f(int a[], int N) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; a[i] = i; ; a[i] = i;
; } ; }
; CHECK: Context: ; CHECK: Context:
; CHECK: [N] -> { : ; CHECK-NEXT: [N] -> { : N <= 9223372036854775807 and N >= -9223372036854775808 }
; CHECK-DAG: N >= -9223372036854775808
; CHECK-DAG: and
; CHECK-DAG: N <= 9223372036854775807
; CHECK: }
; CTX: Context: ; CTX: Context:
; CTX: [N] -> { : N = 1024 } ; CTX-NEXT: [N] -> { : N = 1024 }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
define void @f(i64* nocapture %a, i64 %N) nounwind { define void @f(i64* nocapture %a, i64 %N) nounwind {
entry: entry:
br label %bb br label %bb
bb: ; preds = %bb, %entry bb: ; preds = %bb, %entry
Show All 11 Lines

polly/trunk/test/ScopInfo/user_provided_assumptions.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP
; ;
; CHECK: remark: <unknown>:0:0: SCoP begins here. ; CHECK: remark: <unknown>:0:0: SCoP begins here.
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N >= -2147483648 - M and N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N >= -2147483648 - M and N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and M <= 100 and M >= 1 and N <= 2147483647 - M and N >= -2147483648 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and M <= 100 and M >= 1 and N <= 2147483647 - M and N >= -2147483648 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and N >= -2147483648 - M and N <= 2147483647 - M and M <= 100 and M >= 1 and N >= 1 } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and N >= -2147483648 - M and N <= 2147483647 - M and M <= 100 and M >= 1 and N >= 1 }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
;
; CHECK: Context: ; SCOP: Context:
; CHECK-NEXT: [N, M, Debug] -> { : Debug = 0 and N >= 1 and M <= 2147483647 - N and M <= 100 and M >= 1 } ; SCOP-NEXT: [N, M, Debug] -> { : Debug = 0 and N >= 1 and M <= 2147483647 - N and M <= 100 and M >= 1 }
; CHECK-NEXT: Assumed Context: ; SCOP: Assumed Context:
; CHECK-NEXT: [N, M, Debug] -> { : } ; SCOP-NEXT: [N, M, Debug] -> { : }
; CHECK-NEXT: Boundary Context: ; SCOP: Boundary Context:
; CHECK-NEXT: [N, M, Debug] -> { : } ; SCOP-NEXT: [N, M, Debug] -> { : }
; ;
; #include <stdio.h> ; #include <stdio.h>
; ;
; void valid(int * restrict A, int * restrict B, int N, int M, int C[100][100], int Debug) { ; void valid(int * restrict A, int * restrict B, int N, int M, int C[100][100], int Debug) {
; __builtin_assume(M <= 2147483647 - N); ; __builtin_assume(M <= 2147483647 - N);
; __builtin_assume(M >= -2147483648 - N); ; __builtin_assume(M >= -2147483648 - N);
; __builtin_assume(Debug == 0 && M <= 100 && M >= 1 && N >= 1); ; __builtin_assume(Debug == 0 && M <= 100 && M >= 1 && N >= 1);
; if (N + M == -1) ; if (N + M == -1)
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/user_provided_non_dominating_assumptions.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: remark: <unknown>:0:0: SCoP begins here. ; CHECK: remark: <unknown>:0:0: SCoP begins here.
; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, p_2] -> { : N <= i or (N >= 1 + i and p_2 <= 100) } ; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, p_2] -> { : N <= i or (N >= 1 + i and p_2 <= 100) }
; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, p_2, M] -> { : N <= i or (N >= 1 + i and p_2 <= 0) or (N >= 1 + i and p_2 >= 1 and M >= p_2) } ; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, p_2, M] -> { : N <= i or (N >= 1 + i and p_2 <= 0) or (N >= 1 + i and p_2 >= 1 and M >= p_2) }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; ;
; void f(int *restrict A, int *restrict B, int i, int N, int M, int C[100][100]) { ; void f(int *restrict A, int *restrict B, int i, int N, int M, int C[100][100]) {
; for (; i < N; i++) { ; for (; i < N; i++) {
; __builtin_assume(N >= 0); ; __builtin_assume(N >= 0);
; for (int j = 0; j != M; j++) { ; for (int j = 0; j != M; j++) {
; __builtin_assume(N >= 0); ; __builtin_assume(N >= 0);
; C[i][j] += A[i * M + j] + B[i + j]; ; C[i][j] += A[i * M + j] + B[i + j];
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/wraping_signed_expr_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, int N, int p) { ; void f(int *A, int N, int p) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + 30] = 0; ; A[i + 30] = 0;
; } ; }
; ;
; The wrap function has no inbounds GEP but the nowrap function has. Therefore, ; The wrap function has no inbounds GEP but the nowrap function has. Therefore,
; we will add the assumption that i+1 won't overflow only to the former. ; we will add the assumption that i+1 won't overflow only to the former.
; ;
; Note: 2147483618 + 30 == 2 ^ 31 ; Note: 2147483618 + 30 == 2 ^ 31
;
; CHECK: Function: wrap ; CHECK: Function: wrap
;
; CHECK: Context: ; CHECK: Context:
; CHECK: [N] -> { : N <= 2147483647 and N >= -2147483648 } ; CHECK-NEXT: [N] -> { : N <= 2147483647 and N >= -2147483648 }
; CHECK: Boundary Context:
; CHECK: [N] -> { : N <= 2147483618 }
; ;
; CHECK: Boundary Context:
; CHECK-NEXT: [N] -> { : N <= 2147483618 }
target datalayout = "e-m:e-i32:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i32:64-f80:128-n8:16:32:64-S128"
define void @wrap(i32* %A, i32 %N, i32 %p) { define void @wrap(i32* %A, i32 %N, i32 %p) {
bb: bb:
br label %bb2 br label %bb2
bb2: ; preds = %bb7, %bb bb2: ; preds = %bb7, %bb
%indvars.iv = phi i32 [ %indvars.iv.next, %bb7 ], [ 0, %bb ] %indvars.iv = phi i32 [ %indvars.iv.next, %bb7 ], [ 0, %bb ]
Show All 16 Lines

polly/trunk/test/ScopInfo/wraping_signed_expr_4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(char *A, char N, char p) { ; void f(char *A, char N, char p) {
; for (char i = 0; i < N; i++) ; for (char i = 0; i < N; i++)
; A[p-1] = 0; ; A[p-1] = 0;
; } ; }
;
; CHECK: Function: wrap ; CHECK: Function: wrap
;
; CHECK: Context: ; CHECK: Context:
; CHECK: [N, p] -> { : N <= 127 and N >= -128 and p <= 127 and p >= -128 } ; CHECK-NEXT: [N, p] -> { : N <= 127 and N >= -128 and p <= 127 and p >= -128 }
; CHECK: Boundary Context:
; CHECK: [N, p] -> { : p >= -127 }
; ;
; CHECK: Boundary Context:
; CHECK-NEXT: [N, p] -> { : p >= -127 }
target datalayout = "e-m:e-i8:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i8:64-f80:128-n8:16:32:64-S128"
define void @wrap(i8* %A, i8 %N, i8 %p) { define void @wrap(i8* %A, i8 %N, i8 %p) {
bb: bb:
br label %bb2 br label %bb2
bb2: ; preds = %bb7, %bb bb2: ; preds = %bb7, %bb
%indvars.iv = phi i8 [ %indvars.iv.next, %bb7 ], [ 0, %bb ] %indvars.iv = phi i8 [ %indvars.iv.next, %bb7 ], [ 0, %bb ]
Show All 16 Lines

polly/trunk/test/ScopInfo/wraping_signed_expr_5.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; We should not generate runtime check for ((int)r1 + (int)r2) as it is known not ; We should not generate runtime check for ((int)r1 + (int)r2) as it is known not
; to overflow. However (p + q) can, thus checks are needed. ; to overflow. However (p + q) can, thus checks are needed.
; ;
; CHECK: Boundary Context: ; CHECK: Boundary Context:
; CHECK: [r1, r2, q, p] -> { ; CHECK-NEXT: [r1, r2, q, p] -> { : r2 <= 127 + r1 and p <= 2147483647 - q and p >= -2147483648 - q }
; CHECK-DAG: p <= 2147483647 - q
; CHECK-DAG: and
; CHECK-DAG: p >= -2147483648 - q
; CHECK-DAG: and
; CHECK-DAG: r2 <= 127 + r1
; CHECK: }
; ;
; void wraps(int *A, int p, short q, char r1, char r2) { ; void wraps(int *A, int p, short q, char r1, char r2) {
; for (char i = r1; i < r2; i++) ; for (char i = r1; i < r2; i++)
; A[p + q] = A[(int)r1 + (int)r2]; ; A[p + q] = A[(int)r1 + (int)r2];
; } ; }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 29 Lines