This is an archive of the discontinued LLVM Phabricator instance.

Differential D45493

[Polly][NewPM] Port IslAst, ScopDetect, and ScopInfo lit testsuites over to the new PM
AcceptedPublic

Authored by philip.pfaffe on Apr 10 2018, 8:36 AM.

Details

Reviewers
grosser
Meinersbur
bollu
Summary

These changes are entirely mechanic, using the new-pm pipeline specifications.
I didn't do these changes by hand but instead used a small
tool, with a small bit of
manual polishing.

This patch depends on D45484.

Diff Detail

Event Timeline

philip.pfaffe created this revision.Apr 10 2018, 8:36 AM
Herald added a reviewer: bollu. · View Herald TranscriptApr 10 2018, 8:36 AM
Herald added a subscriber: bollu. · View Herald Transcript
Harbormaster completed remote builds in B16939: Diff 141861.Apr 10 2018, 8:36 AM
philip.pfaffe added a comment.Apr 10 2018, 8:39 AM

It's obviously hard for reviewers to examine all changes, but I'd be happy if you could take a look at a random sample :)

lksbhm mentioned this in D45210: [New-PM] Lift Scop Pipeline to CGSCC-level.Apr 10 2018, 8:45 AM
philip.pfaffe mentioned this in D45484: [Polly][NewPM] Update pass registration for the LLVM plugin interface.Apr 10 2018, 8:45 AM
lksbhm added a child revision: D45210: [New-PM] Lift Scop Pipeline to CGSCC-level.Apr 10 2018, 8:46 AM
grosser accepted this revision.Apr 10 2018, 9:20 AM

Very nice. This LGTM, but maybe @Meinersbur also has some comment.

This revision is now accepted and ready to land.Apr 10 2018, 9:20 AM
Meinersbur added a comment.Apr 10 2018, 9:34 AM

Instead of adding -aa-pipeline=basic-aa everywhere, did you consider adding it to %loadPolly, or only add it if the test otherwise fails?

This will double the time a check-polly run takes, which I unfortunately cannot get too excited about. For new test cases, do we then also have to consider the new pass manager?
My suggestion is to wait with this change until we want to make the new PM the main implementation, instead of maintaining two PMs in parallel. The script can be applied anytime, and even added to the repository.

test/Isl/CodeGen/20100708.ll
1

Could you try to do something more intelligent than merging stdout and stderr everywhere? How they are interleaved is undefined, and we risk indeterministic test failures.

test/Isl/CodeGen/conflict-between-loop-invariant-code-hosting-and-escape-map-computation.ll
1

Could you can tell your script to remove -polly-process-unprofitable, which is added by %loadPolly anyway?

philip.pfaffe added a comment.Apr 11 2018, 3:17 AM
In D45493#1063228, @Meinersbur wrote:

Instead of adding -aa-pipeline=basic-aa everywhere, did you consider adding it to %loadPolly, or only add it if the test otherwise fails?

I can add it to %loadPolly. I'm hesitant to make this opt-in, though, since I fear the tests could get very flaky.

This will double the time a check-polly run takes, which I unfortunately cannot get too excited about. For new test cases, do we then also have to consider the new pass manager?

New test cases should be written for the new pass manager. Possibly, we should require future changes to be new-pm only? I don't think it makes sense to invest in a legacy codebase.

My suggestion is to wait with this change until we want to make the new PM the main implementation, instead of maintaining two PMs in parallel. The script can be applied anytime, and even added to the repository.

I can agree with that, but I think we should make the switch asap (since this is mostly a change in policy).

Meinersbur added a comment.Apr 12 2018, 3:45 PM
In D45493#1064052, @philip.pfaffe wrote:
In D45493#1063228, @Meinersbur wrote:

Instead of adding -aa-pipeline=basic-aa everywhere, did you consider adding it to %loadPolly, or only add it if the test otherwise fails?

I can add it to %loadPolly. I'm hesitant to make this opt-in, though, since I fear the tests could get very flaky.

Can you elaborate on this?

This will double the time a check-polly run takes, which I unfortunately cannot get too excited about. For new test cases, do we then also have to consider the new pass manager?

New test cases should be written for the new pass manager. Possibly, we should require future changes to be new-pm only? I don't think it makes sense to invest in a legacy codebase.

My suggestion is to wait with this change until we want to make the new PM the main implementation, instead of maintaining two PMs in parallel. The script can be applied anytime, and even added to the repository.

I can agree with that, but I think we should make the switch asap (since this is mostly a change in policy).

I'd go with when clang/LLVM itself makes the switch.

philip.pfaffe added a comment.Apr 16 2018, 4:01 AM
In D45493#1066480, @Meinersbur wrote:
In D45493#1064052, @philip.pfaffe wrote:
In D45493#1063228, @Meinersbur wrote:

Instead of adding -aa-pipeline=basic-aa everywhere, did you consider adding it to %loadPolly, or only add it if the test otherwise fails?

I can add it to %loadPolly. I'm hesitant to make this opt-in, though, since I fear the tests could get very flaky.

Can you elaborate on this?

In a legacy PM pipeline, basic-aa is always the default. I.e., if you do AA queries without specifying any AA passes, you always get basic-aa results. In the new PM, that's not true. So i think it should be present in the testcases. I'm happy to add it to `%loadPolly', though!

This will double the time a check-polly run takes, which I unfortunately cannot get too excited about. For new test cases, do we then also have to consider the new pass manager?

New test cases should be written for the new pass manager. Possibly, we should require future changes to be new-pm only? I don't think it makes sense to invest in a legacy codebase.

My suggestion is to wait with this change until we want to make the new PM the main implementation, instead of maintaining two PMs in parallel. The script can be applied anytime, and even added to the repository.

I can agree with that, but I think we should make the switch asap (since this is mostly a change in policy).

I'd go with when clang/LLVM itself makes the switch.

I'd prefer to have coverage before that. But actually this feels like we should have broader discussion on whether or when we should deprecate legacy PM in Polly and should expect contributors to code against the new PM instead.

lksbhm added a subscriber: lksbhm.Apr 16 2018, 4:58 AM
lksbhm added inline comments.
test/ScopInfo/scalar_to_array.ll
5

This is the same RUN line twice. I just noticed this by accident. The polly-scops and polly-function-scops flags map to the same new-pm pass. It might be good to look for similar cases within the other tests.

Meinersbur added a comment.Apr 16 2018, 2:43 PM
In D45493#1068638, @philip.pfaffe wrote:

In a legacy PM pipeline, basic-aa is always the default. I.e., if you do AA queries without specifying any AA passes, you always get basic-aa results. In the new PM, that's not true. So i think it should be present in the testcases. I'm happy to add it to `%loadPolly', though!

I'd prefer to have it added to %loadPolly to avoid boilerplate in every test case.

Meinersbur mentioned this in D121566: Load pass plugins during option processing, so that plugin options are registered and live..Mar 16 2022, 10:10 AM

Revision Contents

PathSize
test/
Isl/
Ast/
13 lines
16 lines
13 lines
4 lines
2 lines
2 lines
2 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
3 lines
3 lines
CodeGen/
1 line
3 lines
1 line
1 line
2 lines
1 line
1 line
1 line
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
1 line
1 line
1 line
1 line
1 line
2 lines
1 line
2 lines
1 line
2 lines
LoopParallelMD/
3 lines
2 lines
4 lines
MemAccess/
6 lines
OpenMP/
2 lines
3 lines
3 lines
3 lines
3 lines
6 lines
6 lines
8 lines
6 lines
5 lines
4 lines
3 lines
3 lines
6 lines
8 lines
3 lines
6 lines
1 line
RuntimeDebugBuilder/
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
1 line
2 lines
3 lines
2 lines
1 line
1 line
4 lines
2 lines
1 line
2 lines
2 lines
1 line
2 lines
2 lines
4 lines
2 lines
2 lines
5 lines
1 line
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
5 lines
2 lines
2 lines
2 lines
3 lines
3 lines
9 lines
2 lines
3 lines
3 lines
2 lines
3 lines
3 lines
2 lines
3 lines
2 lines
2 lines
5 lines
3 lines
3 lines
2 lines
2 lines
2 lines
3 lines
3 lines
5 lines
2 lines
1 line
2 lines
3 lines
2 lines
5 lines
2 lines
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
3 lines
6 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
6 lines
2 lines
2 lines
6 lines
2 lines
3 lines
3 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
1 line
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
6 lines
3 lines
3 lines
4 lines
4 lines
3 lines
3 lines
3 lines
2 lines
2 lines
3 lines
3 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
5 lines
2 lines
2 lines
18 lines
2 lines
2 lines
7 lines
4 lines
2 lines
2 lines
ScopDetect/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
5 lines
3 lines
2 lines
2 lines
2 lines
10 lines
2 lines
3 lines
5 lines
6 lines
2 lines
2 lines
2 lines
2 lines
4 lines
3 lines
3 lines
16 lines
12 lines
12 lines
22 lines
3 lines
2 lines
2 lines
7 lines
3 lines
3 lines
2 lines
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
ScopInfo/
2 lines
2 lines
2 lines
2 lines
6 lines
6 lines
6 lines
6 lines
5 lines
BoundChecks/
4 lines
4 lines
NonAffine/
2 lines
2 lines
3 lines
2 lines
2 lines
9 lines
12 lines
12 lines
3 lines
2 lines
2 lines
3 lines
9 lines
14 lines
3 lines
13 lines
9 lines
3 lines
3 lines
2 lines
2 lines
2 lines
2 lines
5 lines
8 lines
2 lines
4 lines
4 lines
4 lines
3 lines
3 lines
2 lines
3 lines
2 lines
4 lines
18 lines
5 lines
2 lines
2 lines
2 lines
2 lines
3 lines
4 lines
4 lines
2 lines
4 lines
3 lines
4 lines
3 lines
4 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
3 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
3 lines
3 lines
4 lines
5 lines
4 lines
4 lines
2 lines
2 lines
4 lines
3 lines
3 lines
4 lines
4 lines
5 lines
2 lines
4 lines
5 lines
4 lines
6 lines
2 lines
5 lines
3 lines
2 lines
3 lines
3 lines
3 lines
2 lines
5 lines
3 lines
6 lines
6 lines
6 lines
6 lines
4 lines
4 lines
4 lines
4 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
5 lines
4 lines
3 lines
3 lines
3 lines
8 lines
4 lines
4 lines
3 lines
7 lines
6 lines
5 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
6 lines
6 lines
6 lines
2 lines
2 lines
3 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
6 lines
6 lines
6 lines
5 lines
2 lines
12 lines
14 lines
5 lines
5 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
19 lines
11 lines
2 lines
2 lines
4 lines
2 lines
4 lines
3 lines
4 lines
23 lines
4 lines
2 lines
2 lines
2 lines
3 lines
6 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
22 lines
2 lines
4 lines
4 lines
13 lines
18 lines
18 lines
3 lines
3 lines
4 lines
4 lines
5 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
8 lines
5 lines
3 lines
3 lines
3 lines
3 lines
3 lines
3 lines
2 lines
2 lines
2 lines
10 lines
3 lines
2 lines
4 lines
2 lines
3 lines
3 lines
2 lines
2 lines
4 lines
11 lines
6 lines
2 lines
2 lines
6 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
11 lines
2 lines
2 lines
2 lines
5 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
3 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
3 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
3 lines
4 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
6 lines
2 lines
12 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
11 lines
5 lines
2 lines
5 lines
5 lines
5 lines
5 lines
9 lines
7 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines

Diff 141861

test/Isl/Ast/alias_simple_1.ll

; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=type-based-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=scev-aa < %s 2>&1 | FileCheck %s\
; RUN: --check-prefix=SCEV
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=globals-aa < %s 2>&1 | FileCheck\
; RUN: %s --check-prefix=GLOB
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB
; ;
; int A[1024]; ; int A[1024];
; ;
; ;
; void jd(float *B, int N) { ; void jd(float *B, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Isl/Ast/alias_simple_2.ll

; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=type-based-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=scev-aa < %s 2>&1 | FileCheck %s\
; RUN: --check-prefix=SCEV
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=globals-aa < %s 2>&1 | FileCheck\
; RUN: %s --check-prefix=GLOB
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB
; RUN: opt %loadPolly -disable-output -disable-basicaa -polly-allow-nonaffine \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=globals-aa < %s 2>&1 | FileCheck\
; RUN: %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa -polly-allow-nonaffine < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa -polly-allow-nonaffine < %s | FileCheck %s --check-prefix=NONAFFINE
; ;
; int A[1024], B[1024]; ; int A[1024], B[1024];
; ;
; ;
; void jd(int N) { ; void jd(int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/Ast/alias_simple_3.ll

; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=type-based-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=scev-aa < %s 2>&1 | FileCheck %s\
; RUN: --check-prefix=SCEV
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -disable-output -disable-basicaa \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=globals-aa < %s 2>&1 | FileCheck\
; RUN: %s --check-prefix=GLOB
; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-ast -analyze -disable-basicaa -globals-aa < %s | FileCheck %s --check-prefix=GLOB
; ;
; int A[1024]; ; int A[1024];
; float B[1024]; ; float B[1024];
; ;
; void jd(int N) { ; void jd(int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/Ast/aliasing_multiple_alias_groups.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=type-based-aa < %s 2>&1 | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
; ;
; void jd(int *Int0, int *Int1, float *Float0, float *Float1) { ; void jd(int *Int0, int *Int1, float *Float0, float *Float1) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; Int0[i] = Int1[i]; ; Int0[i] = Int1[i];
; Float0[i] = Float1[i]; ; Float0[i] = Float1[i];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Isl/Ast/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
; CHECK: if (1 && (&MemRef_B[c + 1] <= &MemRef_A[0] || &MemRef_A[1024] <= &MemRef_B[c])) ; CHECK: if (1 && (&MemRef_B[c + 1] <= &MemRef_A[0] || &MemRef_A[1024] <= &MemRef_B[c]))
Show All 31 Lines

test/Isl/Ast/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
; CHECK: if (1 && 0 == c <= -{{[0-9]*}} && (&MemRef_B[max(6, c - 9)] <= &MemRef_A[0] || &MemRef_A[1024] <= &MemRef_B[min(5, c - 10)])) ; CHECK: if (1 && 0 == c <= -{{[0-9]*}} && (&MemRef_B[max(6, c - 9)] <= &MemRef_A[0] || &MemRef_A[1024] <= &MemRef_B[min(5, c - 10)]))
Show All 35 Lines

test/Isl/Ast/domain_bounded_only_with_context.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; CHECK: { ; CHECK: {
; CHECK-NEXT: if (p <= -1 || p >= 1) ; CHECK-NEXT: if (p <= -1 || p >= 1)
; CHECK-NEXT: Stmt_preheader(); ; CHECK-NEXT: Stmt_preheader();
; CHECK-NEXT: for (int c0 = 0; c0 < 2 * p; c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 < 2 * p; c0 += 1)
; CHECK-NEXT: Stmt_loop(c0); ; CHECK-NEXT: Stmt_loop(c0);
; CHECK-NEXT: if (p <= -1) { ; CHECK-NEXT: if (p <= -1) {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/Ast/non_affine_access.ll

; RUN: opt %loadPolly -polly-ast-print-accesses -disable-output \
; RUN: -polly-allow-nonaffine "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -polly-ast-print-accesses -analyze \ ; RUN: opt %loadPolly -polly-ast -polly-ast-print-accesses -analyze \
; RUN: -polly-allow-nonaffine < %s \ ; RUN: -polly-allow-nonaffine < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; void non_affine_access(float A[]) { ; void non_affine_access(float A[]) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; A[i * i] = 1; ; A[i * i] = 1;
; } ; }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_clauses_onedimensional_access.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma known-parallel reduction (^ : MemRef_sum) ; CHECK: #pragma known-parallel reduction (^ : MemRef_sum)
; void f(int N, int M, int *sum) { ; void f(int N, int M, int *sum) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; CHECK: #pragma simd ; CHECK: #pragma simd
; for (int j = 0; j < M; j++) ; for (int j = 0; j < M; j++)
; sum[j] ^= j; ; sum[j] ^= j;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_dependences_equal_non_reduction_dependences.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -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 do __not__ parallelize anything ; accesses to the array A. We need to ensure we do __not__ parallelize anything
; here. ; here.
; ;
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; CHECK-NOT: pragma ; CHECK-NOT: pragma
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_different_reduction_clauses.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma simd reduction (+ : MemRef_sum{{[1,2]}}, MemRef_sum{{[1,2]}}) reduction (* : MemRef_prod) reduction (| : MemRef_or) reduction (& : MemRef_and) ; CHECK: #pragma simd reduction (+ : MemRef_sum{{[1,2]}}, MemRef_sum{{[1,2]}}) reduction (* : MemRef_prod) reduction (| : MemRef_or) reduction (& : MemRef_and)
; CHECK: #pragma known-parallel reduction (+ : MemRef_sum{{[1,2]}}, MemRef_sum{{[1,2]}}) reduction (* : MemRef_prod) reduction (| : MemRef_or) reduction (& : MemRef_and) ; CHECK: #pragma known-parallel reduction (+ : MemRef_sum{{[1,2]}}, MemRef_sum{{[1,2]}}) reduction (* : MemRef_prod) reduction (| : MemRef_or) reduction (& : MemRef_and)
; CHECK: for (int c0 = 0; c0 < N; c0 += 1) ; CHECK: for (int c0 = 0; c0 < N; c0 += 1)
; CHECK: Stmt_for_body(c0); ; CHECK: Stmt_for_body(c0);
; ;
; void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod, ; void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod,
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_multiple_dimensions.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_multiple_dimensions_2.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_multiple_dimensions_3.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/Ast/reduction_multiple_dimensions_4.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/Ast/run-time-condition.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i] = B[i]; ; A[i] = B[i];
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 @run-time-condition(i16* noalias %A, i16* noalias %B) { define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
Show All 27 Lines

test/Isl/Ast/runtime_context_with_error_blocks.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -analyze \ ; RUN: opt %loadPolly -polly-ast -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; Verify we do not simplify the runtime check to "true" due to the domain ; Verify we do not simplify the runtime check to "true" due to the domain
; constraints as the test contains an error block that influenced the domains ; constraints as the test contains an error block that influenced the domains
; already. ; already.
; ;
; CHECK: if (p_0_loaded_from_this <= -1 || p_0_loaded_from_this >= 1) ; CHECK: if (p_0_loaded_from_this <= -1 || p_0_loaded_from_this >= 1)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/Isl/Ast/simple-run-time-condition.ll

; RUN: opt %loadPolly -disable-output -polly-precise-inbounds < %s \
; RUN: -polly-precise-fold-accesses "-passes=print<polly-ast>" 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -polly-precise-inbounds < %s \ ; RUN: opt %loadPolly -polly-ast -analyze -polly-precise-inbounds < %s \
; RUN: -polly-precise-fold-accesses \ ; RUN: -polly-precise-fold-accesses \
; RUN: | FileCheck %s ; RUN: | 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, int o, double A[n][m], long p, long q) { ; void foo(long n, long m, int o, double A[n][m], long p, long q) {
; ;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/Isl/CodeGen/20100617.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @init_array() nounwind { define void @init_array() nounwind {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.cond1, %entry for.cond: ; preds = %for.cond1, %entry
Show All 10 Lines

test/Isl/CodeGen/20100622.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | not FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | not FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
define void @MAIN__() nounwind { define void @MAIN__() nounwind {
entry: entry:
br i1 undef, label %bb6.preheader, label %bb3 br i1 undef, label %bb6.preheader, label %bb3
Show All 33 Lines

test/Isl/CodeGen/20100707.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @clause_SetSplitField(i32 %Length) nounwind inlinehint { define void @clause_SetSplitField(i32 %Length) nounwind inlinehint {
entry: entry:
br i1 undef, label %bb1, label %bb6 br i1 undef, label %bb1, label %bb6
bb1: ; preds = %entry bb1: ; preds = %entry
Show All 18 Lines

test/Isl/CodeGen/20100707_2.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
@win193 = external global [4 x [36 x double]], align 32 ; <[4 x [36 x double]]*> [#uses=3] @win193 = external global [4 x [36 x double]], align 32 ; <[4 x [36 x double]]*> [#uses=3]
@sb_sample = external global [2 x [2 x [18 x [32 x double]]]], align 32 ; <[2 x [2 x [18 x [32 x double]]]]*> [#uses=2] @sb_sample = external global [2 x [2 x [18 x [32 x double]]]], align 32 ; <[2 x [2 x [18 x [32 x double]]]]*> [#uses=2]
define void @mdct_sub48() nounwind { define void @mdct_sub48() nounwind {
entry: entry:
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

test/Isl/CodeGen/20100708.ll

; RUN: opt %loadPolly "-passes=require<polly-detect>" < %s 2>&1 \
MeinersburUnsubmitted
Not Done
ReplyInline Actions

Could you try to do something more intelligent than merging stdout and stderr everywhere? How they are interleaved is undefined, and we risk indeterministic test failures.

Meinersbur: Could you try to do something more intelligent than merging stdout and stderr everywhere? How…
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect < %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" 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"
define fastcc void @execute() nounwind { define fastcc void @execute() nounwind {
entry: entry:
br i1 undef, label %check_stack.exit456.thread, label %bb.i451.preheader br i1 undef, label %check_stack.exit456.thread, label %bb.i451.preheader
bb.i451.preheader: ; preds = %bb116 bb.i451.preheader: ; preds = %bb116
Show All 9 Lines

test/Isl/CodeGen/20100708_2.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @init_array() nounwind { define void @init_array() nounwind {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb4, %bb bb1: ; preds = %bb4, %bb
Show All 19 Lines

test/Isl/CodeGen/20100713.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @fft_float(i32 %NumSamples) nounwind { define void @fft_float(i32 %NumSamples) nounwind {
br label %bb18 br label %bb18
bb18: ; preds = %bb17 bb18: ; preds = %bb17
br i1 false, label %bb19, label %bb22 br i1 false, label %bb19, label %bb22
Show All 25 Lines

test/Isl/CodeGen/20100713_2.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define hidden void @luaD_callhook() nounwind { define hidden void @luaD_callhook() nounwind {
entry: entry:
br i1 undef, label %bb, label %return br i1 undef, label %bb, label %return
bb: ; preds = %entry bb: ; preds = %entry
Show All 25 Lines

test/Isl/CodeGen/20100717.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %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" 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"
define void @matrixTranspose(double** %A) nounwind { define void @matrixTranspose(double** %A) nounwind {
entry: entry:
br label %bb4 br label %bb4
bb: ; preds = %bb4 bb: ; preds = %bb4
Show All 30 Lines

test/Isl/CodeGen/20100718-DomInfo-2.ll

; RUN: opt %loadPolly -verify-dom-info -disable-output -passes=polly-codegen < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -verify-dom-info -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -verify-dom-info -disable-output < %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" 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"
define void @getNonAffNeighbour() nounwind { define void @getNonAffNeighbour() nounwind {
entry: entry:
br i1 undef, label %bb, label %bb6 br i1 undef, label %bb, label %bb6
bb: ; preds = %entry bb: ; preds = %entry
Show All 26 Lines

test/Isl/CodeGen/20100718-DomInfo.ll

; RUN: opt %loadPolly -verify-dom-info -disable-output -passes=polly-codegen < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -verify-dom-info -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -verify-dom-info -disable-output < %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" 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"
define void @intrapred_luma_16x16(i32 %predmode) nounwind { define void @intrapred_luma_16x16(i32 %predmode) nounwind {
entry: entry:
switch i32 %predmode, label %bb81 [ switch i32 %predmode, label %bb81 [
i32 0, label %bb25 i32 0, label %bb25
i32 1, label %bb26 i32 1, label %bb26
Show All 19 Lines

test/Isl/CodeGen/20100720-MultipleConditions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-ast -analyze < %s ; RUN: opt %loadPolly -polly-ast -analyze < %s
;int bar1(); ;int bar1();
;int bar2(); ;int bar2();
;int bar3(); ;int bar3();
;int k; ;int k;
;#define N 100 ;#define N 100
;int A[N]; ;int A[N];
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/Isl/CodeGen/20100809-IndependentBlock.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %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" 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"
define void @cfft2([2 x float]* %x) nounwind { define void @cfft2([2 x float]* %x) nounwind {
entry: entry:
%d.1.reg2mem = alloca [2 x float]* ; <[2 x float]**> [#uses=3] %d.1.reg2mem = alloca [2 x float]* ; <[2 x float]**> [#uses=3]
br i1 undef, label %bb2, label %bb34 br i1 undef, label %bb2, label %bb34
bb2: ; preds = %bb34, %entry bb2: ; preds = %bb34, %entry
Show All 22 Lines

test/Isl/CodeGen/20100811-ScalarDependencyBetweenBrAndCnd.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %s
target datalayout = 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" "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"
define void @main() nounwind { define void @main() nounwind {
entry: entry:
br label %for.cond br label %for.cond
Show All 21 Lines

test/Isl/CodeGen/20101030-Overflow.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @compdecomp() nounwind { define void @compdecomp() nounwind {
entry: entry:
%max = alloca i64 %max = alloca i64
%i = load i64, i64* undef %i = load i64, i64* undef
br label %bb37 br label %bb37
Show All 13 Lines

test/Isl/CodeGen/20101103-Overflow3.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @Reflection_coefficients(i16* %r) nounwind { define void @Reflection_coefficients(i16* %r) nounwind {
bb20: bb20:
%indvar3.lcssa20.reload = load i64, i64* undef %indvar3.lcssa20.reload = load i64, i64* undef
%tmp = mul i64 %indvar3.lcssa20.reload, -1 %tmp = mul i64 %indvar3.lcssa20.reload, -1
%tmp5 = add i64 %tmp, 8 %tmp5 = add i64 %tmp, 8
br label %bb22 br label %bb22
Show All 15 Lines

test/Isl/CodeGen/20101103-signmissmatch.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @CleanNet() nounwind { define void @CleanNet() nounwind {
entry: entry:
%firstVia.0.reg2mem = alloca i64 %firstVia.0.reg2mem = alloca i64
br label %bb7 br label %bb7
Show All 29 Lines

test/Isl/CodeGen/20110226-Ignore-Dead-Code.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @main() nounwind { define void @main() nounwind {
.split: .split:
br label %0 br label %0
.loopexit.loopexit: ; preds = %.preheader.us .loopexit.loopexit: ; preds = %.preheader.us
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Isl/CodeGen/20110226-PHI-Node-removed.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
define void @main() nounwind { define void @main() nounwind {
.split: .split:
br label %0 br label %0
Show All 21 Lines

test/Isl/CodeGen/20120316-InvalidCast.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; CHECK: polly.start ; CHECK: polly.start
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
define void @fixup_gotos(i32* %A, i32* %data) nounwind { define void @fixup_gotos(i32* %A, i32* %data) nounwind {
entry: entry:
Show All 13 Lines

test/Isl/CodeGen/20120403-RHS-type-mismatch.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
; We just check that this compilation does not crash. ; We just check that this compilation does not crash.
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
define void @init() nounwind { define void @init() nounwind {
entry: entry:
Show All 18 Lines

test/Isl/CodeGen/20130211-getNumberOfIterations.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly < %s ; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly < %s
; This test case checks that the polly vectorizer does not crash when ; This test case checks that the polly vectorizer does not crash when
; calculating the number of iterations. ; calculating the number of iterations.
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"
@b = external global [2048 x i64], align 16 @b = external global [2048 x i64], align 16
Show All 19 Lines

test/Isl/CodeGen/20130221.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -S < %s ; RUN: opt %loadPolly -polly-codegen -S < %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"
define void @list_sequence(i32* %A) { define void @list_sequence(i32* %A) {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 12 Lines

test/Isl/CodeGen/20150328-SCEVExpanderIntroducesNewIV.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
@A = common global [1536 x float] zeroinitializer @A = common global [1536 x float] zeroinitializer
; CHECK: polly ; CHECK: polly
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() { define void @foo() {
Show All 29 Lines

test/Isl/CodeGen/LoopParallelMD/do_not_mutate_debug_info.ll

; This test checks that we do not accidently mutate the debug info when ; This test checks that we do not accidently mutate the debug info when
; inserting loop parallel metadata. ; inserting loop parallel metadata.
; RUN: opt %loadPolly < %s -S -polly -polly-ast-detect-parallel \
; RUN: -passes=polly-codegen 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --allow-empty
; RUN: opt %loadPolly < %s -S -polly -polly-codegen -polly-ast-detect-parallel | FileCheck %s ; RUN: opt %loadPolly < %s -S -polly -polly-codegen -polly-ast-detect-parallel | FileCheck %s
; CHECK-NOT: !7 = !{!7} ; CHECK-NOT: !7 = !{!7}
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"
@A = common global i32* null, align 8 @A = common global i32* null, align 8
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo() !dbg !4 { define void @foo() !dbg !4 {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/LoopParallelMD/loop_nest_param_parallel.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -S -passes=polly-codegen < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s
; ;
; Check that we mark multiple parallel loops correctly including the memory instructions. ; Check that we mark multiple parallel loops correctly including the memory instructions.
; ;
; CHECK-DAG: %polly.loop_cond[[COuter:[0-9]*]] = icmp sle i64 %polly.indvar_next{{[0-9]*}}, 1023 ; CHECK-DAG: %polly.loop_cond[[COuter:[0-9]*]] = icmp sle i64 %polly.indvar_next{{[0-9]*}}, 1023
; CHECK-DAG: br i1 %polly.loop_cond[[COuter]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDOuter:[0-9]*]] ; CHECK-DAG: br i1 %polly.loop_cond[[COuter]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDOuter:[0-9]*]]
; ;
; CHECK-DAG: %polly.loop_cond[[CInner:[0-9]*]] = icmp sle i64 %polly.indvar_next{{[0-9]*}}, 511 ; CHECK-DAG: %polly.loop_cond[[CInner:[0-9]*]] = icmp sle i64 %polly.indvar_next{{[0-9]*}}, 511
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/Isl/CodeGen/LoopParallelMD/single_loop_param_parallel.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=SEQUENTIAL
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=SEQUENTIAL ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=SEQUENTIAL
; RUN: opt %loadPolly -polly-ast-detect-parallel -S -passes=polly-codegen < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=PARALLEL
; RUN: opt %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL ; RUN: opt %loadPolly -polly-codegen -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL
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"
; This is a trivially parallel loop. We just use it to ensure that we actually ; This is a trivially parallel loop. We just use it to ensure that we actually
; emit the right information. ; emit the right information.
; ;
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = 1; ; A[i] = 1;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/Isl/CodeGen/MemAccess/generate-all.ll

; RUN: opt %loadPolly -polly-codegen-generate-expressions=false -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=SCEV
; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=false \ ; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=false \
; RUN: -S < %s | FileCheck %s -check-prefix=SCEV ; RUN: -S < %s | FileCheck %s -check-prefix=SCEV
; RUN: opt %loadPolly -polly-codegen-generate-expressions=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=ASTEXPR
; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=true \ ; RUN: opt %loadPolly -polly-codegen -polly-codegen-generate-expressions=true \
; RUN: -S < %s | FileCheck %s -check-prefix=ASTEXPR ; RUN: -S < %s | FileCheck %s -check-prefix=ASTEXPR
; ;
; void foo(float A[]) { ; void foo(float A[]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i % 4] += 10; ; A[i % 4] += 10;
; } ; }
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/alias-metadata.ll

; RUN: opt %loadPolly -polly-parallel -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s
; ;
; void foo(float *A, float *B) { ; void foo(float *A, float *B) {
; for (long i = 0; i < 1000; i++) ; for (long i = 0; i < 1000; i++)
; for (long j = 0; j < 1000; j++) ; for (long j = 0; j < 1000; j++)
; A[i] = B[i]; ; A[i] = B[i];
; } ; }
; ;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/invariant_base_pointer_preloaded.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction. ; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction.
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 1; i < 1000; i++) ; for (int i = 1; i < 1000; i++)
; A[i] += A[0]; ; A[i] += A[0];
Show All 25 Lines

test/Isl/CodeGen/OpenMP/invariant_base_pointer_preloaded_different_bb.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction. ; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction.
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 1; i < 1000; i++) ; for (int i = 1; i < 1000; i++)
; A[i] += /* split bb */ A[0]; ; A[i] += /* split bb */ A[0];
Show All 30 Lines

test/Isl/CodeGen/OpenMP/invariant_base_pointer_preloaded_pass_only_needed.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction but ; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction but
; not B[0] as it is not needed ; not B[0] as it is not needed
; ;
; void f(float *A, float *B) { ; void f(float *A, float *B) {
; // Not parallel ; // Not parallel
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/invariant_base_pointers_preloaded.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction. ; Test to verify that we hand down the preloaded A[0] to the OpenMP subfunction.
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 1; i < 1000; i++) ; for (int i = 1; i < 1000; i++)
; A[i] += A[0] + A[0]; ; A[i] += A[0] + A[0];
Show All 27 Lines

test/Isl/CodeGen/OpenMP/loop-body-references-outer-iv.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; This code has failed the scev based code generation as the scev in the scop ; This code has failed the scev based code generation as the scev in the scop
; contains an AddRecExpr of an outer loop. When generating code, we did not ; contains an AddRecExpr of an outer loop. When generating code, we did not
; properly forward the value of this expression to the subfunction. ; properly forward the value of this expression to the subfunction.
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
; AST: for (int c0 = 0; c0 <= 1023; c0 += 1) ; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
Show All 34 Lines

test/Isl/CodeGen/OpenMP/loop-body-references-outer-values-2.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; AST: #pragma simd ; AST: #pragma simd
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
; AST: for (int c0 = 0; c0 <= 1023; c0 += 1) ; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
; AST: Stmt_for_i(c0); ; AST: Stmt_for_i(c0);
; IR: getelementptr inbounds { [1024 x double]* }, { [1024 x double]* }* %polly.par.userContext, i32 0, i32 0 ; IR: getelementptr inbounds { [1024 x double]* }, { [1024 x double]* }* %polly.par.userContext, i32 0, i32 0
Show All 22 Lines

test/Isl/CodeGen/OpenMP/loop-body-references-outer-values-3.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-invariant-load-hoisting=true -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-invariant-load-hoisting=true -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force \
; RUN: -polly-invariant-load-hoisting=true -S -verify-dom-info \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-invariant-load-hoisting=true -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-invariant-load-hoisting=true -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; The interesting part of this test case is the instruction: ; The interesting part of this test case is the instruction:
; %tmp = bitcast i8* %call to i64** ; %tmp = bitcast i8* %call to i64**
; which is not part of the scop. In the SCEV based code generation not '%tmp', ; which is not part of the scop. In the SCEV based code generation not '%tmp',
; but %call is a parameter of the SCoP and we need to make sure its value is ; but %call is a parameter of the SCoP and we need to make sure its value is
; properly forwarded to the subfunction. ; properly forwarded to the subfunction.
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/loop-body-references-outer-values.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction. ; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction.
; ;
; void loop_references_outer_ids(float *A) { ; void loop_references_outer_ids(float *A) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 36 Lines

test/Isl/CodeGen/OpenMP/loop-bounds-reference-outer-ids.ll

; RUN: opt %loadPolly -polly-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; ;
; float A[100]; ; float A[100];
; ;
; void loop_references_outer_ids(long n) { ; void loop_references_outer_ids(long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; for (long k = 0; k < n + i; k++) ; for (long k = 0; k < n + i; k++)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/recomputed-srem.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-parallel \
; RUN: -polly-parallel-force -S -passes=polly-codegen -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -polly-parallel \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -polly-parallel \
; RUN: -polly-parallel-force -S < %s | FileCheck %s ; RUN: -polly-parallel-force -S < %s | FileCheck %s
; ;
; Test to verify that we pass %rem96 to the parallel subfunction. ; Test to verify that we pass %rem96 to the parallel subfunction.
; ;
; CHECK: %[[R:[0-9]*]] = getelementptr inbounds { i32, i32, i64, float*, float*, i32 }, { i32, i32, i64, float*, float*, i32 }* %polly.par.userContext1, i32 0, i32 5 ; CHECK: %[[R:[0-9]*]] = getelementptr inbounds { i32, i32, i64, float*, float*, i32 }, { i32, i32, i64, float*, float*, i32 }* %polly.par.userContext1, i32 0, i32 5
; CHECK-NEXT: %polly.subfunc.arg.rem96 = load i32, i32* %[[R]] ; CHECK-NEXT: %polly.subfunc.arg.rem96 = load i32, i32* %[[R]]
; ;
Show All 36 Lines

test/Isl/CodeGen/OpenMP/reference-argument-from-non-affine-region.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel \ ; RUN: opt %loadPolly -polly-parallel \
; RUN: -polly-parallel-force -polly-codegen -S -verify-dom-info < %s \ ; RUN: -polly-parallel-force -polly-codegen -S -verify-dom-info < %s \
; RUN: | FileCheck %s -check-prefix=IR ; RUN: | FileCheck %s -check-prefix=IR
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"
; IR: @GOMP_parallel_loop_runtime_start ; IR: @GOMP_parallel_loop_runtime_start
@longLimit = external global [9 x [23 x i32]], align 16 @longLimit = external global [9 x [23 x i32]], align 16
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Isl/CodeGen/OpenMP/reference-other-bb.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; IR: @foo_polly_subfn ; IR: @foo_polly_subfn
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(i32 %sendcount, i8* %recvbuf) { define void @foo(i32 %sendcount, i8* %recvbuf) {
entry: entry:
br label %sw.bb3 br label %sw.bb3
Show All 18 Lines

test/Isl/CodeGen/OpenMP/reference-preceeding-loop.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; - Test the case where scalar evolution references a loop that is outside ; - Test the case where scalar evolution references a loop that is outside
; of the scop, but does not contain the scop. ; of the scop, but does not contain the scop.
; AST: { ; AST: {
; AST-NEXT: #pragma simd ; AST-NEXT: #pragma simd
Show All 34 Lines

test/Isl/CodeGen/OpenMP/single_loop_with_loop_invariant_baseptr.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force \
; RUN: -polly-parallel-force -polly-invariant-load-hoisting=true \
; RUN: -disable-output "-passes=print<polly-ast>" -aa-pipeline=type-based-aa < \
; RUN: %s 2>&1 | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-invariant-load-hoisting=true -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-invariant-load-hoisting=true -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force \
; RUN: -polly-parallel-force -polly-invariant-load-hoisting=true -S \
; RUN: -verify-dom-info -passes=polly-codegen -aa-pipeline=type-based-aa < %s \
; RUN: 2>&1 | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-invariant-load-hoisting=true -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-invariant-load-hoisting=true -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; #define N 1024 ; #define N 1024
; float A[N]; ; float A[N];
; ;
; void single_parallel_loop(void) { ; void single_parallel_loop(void) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; A[i] = 1; ; A[i] = 1;
Show All 39 Lines

test/Isl/CodeGen/OpenMP/single_loop_with_param.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel \ ; RUN: opt %loadPolly -polly-parallel \
; RUN: -polly-parallel-force -polly-codegen -S -verify-dom-info < %s \ ; RUN: -polly-parallel-force -polly-codegen -S -verify-dom-info < %s \
; RUN: | FileCheck %s -check-prefix=IR ; RUN: | FileCheck %s -check-prefix=IR
; #define N 1024 ; #define N 1024
; float A[N]; ; float A[N];
; ;
; void single_parallel_loop(float alpha) { ; void single_parallel_loop(float alpha) {
Show All 37 Lines

test/Isl/CodeGen/OpenMP/two-parallel-loops-reference-outer-indvar.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -S -verify-dom-info\
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; This test case verifies that we create correct code even if two OpenMP loops ; This test case verifies that we create correct code even if two OpenMP loops
; share common outer variables. ; share common outer variables.
; AST: Stmt_for_body35(0); ; AST: Stmt_for_body35(0);
; AST: #pragma simd ; AST: #pragma simd
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
Show All 32 Lines

test/Isl/CodeGen/PHIInExit.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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" 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"
%struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t } %struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t }
%struct.__pthread_list_t = type { %struct.__pthread_list_t*, %struct.__pthread_list_t* } %struct.__pthread_list_t = type { %struct.__pthread_list_t*, %struct.__pthread_list_t* }
%union.pthread_attr_t = type { i64, [12 x i32] } %union.pthread_attr_t = type { i64, [12 x i32] }
%union.pthread_mutex_t = type { %struct..0__pthread_mutex_s } %union.pthread_mutex_t = type { %struct..0__pthread_mutex_s }
%union.pthread_mutexattr_t = type { i32 } %union.pthread_mutexattr_t = type { i32 }
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/Isl/CodeGen/RuntimeDebugBuilder/combine_different_values.ll

; RUN: opt %loadPolly -S -polly-codegen-add-debug-printing \
; RUN: -polly-ignore-aliasing -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-codegen-add-debug-printing \ ; RUN: -polly-codegen-add-debug-printing \
; RUN: -polly-ignore-aliasing < %s | FileCheck %s ; RUN: -polly-ignore-aliasing < %s | FileCheck %s
; #define N 10 ; #define N 10
; void foo(float A[restrict], double B[restrict], char C[restrict], ; void foo(float A[restrict], double B[restrict], char C[restrict],
; int D[restrict], long E[restrict]) { ; int D[restrict], long E[restrict]) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

test/Isl/CodeGen/alias-check-multi-dim.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %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"
; CHECK: sext i32 %indvar.init to i64 ; CHECK: sext i32 %indvar.init to i64
define void @foo(double* %A, double* %B, i32 %p, i32 %indvar.init) { define void @foo(double* %A, double* %B, i32 %p, i32 %indvar.init) {
preheader: preheader:
Show All 17 Lines

test/Isl/CodeGen/alias_metadata_too_many_arrays.ll

; RUN: opt %loadPolly -polly-ignore-aliasing -S -passes=polly-codegen < %s 2>&1\
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -S < %s \ ; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -S < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; void manyarrays(float A1[], float A2[], float A3[], float A4[], float A5[], ; void manyarrays(float A1[], float A2[], float A3[], float A4[], float A5[],
; float A6[], float A7[], float A8[], float A9[]) { ; float A6[], float A7[], float A8[], float A9[]) {
; for (long i = 0; i <= 1024; i++) { ; for (long i = 0; i <= 1024; i++) {
; A1[i] += i; ; A1[i] += i;
; A2[i] += i; ; A2[i] += i;
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

test/Isl/CodeGen/aliasing_different_base_and_access_type.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; We have to cast %B to "short *" before we create RTCs. ; We have to cast %B to "short *" before we create RTCs.
; ;
; CHECK: %polly.access.cast.B = bitcast i32* %B to i16* ; CHECK: %polly.access.cast.B = bitcast i32* %B to i16*
; CHECK-NEXT: %polly.access.B = getelementptr i16, i16* %polly.access.cast.B, i64 1024 ; CHECK-NEXT: %polly.access.B = getelementptr i16, i16* %polly.access.cast.B, i64 1024
; ;
; We should never access %B as an i32 pointer: ; We should never access %B as an i32 pointer:
Show All 35 Lines

test/Isl/CodeGen/aliasing_different_pointer_types.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Check that we cast the different pointer types correctly before we compare ; Check that we cast the different pointer types correctly before we compare
; them in the RTC's. We use i8* as max pointer type. ; them in the RTC's. We use i8* as max pointer type.
; ;
; CHECK: polly.split_new_and_old: ; CHECK: polly.split_new_and_old:
; CHECK: %polly.access.B = getelementptr float*, float** %B, i64 1024 ; CHECK: %polly.access.B = getelementptr float*, float** %B, i64 1024
; CHECK: %polly.access.A = getelementptr double*, double** %A, i64 0 ; CHECK: %polly.access.A = getelementptr double*, double** %A, i64 0
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/CodeGen/aliasing_multidimensional_access.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; Check that we calculate the maximal access into array A correctly and track the overflow state. ; Check that we calculate the maximal access into array A correctly and track the overflow state.
; ;
; CHECK: %[[TMP0:[._0-9a-zA-Z]*]] = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 99, i64 %m) ; CHECK: %[[TMP0:[._0-9a-zA-Z]*]] = call { i64, i1 } @llvm.smul.with.overflow.i64(i64 99, i64 %m)
; CHECK: %[[TMP0O:[._0-9a-zA-Z]*]] = extractvalue { i64, i1 } %[[TMP0]], 1 ; CHECK: %[[TMP0O:[._0-9a-zA-Z]*]] = extractvalue { i64, i1 } %[[TMP0]], 1
; CHECK: %[[OS0:[._0-9a-zA-Z]*]] = or i1 {{[^,]*}}, %[[TMP0O]] ; CHECK: %[[OS0:[._0-9a-zA-Z]*]] = or i1 {{[^,]*}}, %[[TMP0O]]
; CHECK: %[[TMP0R:[._0-9a-zA-Z]*]] = extractvalue { i64, i1 } %[[TMP0]], 0 ; CHECK: %[[TMP0R:[._0-9a-zA-Z]*]] = extractvalue { i64, i1 } %[[TMP0]], 0
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/Isl/CodeGen/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
; CHECK: %[[Cext:[._a-zA-Z0-9]*]] = sext i32 %c to i64 ; CHECK: %[[Cext:[._a-zA-Z0-9]*]] = sext i32 %c to i64
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Isl/CodeGen/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
; CHECK: %[[Ctx:[._a-zA-Z0-9]*]] = and i1 true ; CHECK: %[[Ctx:[._a-zA-Z0-9]*]] = and i1 true
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Isl/CodeGen/aliasing_struct_element.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; We should only access (or compute the address of) "the first element" of %S ; We should only access (or compute the address of) "the first element" of %S
; as it is a single struct not a struct array. The maximal access to S, thus ; as it is a single struct not a struct array. The maximal access to S, thus
; S->B[1023] is for ScalarEvolution an access with offset of 1423, 1023 for the ; S->B[1023] is for ScalarEvolution an access with offset of 1423, 1023 for the
; index inside the B part of S and 400 to skip the Dummy array in S. Note that ; index inside the B part of S and 400 to skip the Dummy array in S. Note that
; these numbers are relative to the actual type of &S->B[i] (char*) not to the ; these numbers are relative to the actual type of &S->B[i] (char*) not to the
; type of S (struct st *) or something else. ; type of S (struct st *) or something else.
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/Isl/CodeGen/alignment.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Check that the special alignment information is kept ; Check that the special alignment information is kept
; ;
; CHECK: align 8 ; CHECK: align 8
; CHECK: align 8 ; CHECK: align 8
; ;
; void jd(int *A) { ; void jd(int *A) {
Show All 28 Lines

test/Isl/CodeGen/annotated_alias_scopes.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --check-prefix=SCOPES
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=SCOPES ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=SCOPES
; ;
; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way. ; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way.
; ;
; SCOPES-LABEL: polly.stmt.for.body: ; SCOPES-LABEL: polly.stmt.for.body:
; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar ; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar
; SCOPES: load i32, i32* %[[BIdx]], align 4, !alias.scope ![[AliasScopeB:[0-9]*]], !noalias ![[NoAliasB:[0-9]*]] ; SCOPES: load i32, i32* %[[BIdx]], align 4, !alias.scope ![[AliasScopeB:[0-9]*]], !noalias ![[NoAliasB:[0-9]*]]
; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar ; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/Isl/CodeGen/blas_sscal_simplified.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
; ;
; Regression test for a bug in the runtime check generation. ; Regression test for a bug in the runtime check generation.
; This was extracted from the blas testcase. It crashed in one ; This was extracted from the blas testcase. It crashed in one
; part of the runtime check generation at some point. To be ; part of the runtime check generation at some point. To be
; precise, we couldn't find a suitable block to put the RTC code in. ; precise, we couldn't find a suitable block to put the RTC code in.
; ;
Show All 36 Lines

test/Isl/CodeGen/conflict-between-loop-invariant-code-hosting-and-escape-map-computation.ll

; RUN: opt %loadPolly -polly-process-unprofitable -disable-output \
MeinersburUnsubmitted
Not Done
ReplyInline Actions

Could you can tell your script to remove -polly-process-unprofitable, which is added by %loadPolly anyway?

Meinersbur: Could you can tell your script to remove `-polly-process-unprofitable`, which is added by…
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-codegen < %s ; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-codegen < %s
; ;
; CHECK: store i32 %tmp14_p_scalar_, i32* %tmp14.s2a ; CHECK: store i32 %tmp14_p_scalar_, i32* %tmp14.s2a
; CHECK: %tmp14.final_reload = load i32, i32* %tmp14.s2a ; CHECK: %tmp14.final_reload = load i32, i32* %tmp14.s2a
; CHECK: %tmp17b.final_reload = load i32, i32* %tmp17b.preload.s2a ; CHECK: %tmp17b.final_reload = load i32, i32* %tmp17b.preload.s2a
; CHECK: %tmp17.final_reload = load i32, i32* %tmp17.preload.s2a ; CHECK: %tmp17.final_reload = load i32, i32* %tmp17.preload.s2a
; ;
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 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/CodeGen/constant_condition.ll

; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(polly-prepare,scop(print<polly-ast>))" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
;RUN: opt %loadPolly -polly-prepare -polly-ast -analyze < %s | FileCheck %s ;RUN: opt %loadPolly -polly-prepare -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;int A[1]; ;int A[1];
; ;
;void constant_condition () { ;void constant_condition () {
; int a = 0; ; int a = 0;
; int b = 0; ; int b = 0;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/CodeGen/create-conditional-scop.ll

; RUN: opt %loadPolly -verify-loop-info < %s -S -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -verify-loop-info < %s -S | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -verify-loop-info < %s -S | FileCheck %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
@A = common global [1536 x float] zeroinitializer @A = common global [1536 x float] zeroinitializer
; This test case used to fail, because we did not add the newly generated basic ; This test case used to fail, because we did not add the newly generated basic
; block %polly.start as a basic block to the surrounding loop. ; block %polly.start as a basic block to the surrounding loop.
Show All 24 Lines

test/Isl/CodeGen/dead_invariant_load_instruction_referenced_by_parameter_1.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
; ;
; Check we do not crash even though the dead %tmp8 is referenced by a parameter ; Check we do not crash even though the dead %tmp8 is referenced by a parameter
; and we do not pre-load it (as it is dead). ; and we do not pre-load it (as it is dead).
; ;
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"
%struct.hoge = type { %struct.widget*, i32, i32, i32, %struct.hoge*, %struct.hoge*, %struct.barney, %struct.ham, %struct.wombat } %struct.hoge = type { %struct.widget*, i32, i32, i32, %struct.hoge*, %struct.hoge*, %struct.barney, %struct.ham, %struct.wombat }
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

test/Isl/CodeGen/dead_invariant_load_instruction_referenced_by_parameter_2.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
; ;
; Check we do not crash even though there is a dead load that is referenced by ; Check we do not crash even though there is a dead load that is referenced by
; a parameter and we do not pre-load it (as it is dead). ; a parameter and we do not pre-load it (as it is dead).
; ;
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"
@REGISTER = external global [10 x i32], align 16 @REGISTER = external global [10 x i32], align 16
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

test/Isl/CodeGen/debug-intrinsics.ll

; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-analyze-read-only-scalars=false -polly-codegen -S < %s | \ ; RUN: -polly-analyze-read-only-scalars=false -polly-codegen -S < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-analyze-read-only-scalars=true -polly-codegen -S < %s | \ ; RUN: -polly-analyze-read-only-scalars=true -polly-codegen -S < %s | \
; RUN: FileCheck %s ; RUN: 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"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(float* %A, i64 %N) #0 !dbg !4 { define void @foo(float* %A, i64 %N) #0 !dbg !4 {
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/Isl/CodeGen/dominance_problem_after_early_codegen_bailout.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -analyze < %s
; ;
; This caused dominance problems at some point as we do bail out during ; This caused dominance problems at some point as we do bail out during
; code generation. Just verify it runs through. ; code generation. Just verify it runs through.
; ;
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"
%struct.hashheader.0.5.10.165.180.185 = type { i16, i16, i16, i16, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, [5 x i8], [13 x i8], i8, i8, i8, [228 x i16], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [128 x i8], [100 x [11 x i8]], [100 x i32], [100 x i32], i16 } %struct.hashheader.0.5.10.165.180.185 = type { i16, i16, i16, i16, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, [5 x i8], [13 x i8], i8, i8, i8, [228 x i16], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [128 x i8], [100 x [11 x i8]], [100 x i32], [100 x i32], i16 }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/Isl/CodeGen/entry_with_trivial_phi.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -S < %s ; RUN: opt %loadPolly -polly-codegen -S < %s
; ;
; The entry of this scop's simple region (entry.split => for.end) has an trivial ; The entry of this scop's simple region (entry.split => for.end) has an trivial
; PHI node. LCSSA may create such PHI nodes. This is a breakdown of this case in ; PHI node. LCSSA may create such PHI nodes. This is a breakdown of this case in
; the function 'Laguerre_With_Deflation' of oggenc from LLVM's test-suite. ; the function 'Laguerre_With_Deflation' of oggenc from LLVM's test-suite.
; ;
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 33 Lines

test/Isl/CodeGen/entry_with_trivial_phi_other_bb.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; The entry of this scop's simple region (entry.split => for.end) has an trivial ; The entry of this scop's simple region (entry.split => for.end) has an trivial
; PHI node that is used in a different of the scop region. LCSSA may create such ; PHI node that is used in a different of the scop region. LCSSA may create such
; PHI nodes. This is a breakdown of this case in the function 'mp_unexp_sub' of ; PHI nodes. This is a breakdown of this case in the function 'mp_unexp_sub' of
; pifft from LLVM's test-suite. ; pifft from LLVM's test-suite.
; ;
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 30 Lines

test/Isl/CodeGen/error-stmt-in-non-affine-region.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
; ;
; CHECK-LABEL: polly.stmt.if.then: ; CHECK-LABEL: polly.stmt.if.then:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
; 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++)
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Isl/CodeGen/error_block_contains_invalid_memory_access.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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"
%struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322 = type { 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, [16 x [16 x i16]], [6 x [32 x i32]], [16 x [16 x i32]], [4 x [12 x [4 x [4 x i32]]]], [16 x i32], i8**, i32*, i32***, i32**, i32, i32, i32, i32, %struct.Slice.8.29.50.239.344.554.596.848.995.1205.2066.2150.2171.2234.2255.2276.2318*, %struct.macroblock.9.30.51.240.345.555.597.849.996.1206.2067.2151.2172.2235.2256.2277.2319*, i32, i32, i32, i32, i32, i32, %struct.DecRefPicMarking_s.10.31.52.241.346.556.598.850.997.1207.2068.2152.2173.2236.2257.2278.2320*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x 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, 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, i32, i32, i32, i32, i32, i32, [3 x [2 x i32]], [3 x [2 x i32]], i32, i32, i64, i64, %struct.timeb.11.32.53.242.347.557.599.851.998.1208.2069.2153.2174.2237.2258.2279.2321, %struct.timeb.11.32.53.242.347.557.599.851.998.1208.2069.2153.2174.2237.2258.2279.2321, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 } %struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322 = type { 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, [16 x [16 x i16]], [6 x [32 x i32]], [16 x [16 x i32]], [4 x [12 x [4 x [4 x i32]]]], [16 x i32], i8**, i32*, i32***, i32**, i32, i32, i32, i32, %struct.Slice.8.29.50.239.344.554.596.848.995.1205.2066.2150.2171.2234.2255.2276.2318*, %struct.macroblock.9.30.51.240.345.555.597.849.996.1206.2067.2151.2172.2235.2256.2277.2319*, i32, i32, i32, i32, i32, i32, %struct.DecRefPicMarking_s.10.31.52.241.346.556.598.850.997.1207.2068.2152.2173.2236.2257.2278.2320*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x 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, 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, i32, i32, i32, i32, i32, i32, [3 x [2 x i32]], [3 x [2 x i32]], i32, i32, i64, i64, %struct.timeb.11.32.53.242.347.557.599.851.998.1208.2069.2153.2174.2237.2258.2279.2321, %struct.timeb.11.32.53.242.347.557.599.851.998.1208.2069.2153.2174.2237.2258.2279.2321, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
%struct.Slice.8.29.50.239.344.554.596.848.995.1205.2066.2150.2171.2234.2255.2276.2318 = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313*, %struct.MotionInfoContexts.5.26.47.236.341.551.593.845.992.1202.2063.2147.2168.2231.2252.2273.2315*, %struct.TextureInfoContexts.6.27.48.237.342.552.594.846.993.1203.2064.2148.2169.2232.2253.2274.2316*, i32, i32*, i32*, i32*, i32, i32*, i32*, i32*, i32 (%struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322*, %struct.inp_par.7.28.49.238.343.553.595.847.994.1204.2065.2149.2170.2233.2254.2275.2317*)*, i32, i32, i32, i32 } %struct.Slice.8.29.50.239.344.554.596.848.995.1205.2066.2150.2171.2234.2255.2276.2318 = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313*, %struct.MotionInfoContexts.5.26.47.236.341.551.593.845.992.1202.2063.2147.2168.2231.2252.2273.2315*, %struct.TextureInfoContexts.6.27.48.237.342.552.594.846.993.1203.2064.2148.2169.2232.2253.2274.2316*, i32, i32*, i32*, i32*, i32, i32*, i32*, i32*, i32 (%struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322*, %struct.inp_par.7.28.49.238.343.553.595.847.994.1204.2065.2149.2170.2233.2254.2275.2317*)*, i32, i32, i32, i32 }
%struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313 = type { %struct.Bitstream.0.21.42.231.336.546.588.840.987.1197.2058.2142.2163.2226.2247.2268.2310*, %struct.DecodingEnvironment.1.22.43.232.337.547.589.841.988.1198.2059.2143.2164.2227.2248.2269.2311, i32 (%struct.syntaxelement.2.23.44.233.338.548.590.842.989.1199.2060.2144.2165.2228.2249.2270.2312*, %struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322*, %struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313*)* } %struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313 = type { %struct.Bitstream.0.21.42.231.336.546.588.840.987.1197.2058.2142.2163.2226.2247.2268.2310*, %struct.DecodingEnvironment.1.22.43.232.337.547.589.841.988.1198.2059.2143.2164.2227.2248.2269.2311, i32 (%struct.syntaxelement.2.23.44.233.338.548.590.842.989.1199.2060.2144.2165.2228.2249.2270.2312*, %struct.img_par.12.33.54.243.348.558.600.852.999.1209.2070.2154.2175.2238.2259.2280.2322*, %struct.datapartition.3.24.45.234.339.549.591.843.990.1200.2061.2145.2166.2229.2250.2271.2313*)* }
%struct.Bitstream.0.21.42.231.336.546.588.840.987.1197.2058.2142.2163.2226.2247.2268.2310 = type { i32, i32, i32, i32, i8*, i32 } %struct.Bitstream.0.21.42.231.336.546.588.840.987.1197.2058.2142.2163.2226.2247.2268.2310 = type { i32, i32, i32, i32, i8*, i32 }
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/Isl/CodeGen/fortran_array_runtime_size_generation.ll

; Check that the runtime size computation is generated for Fortran arrays. ; Check that the runtime size computation is generated for Fortran arrays.
; Regular code generation backend: ; Regular code generation backend:
; RUN: opt %loadPolly -S -polly-detect-fortran-arrays -passes=polly-codegen < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-detect-fortran-arrays \ ; RUN: opt %loadPolly -S -polly-detect-fortran-arrays \
; RUN: -polly-codegen < %s | FileCheck %s ; RUN: -polly-codegen < %s | FileCheck %s
; What the input fortran code should look like. NOTE: this is fake, the ; What the input fortran code should look like. NOTE: this is fake, the
; .ll file was hand-written. ; .ll file was hand-written.
; ;
; MODULE testmod ; MODULE testmod
; USE data_parameters, ONLY : & ; USE data_parameters, ONLY : &
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/Isl/CodeGen/getNumberOfIterations.ll

; RUN: opt %loadPolly -polly-vectorizer=polly < %s -S -passes=polly-codegen \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-vectorizer=polly -polly-codegen \ ; RUN: opt %loadPolly -polly-vectorizer=polly -polly-codegen \
; RUN: < %s -S | FileCheck %s ; RUN: < %s -S | FileCheck %s
; #pragma known-parallel ; #pragma known-parallel
; for (int c0 = 0; c0 <= min(15, N - 1); c0 += 1) ; for (int c0 = 0; c0 <= min(15, N - 1); c0 += 1)
; Stmt_if_then(c0); ; Stmt_if_then(c0);
; CHECK: polly.stmt.if.then: ; preds = %polly.loop_header ; CHECK: polly.stmt.if.then: ; preds = %polly.loop_header
Show All 31 Lines

test/Isl/CodeGen/hoisted_load_escapes_through_phi.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=false \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen \ ; RUN: opt %loadPolly -S -polly-codegen \
; RUN: -polly-invariant-load-hoisting=false < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=false < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen \ ; RUN: opt %loadPolly -S -polly-codegen \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; Check that we generate valid code even if the load of cont_STACKPOINTER is ; Check that we generate valid code even if the load of cont_STACKPOINTER is
; hoisted in one SCoP and used (through the phi node %tmp2). ; hoisted in one SCoP and used (through the phi node %tmp2).
; ;
; CHECK: polly.start ; CHECK: polly.start
; CHECK: polly.start ; CHECK: polly.start
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/Isl/CodeGen/hoisting_1.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -disable-output \
; RUN: -passes=polly-codegen -aa-pipeline=type-based-aa %s 2>&1
; RUN: opt %loadPolly -tbaa -polly-codegen -polly-allow-differing-element-types -disable-output %s ; RUN: opt %loadPolly -tbaa -polly-codegen -polly-allow-differing-element-types -disable-output %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"
%struct.hoge = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32, %struct.wibble*, i32, i32, i32, i32, double, i32, i32, i32, %struct.foo.1*, [4 x %struct.hoge.2*], [4 x %struct.blam*], [4 x %struct.blam*], [16 x i8], [16 x i8], [16 x i8], i32, %struct.barney.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i16, i16, i32, i32, i32, i32, i32, i32, i32, [4 x %struct.foo.1*], i32, i32, i32, [10 x i32], i32, i32, i32, i32, %struct.foo.4*, %struct.wombat.5*, %struct.blam.6*, %struct.foo.7*, %struct.bar*, %struct.wibble.8*, %struct.barney.9*, %struct.hoge.10*, %struct.bar.11* } %struct.hoge = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32, %struct.wibble*, i32, i32, i32, i32, double, i32, i32, i32, %struct.foo.1*, [4 x %struct.hoge.2*], [4 x %struct.blam*], [4 x %struct.blam*], [16 x i8], [16 x i8], [16 x i8], i32, %struct.barney.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i16, i16, i32, i32, i32, i32, i32, i32, i32, [4 x %struct.foo.1*], i32, i32, i32, [10 x i32], i32, i32, i32, i32, %struct.foo.4*, %struct.wombat.5*, %struct.blam.6*, %struct.foo.7*, %struct.bar*, %struct.wibble.8*, %struct.barney.9*, %struct.hoge.10*, %struct.bar.11* }
%struct.widget = type { void (%struct.quux*)*, void (%struct.quux*, i32)*, void (%struct.quux*)*, void (%struct.quux*, i8*)*, void (%struct.quux*)*, i32, %struct.hoge.0, i32, i64, i8**, i32, i8**, i32, i32 } %struct.widget = type { void (%struct.quux*)*, void (%struct.quux*, i32)*, void (%struct.quux*)*, void (%struct.quux*, i8*)*, void (%struct.quux*)*, i32, %struct.hoge.0, i32, i64, i8**, i32, i8**, i32, i32 }
%struct.quux = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32 } %struct.quux = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32 }
%struct.hoge.0 = type { [8 x i32], [48 x i8] } %struct.hoge.0 = type { [8 x i32], [48 x i8] }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Isl/CodeGen/hoisting_2.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -disable-output \
; RUN: -passes=polly-codegen -aa-pipeline=type-based-aa %s 2>&1
; RUN: opt %loadPolly -tbaa -polly-codegen -polly-allow-differing-element-types -disable-output %s ; RUN: opt %loadPolly -tbaa -polly-codegen -polly-allow-differing-element-types -disable-output %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"
%struct.hoge = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32, %struct.wibble*, i32, i32, i32, i32, double, i32, i32, i32, %struct.foo.1*, [4 x %struct.hoge.2*], [4 x %struct.blam*], [4 x %struct.blam*], [16 x i8], [16 x i8], [16 x i8], i32, %struct.barney.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i16, i16, i32, i32, i32, i32, i32, i32, i32, [4 x %struct.foo.1*], i32, i32, i32, [10 x i32], i32, i32, i32, i32, %struct.foo.4*, %struct.wombat.5*, %struct.blam.6*, %struct.foo.7*, %struct.bar*, %struct.wibble.8*, %struct.barney.9*, %struct.hoge.10*, %struct.bar.11* } %struct.hoge = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32, %struct.wibble*, i32, i32, i32, i32, double, i32, i32, i32, %struct.foo.1*, [4 x %struct.hoge.2*], [4 x %struct.blam*], [4 x %struct.blam*], [16 x i8], [16 x i8], [16 x i8], i32, %struct.barney.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8, i16, i16, i32, i32, i32, i32, i32, i32, i32, [4 x %struct.foo.1*], i32, i32, i32, [10 x i32], i32, i32, i32, i32, %struct.foo.4*, %struct.wombat.5*, %struct.blam.6*, %struct.foo.7*, %struct.bar*, %struct.wibble.8*, %struct.barney.9*, %struct.hoge.10*, %struct.bar.11* }
%struct.widget = type { void (%struct.quux*)*, void (%struct.quux*, i32)*, void (%struct.quux*)*, void (%struct.quux*, i8*)*, void (%struct.quux*)*, i32, %struct.hoge.0, i32, i64, i8**, i32, i8**, i32, i32 } %struct.widget = type { void (%struct.quux*)*, void (%struct.quux*, i32)*, void (%struct.quux*)*, void (%struct.quux*, i8*)*, void (%struct.quux*)*, i32, %struct.hoge.0, i32, i64, i8**, i32, i8**, i32, i32 }
%struct.quux = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32 } %struct.quux = type { %struct.widget*, %struct.barney*, %struct.foo*, i32, i32 }
%struct.hoge.0 = type { [8 x i32], [48 x i8] } %struct.hoge.0 = type { [8 x i32], [48 x i8] }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/Isl/CodeGen/if-conditions-in-vector-code.ll

; RUN: opt %loadPolly -disable-output -polly-vectorizer=polly \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=AST
; RUN: opt %loadPolly -analyze -polly-ast -polly-vectorizer=polly < %s | \ ; RUN: opt %loadPolly -analyze -polly-ast -polly-vectorizer=polly < %s | \
; RUN: FileCheck %s -check-prefix=AST ; RUN: FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-vectorizer=polly -S -passes=polly-codegen < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly -S < %s | \ ; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly -S < %s | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 0; i < 16; i++) { ; for (long i = 0; i < 16; i++) {
; if (i % 2) ; if (i % 2)
; A[i] += 2; ; A[i] += 2;
; if (i % 3) ; if (i % 3)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Isl/CodeGen/inner_scev_sdiv_1.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -S -polly-codegen < %s ; RUN: opt %loadPolly -S -polly-codegen < %s
; ;
; Excerpt from the test-suite's oggenc reduced using bugpoint. ; Excerpt from the test-suite's oggenc reduced using bugpoint.
; ;
; It features a SCEV value using %div44 for the inner loop (for.body.51 => ; It features a SCEV value using %div44 for the inner loop (for.body.51 =>
; for.cond.60.preheader) that is computed within the body of the outer loop ; for.cond.60.preheader) that is computed within the body of the outer loop
; (for.cond.30.preheader => for.cond.60.preheader). CodeGenerator would add a ; (for.cond.30.preheader => for.cond.60.preheader). CodeGenerator would add a
; computation of the SCEV to before the scop that references %div44, which is ; computation of the SCEV to before the scop that references %div44, which is
Show All 39 Lines

test/Isl/CodeGen/inner_scev_sdiv_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; The SCEV expression in this test case refers to a sequence of sdiv ; The SCEV expression in this test case refers to a sequence of sdiv
; instructions, which are part of different bbs in the SCoP. When code ; instructions, which are part of different bbs in the SCoP. When code
; generating the parameter expressions, the code that is generated by the SCEV ; generating the parameter expressions, the code that is generated by the SCEV
; expander has still references to the in-scop instructions, which was invalid. ; expander has still references to the in-scop instructions, which was invalid.
; ;
; CHECK: polly.start ; CHECK: polly.start
Show All 36 Lines

test/Isl/CodeGen/inner_scev_sdiv_3.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; This test case has a inner SCEV sdiv that will escape the SCoP. Just check we ; This test case has a inner SCEV sdiv that will escape the SCoP. Just check we
; do not crash and generate valid code. ; do not crash and generate valid code.
; ;
; CHECK: polly.split_new_and_old: ; CHECK: polly.split_new_and_old:
; ;
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
Show All 38 Lines

test/Isl/CodeGen/inner_scev_sdiv_in_lb.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-scops -analyze < %s | FileCheck %s ; RUN: -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --check-prefix=CODEGEN
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: -S -polly-codegen < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; CHECK: [N] -> { Stmt_bb11[i0, i1] : i0 < N and i1 >= 0 and 3i1 <= -3 + i0 }; ; CHECK: [N] -> { Stmt_bb11[i0, i1] : i0 < N and i1 >= 0 and 3i1 <= -3 + i0 };
; CODEGEN: polly ; CODEGEN: polly
; ;
; 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++)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Isl/CodeGen/inner_scev_sdiv_in_lb_invariant.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen \ ; RUN: opt %loadPolly -S -polly-codegen \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; Check that this will not crash our code generation. ; Check that this will not crash our code generation.
; ;
; CHECK: polly.start: ; CHECK: polly.start:
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
Show All 34 Lines

test/Isl/CodeGen/inner_scev_sdiv_in_rtc.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; ;
; This will just check that we generate valid code here. ; This will just check that we generate valid code here.
; ;
; CHECK: polly.start: ; CHECK: polly.start:
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
Show All 33 Lines

test/Isl/CodeGen/intrinsics_lifetime.ll

; RUN: opt %loadPolly -S -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 \
; RUN: | FileCheck %s --allow-empty
; RUN: opt %loadPolly -basicaa -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -S < %s | FileCheck %s
; ;
; Verify that we remove the lifetime markers from everywhere. ; Verify that we remove the lifetime markers from everywhere.
; ;
; CHECK-NOT: call void @llvm.lifetime.start ; CHECK-NOT: call void @llvm.lifetime.start
; CHECK-NOT: call void @llvm.lifetime.end ; CHECK-NOT: call void @llvm.lifetime.end
; ;
; int A[1024]; ; int A[1024];
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/Isl/CodeGen/intrinsics_misc.ll

; RUN: opt %loadPolly -S -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -S < %s | FileCheck %s
; ;
; Verify that we remove the misc intrinsics from the optimized SCoP. ; Verify that we remove the misc intrinsics from the optimized SCoP.
; ;
; CHECK: for.body: ; CHECK: for.body:
; CHECK: call {}* @llvm.invariant.start ; CHECK: call {}* @llvm.invariant.start
; CHECK: for.body4: ; CHECK: for.body4:
; CHECK: call void @llvm.assume ; CHECK: call void @llvm.assume
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

test/Isl/CodeGen/inv-load-lnt-crash-wrong-order-2.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; This crashed our codegen at some point, verify it runs through ; This crashed our codegen at some point, verify it runs through
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
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 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/Isl/CodeGen/inv-load-lnt-crash-wrong-order-3.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; This crashed our codegen at some point, verify it runs through ; This crashed our codegen at some point, verify it runs through
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
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 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/Isl/CodeGen/inv-load-lnt-crash-wrong-order.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; This crashed our codegen at some point, verify it runs through ; This crashed our codegen at some point, verify it runs through
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
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 20 Lines • Show All 83 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant-load-dimension.ll

; RUN: opt %loadPolly < %s -disable-output -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting "-passes=print<polly-function-scops>" \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly < %s -analyze -polly-scops -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=SCOPS ; RUN: opt %loadPolly < %s -analyze -polly-scops -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly -S < %s -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting -passes=polly-codegen 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -S < %s -polly-codegen -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -S < %s -polly-codegen -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
%S = type { i32, i32, [12 x %L] } %S = type { i32, i32, [12 x %L] }
%L = type { i32, i32, double, i32, i32, i32, i32, i32 } %L = type { i32, i32, double, i32, i32, i32, i32, i32 }
define void @test(%S* %cpi, i1 %b) { define void @test(%S* %cpi, i1 %b) {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant-load-preload-base-pointer-origin-first.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s ; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s
; ;
; Check that we generate valid code as we did non preload the base pointer ; Check that we generate valid code as we did non preload the base pointer
; origin of %tmp4 at some point. ; origin of %tmp4 at some point.
; ;
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"
@TOP = external global i64*, align 8 @TOP = external global i64*, align 8
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_cannot_handle_void.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true %s | FileCheck %s
; ;
; The offset of the %tmp1 load wrt. to %buff (62 bytes) is not divisible ; The offset of the %tmp1 load wrt. to %buff (62 bytes) is not divisible
; by the type size (i32 = 4 bytes), thus we will have to represent %buff ; by the type size (i32 = 4 bytes), thus we will have to represent %buff
; with a smaller type. In this case i16 is sufficient to represent the ; with a smaller type. In this case i16 is sufficient to represent the
; 62 byte offset accurately. ; 62 byte offset accurately.
; ;
; SCOP: Invariant Accesses: { ; SCOP: Invariant Accesses: {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.B = getelementptr i32, i32* %B, i64 0 ; CHECK-NEXT: %polly.access.B = getelementptr i32, i32* %B, i64 0
; CHECK-NEXT: %polly.access.B.load = load i32, i32* %polly.access.B ; CHECK-NEXT: %polly.access.B.load = load i32, i32* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar
Show All 31 Lines

test/Isl/CodeGen/invariant_load_address_space.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.B = getelementptr i32, i32 addrspace(1)* %B, i64 0 ; CHECK-NEXT: %polly.access.B = getelementptr i32, i32 addrspace(1)* %B, i64 0
; CHECK-NOT: addrspacecast ; CHECK-NOT: addrspacecast
; CHECK-NEXT: %polly.access.B.load = load i32, i32 addrspace(1)* %polly.access.B ; CHECK-NEXT: %polly.access.B.load = load i32, i32 addrspace(1)* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
Show All 32 Lines

test/Isl/CodeGen/invariant_load_alias_metadata.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; ;
; This test case checks whether Polly generates alias metadata in case of ; This test case checks whether Polly generates alias metadata in case of
; the ublas gemm kernel and polly-invariant-load-hoisting. ; the ublas gemm kernel and polly-invariant-load-hoisting.
; ;
; CHECK: store float 4.200000e+01, float* %polly.access.A.load, !alias.scope !3, !noalias !4 ; CHECK: store float 4.200000e+01, float* %polly.access.A.load, !alias.scope !3, !noalias !4
; ;
Show All 24 Lines

test/Isl/CodeGen/invariant_load_base_pointer.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.BPLoc = getelementptr i32*, i32** %BPLoc, i64 0 ; CHECK-NEXT: %polly.access.BPLoc = getelementptr i32*, i32** %BPLoc, i64 0
; CHECK-NEXT: %polly.access.BPLoc.load = load i32*, i32** %polly.access.BPLoc ; CHECK-NEXT: %polly.access.BPLoc.load = load i32*, i32** %polly.access.BPLoc
; ;
; CHECK-LABEL: polly.stmt.bb2: ; CHECK-LABEL: polly.stmt.bb2:
; CHECK-NEXT: %scevgep = getelementptr i32, i32* %polly.access.BPLoc.load, i64 %polly.indvar ; CHECK-NEXT: %scevgep = getelementptr i32, i32* %polly.access.BPLoc.load, i64 %polly.indvar
Show All 30 Lines

test/Isl/CodeGen/invariant_load_base_pointer_conditional.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %0 = sext i32 %N to i64 ; CHECK-NEXT: %0 = sext i32 %N to i64
; CHECK-NEXT: %1 = icmp sge i64 %0, 514 ; CHECK-NEXT: %1 = icmp sge i64 %0, 514
; CHECK-NEXT: br label %polly.preload.cond ; CHECK-NEXT: br label %polly.preload.cond
; ;
; CHECK-LABEL: polly.preload.cond: ; CHECK-LABEL: polly.preload.cond:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_base_pointer_conditional_2.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=IR
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: --polly-overflow-tracking=always -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=IRA
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true --polly-overflow-tracking=always < %s | FileCheck %s --check-prefix=IRA ; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true --polly-overflow-tracking=always < %s | FileCheck %s --check-prefix=IRA
; ;
; As (p + q) can overflow we have to check that we load from ; As (p + q) can overflow we have to check that we load from
; I[p + q] only if it does not. ; I[p + q] only if it does not.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] }; ; CHECK-NEXT: [N, p, q] -> { Stmt_for_body[i0] -> MemRef_I[p + q] };
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_canonicalize_array_baseptrs.ll

; RUN: opt %loadPolly -S < %s -polly-invariant-load-hoisting \
; RUN: -passes=polly-codegen 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s \ ; RUN: opt %loadPolly -polly-codegen -S < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: %polly.access.A = getelementptr float*, float** %A, i64 0 ; CHECK: %polly.access.A = getelementptr float*, float** %A, i64 0
; CHECK: %polly.access.A.load = load float*, float** %polly.access.A ; CHECK: %polly.access.A.load = load float*, float** %polly.access.A
; CHECK: store float 4.200000e+01, float* %polly.access.A.load ; CHECK: store float 4.200000e+01, float* %polly.access.A.load
; CHECK: store float 4.800000e+01, float* %polly.access.A.load ; CHECK: store float 4.800000e+01, float* %polly.access.A.load
Show All 28 Lines

test/Isl/CodeGen/invariant_load_condition.ll

; RUN: opt %loadPolly -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting=true -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK-NEXT: %polly.access.C = getelementptr i32, i32* %C, i64 0 ; CHECK-NEXT: %polly.access.C = getelementptr i32, i32* %C, i64 0
; CHECK-NEXT: %polly.access.C.load = load i32, i32* %polly.access.C ; CHECK-NEXT: %polly.access.C.load = load i32, i32* %polly.access.C
; CHECK-NOT: %polly.access.C.load = load i32, i32* %polly.access.C ; CHECK-NOT: %polly.access.C.load = load i32, i32* %polly.access.C
; ;
; CHECK-LABEL: polly.cond: ; CHECK-LABEL: polly.cond:
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_different_sized_types.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -polly-allow-differing-element-types -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S \
; RUN: -polly-allow-differing-element-types < %s | FileCheck %s ; RUN: -polly-allow-differing-element-types < %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"
; CHECK: polly.preload.begin: ; preds = %polly.split_new_and_old ; CHECK: polly.preload.begin: ; preds = %polly.split_new_and_old
; CHECK-NEXT: %polly.access.cast.tmp2 = bitcast %struct.hoge* %tmp2 to i32* ; CHECK-NEXT: %polly.access.cast.tmp2 = bitcast %struct.hoge* %tmp2 to i32*
; CHECK-NEXT: %polly.access.tmp2 = getelementptr i32, i32* %polly.access.cast.tmp2, i64 1 ; CHECK-NEXT: %polly.access.tmp2 = getelementptr i32, i32* %polly.access.cast.tmp2, i64 1
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_escaping.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; int f(int *A, int *B) { ; int f(int *A, int *B) {
; // Possible aliasing between A and B but if not then *B would be ; // Possible aliasing between A and B but if not then *B would be
; // invariant. We assume this and hoist *B but need to use a merged ; // invariant. We assume this and hoist *B but need to use a merged
; // version in the return. ; // version in the return.
; int i = 0; ; int i = 0;
; int x = 0; ; int x = 0;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_escaping_second_scop.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-process-unprofitable -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; void fence(void); ; void fence(void);
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
; int i = 0; ; int i = 0;
; int x = 0; ; int x = 0;
; ;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_hoist_alignment.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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" 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 triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x i32] zeroinitializer, align 16 @A = common global [1024 x i32] zeroinitializer, align 16
@B = common global [1024 x i32] zeroinitializer, align 16 @B = common global [1024 x i32] zeroinitializer, align 16
Show All 23 Lines

test/Isl/CodeGen/invariant_load_in_non_affine_subregion.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; This crashed at some point as the invariant load is in a non-affine ; This crashed at some point as the invariant load is in a non-affine
; subregion. Just check it does not anymore. ; subregion. Just check it does not anymore.
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
; ModuleID = 'bugpoint-reduced-simplified.bc' ; ModuleID = 'bugpoint-reduced-simplified.bc'
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_loop_ub.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-process-unprofitable -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
; void f(int *A, int *UB) { ; void f(int *A, int *UB) {
; for (int i = 0; i < *UB; i++) ; for (int i = 0; i < *UB; i++)
; A[i] = 0; ; A[i] = 0;
; } ; }
Show All 26 Lines

test/Isl/CodeGen/invariant_load_not_executed_but_in_parameters.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s
; ;
; Check that this does not crash as the invariant load is not executed (thus ; Check that this does not crash as the invariant load is not executed (thus
; not preloaded) but still referenced by one of the parameters. ; not preloaded) but still referenced by one of the parameters.
; ;
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"
%struct.Exp.204.248.358 = type { %struct.Exp_.200.244.354*, i32, i32, i32, %struct.Exp.204.248.358*, %struct.Exp.204.248.358*, %union.anon.2.201.245.355, %union.anon.3.202.246.356, %union.anon.4.203.247.357 } %struct.Exp.204.248.358 = type { %struct.Exp_.200.244.354*, i32, i32, i32, %struct.Exp.204.248.358*, %struct.Exp.204.248.358*, %union.anon.2.201.245.355, %union.anon.3.202.246.356, %union.anon.4.203.247.357 }
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_outermost.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; CHECK: polly.start ; CHECK: polly.start
; void f(int *A) { ; void f(int *A) {
; if (*A > 42) ; if (*A > 42)
; *A = *A + 1; ; *A = *A + 1;
; else ; else
Show All 29 Lines

test/Isl/CodeGen/invariant_load_parameters_cyclic_dependence.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; SCOP: Assumed Context: ; SCOP: Assumed Context:
; SCOP-NEXT: [p_0, tmp4] -> { : } ; SCOP-NEXT: [p_0, tmp4] -> { : }
; SCOP-NEXT: Invalid Context: ; SCOP-NEXT: Invalid Context:
; SCOP-NEXT: [p_0, tmp4] -> { : p_0 > 0 and tmp4 < 0 } ; SCOP-NEXT: [p_0, tmp4] -> { : p_0 > 0 and tmp4 < 0 }
; SCOP-NEXT: p0: (%N * %M) ; SCOP-NEXT: p0: (%N * %M)
; SCOP-NEXT: p1: %tmp4 ; SCOP-NEXT: p1: %tmp4
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_load_ptr_ptr_noalias.ll

; RUN: opt %loadPolly -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting=true -polly-ignore-aliasing -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK: %polly.access.A = getelementptr i32**, i32*** %A, i64 42 ; CHECK: %polly.access.A = getelementptr i32**, i32*** %A, i64 42
; CHECK: %polly.access.A.load = load i32**, i32*** %polly.access.A ; CHECK: %polly.access.A.load = load i32**, i32*** %polly.access.A
; CHECK: %polly.access.polly.access.A.load = getelementptr i32*, i32** %polly.access.A.load, i64 32 ; CHECK: %polly.access.polly.access.A.load = getelementptr i32*, i32** %polly.access.A.load, i64 32
; CHECK: %polly.access.polly.access.A.load.load = load i32*, i32** %polly.access.polly.access.A.load ; CHECK: %polly.access.polly.access.A.load.load = load i32*, i32** %polly.access.polly.access.A.load
; ;
Show All 36 Lines

test/Isl/CodeGen/invariant_load_scalar_dep.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -S < %s | FileCheck %s
; ;
; CHECK-LABEL: polly.preload.begin: ; CHECK-LABEL: polly.preload.begin:
; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0 ; CHECK: %polly.access.B = getelementptr i32, i32* %B, i64 0
; CHECK: %polly.access.B.load = load i32, i32* %polly.access.B ; CHECK: %polly.access.B.load = load i32, i32* %polly.access.B
; ;
; CHECK-LABEL: polly.stmt.bb2.split: ; CHECK-LABEL: polly.stmt.bb2.split:
; CHECK: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar ; CHECK: %scevgep = getelementptr i32, i32* %A, i64 %polly.indvar
Show All 36 Lines

test/Isl/CodeGen/invariant_load_scalar_escape_alloca_sharing.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s
; ;
; Verify the preloaded %tmp0 is stored and communicated in the same alloca. ; Verify the preloaded %tmp0 is stored and communicated in the same alloca.
; In this case, we do not reload %ncol.load from the scalar stack slot, but ; In this case, we do not reload %ncol.load from the scalar stack slot, but
; instead use directly the preloaded value stored in GlobalMap. ; instead use directly the preloaded value stored in GlobalMap.
; ;
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: %tmp0.preload.s2a = alloca i32 ; CHECK: %tmp0.preload.s2a = alloca i32
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_loads_from_struct_with_different_types_1.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -passes=polly-codegen\
; RUN: < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true < %s
; ;
; Check we do not crash even though we pre-load values with different types ; Check we do not crash even though we pre-load values with different types
; from the same base pointer. ; from the same base pointer.
; ;
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
%struct.FFIIRFilterCoeffs.0.3.6.12.15.27.36.54.57.84.87.90 = type { i32, float, i32*, float* } %struct.FFIIRFilterCoeffs.0.3.6.12.15.27.36.54.57.84.87.90 = type { i32, float, i32*, float* }
Show All 19 Lines

test/Isl/CodeGen/invariant_loads_from_struct_with_different_types_2.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -passes=polly-codegen\
; RUN: < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true < %s
; ;
; Check we do not crash even though we pre-load values with different types ; Check we do not crash even though we pre-load values with different types
; from the same base pointer. ; from the same base pointer.
; ;
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
%struct.FFIIRFilterCoeffs.0.3.6.63.78.81.87.102.150.162.165.168.171 = type { i32, float, i32*, float* } %struct.FFIIRFilterCoeffs.0.3.6.63.78.81.87.102.150.162.165.168.171 = type { i32, float, i32*, float* }
Show All 37 Lines

test/Isl/CodeGen/invariant_loads_ignore_parameter_bounds.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting \
; RUN: -polly-ignore-parameter-bounds -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting \
; RUN: -polly-ignore-parameter-bounds -S < %s | FileCheck %s ; RUN: -polly-ignore-parameter-bounds -S < %s | FileCheck %s
; CHECK: polly.preload.begin: ; CHECK: polly.preload.begin:
; CHECK-NEXT: %global.load = load i32, i32* @global, align 4, !alias.scope !0, !noalias !2 ; CHECK-NEXT: %global.load = load i32, i32* @global, align 4, !alias.scope !0, !noalias !2
; CHECK-NEXT: store i32 %global.load, i32* %tmp24.preload.s2a ; CHECK-NEXT: store i32 %global.load, i32* %tmp24.preload.s2a
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"
Show All 28 Lines

test/Isl/CodeGen/invariant_verify_function_failed.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=function(print<polly-detect>,scop(polly-codegen))" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; This crashed at some point as the pointer returned by the call ; This crashed at some point as the pointer returned by the call
; to @__errno_location is invariant and defined in the SCoP but not ; to @__errno_location is invariant and defined in the SCoP but not
; loaded. Therefore it is not hoisted and consequently not available ; loaded. Therefore it is not hoisted and consequently not available
; at the beginning of the SCoP where we would need it if we would try ; at the beginning of the SCoP where we would need it if we would try
; to hoist %tmp. We don't try to hoist %tmp anymore but this test still ; to hoist %tmp. We don't try to hoist %tmp anymore but this test still
; checks that this passes to code generation and produces valid code. ; checks that this passes to code generation and produces valid code.
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/Isl/CodeGen/invariant_verify_function_failed_2.ll

; RUN: opt %loadPolly -S -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly -S -polly-scops -analyze \ ; RUN: opt %loadPolly -S -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true %s \ ; RUN: -polly-invariant-load-hoisting=true %s \
; RUN: | FileCheck %s -check-prefix=SCOPS ; RUN: | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen -polly-invariant-load-hoisting=true %s | FileCheck %s
; ;
; Check we generate valid code. ; Check we generate valid code.
; SCOPS: Statements { ; SCOPS: Statements {
; SCOPS-NEXT: Stmt_if_then2457 ; SCOPS-NEXT: Stmt_if_then2457
; SCOPS-NEXT: Domain := ; SCOPS-NEXT: Domain :=
; SCOPS-NEXT: [p_0] -> { Stmt_if_then2457[] : p_0 = 1 }; ; SCOPS-NEXT: [p_0] -> { Stmt_if_then2457[] : p_0 = 1 };
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

test/Isl/CodeGen/large-numbers-in-boundary-context.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
; ;
; The boundary context contains a constant that does not fit in 64 bits. Hence, ; The boundary context contains a constant that does not fit in 64 bits. Hence,
; make sure we bail out. On certain systems, e.g. AOSP, no runtime support for ; make sure we bail out. On certain systems, e.g. AOSP, no runtime support for
; 128bit operations is available and consequently the code generation of large ; 128bit operations is available and consequently the code generation of large
; values might cause linker errors. ; values might cause linker errors.
; ;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop-invariant-load-type-mismatch.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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"
; Just make sure this test passes correctly. ; Just make sure this test passes correctly.
define void @kernel_ludcmp(double* %b, double* %y) #0 { define void @kernel_ludcmp(double* %b, double* %y) #0 {
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop_with_condition.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition() { ;void loop_with_condition() {
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop_with_condition_2.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; Verify that we actually detect this loop as the innermost loop even though ; Verify that we actually detect this loop as the innermost loop even though
; there is a conditional inside. ; there is a conditional inside.
; CHECK: #pragma simd ; CHECK: #pragma simd
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) { ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) {
; CHECK: if (c0 >= m + 1025) { ; CHECK: if (c0 >= m + 1025) {
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop_with_condition_ineq.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition_ineq() { ;void loop_with_condition_ineq() {
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop_with_condition_nested.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(scop(polly-codegen),print<loops>)" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s -check-prefix=LOOPS
; RUN: opt %loadPolly -basicaa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -basicaa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

test/Isl/CodeGen/loop_with_conditional_entry_edge_split_hard_case.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Test case to trigger the hard way of creating a unique entering ; Test case to trigger the hard way of creating a unique entering
; edge for the SCoP. It is triggered because the entering edge ; edge for the SCoP. It is triggered because the entering edge
; here: %while.begin --> %if is __not__ critical. ; here: %while.begin --> %if is __not__ critical.
; ;
; int f(void); ; int f(void);
; void jd(int b, int *A) { ; void jd(int b, int *A) {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/Isl/CodeGen/multidim-non-matching-typesize-2.ll

; RUN: opt %loadPolly -disable-basicaa -S -passes=polly-codegen < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -disable-basicaa -polly-codegen \ ; RUN: opt %loadPolly -disable-basicaa -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; CHECK: polly ; CHECK: polly
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
define void @hoge(i16* %arg, i32 %arg1, i16* %arg2) { define void @hoge(i16* %arg, i32 %arg1, i16* %arg2) {
bb: bb:
%tmp = alloca i32 %tmp = alloca i32
Show All 18 Lines

test/Isl/CodeGen/multidim-non-matching-typesize.ll

; RUN: opt %loadPolly -disable-basicaa -S -passes=polly-codegen < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -disable-basicaa -polly-codegen \ ; RUN: opt %loadPolly -disable-basicaa -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128" target datalayout = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128"
; CHECK: polly ; CHECK: polly
define void @hoge(i16* %arg, i32 %arg1) { define void @hoge(i16* %arg, i32 %arg1) {
Show All 16 Lines

test/Isl/CodeGen/multidim_2d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %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++)
Show All 34 Lines

test/Isl/CodeGen/multidim_alias_check.ll

; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %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"
; CHECK: %polly.access.sext.A = sext i32 %n to i64 ; CHECK: %polly.access.sext.A = sext i32 %n to i64
; CHECK: %polly.access.mul.A = mul i64 %polly.access.sext.A, %0 ; CHECK: %polly.access.mul.A = mul i64 %polly.access.sext.A, %0
; CHECK: %polly.access.add.A = add i64 %polly.access.mul.A, 1 ; CHECK: %polly.access.add.A = add i64 %polly.access.mul.A, 1
; CHECK: %polly.access.A = getelementptr double, double* %A, i64 %polly.access.add.A ; CHECK: %polly.access.A = getelementptr double, double* %A, i64 %polly.access.add.A
; CHECK: %polly.access.y = getelementptr double, double* %y, i64 0 ; CHECK: %polly.access.y = getelementptr double, double* %y, i64 0
Show All 33 Lines

test/Isl/CodeGen/multiple-scops-in-a-row.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; This test case has two scops in a row. When code generating the first scop, ; This test case has two scops in a row. When code generating the first scop,
; the second scop is invalidated. This test case verifies that we do not crash ; the second scop is invalidated. This test case verifies that we do not crash
; due to incorrectly assuming the second scop is still valid. ; due to incorrectly assuming the second scop is still valid.
; We explicitly check here that the second scop is not code generated. Later ; We explicitly check here that the second scop is not code generated. Later
; improvements may make this possible (e.g., Polly gaining support for ; improvements may make this possible (e.g., Polly gaining support for
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/Isl/CodeGen/multiple-types-invariant-load-2.ll

; RUN: opt %loadPolly -S -polly-allow-differing-element-types \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-allow-differing-element-types < %s | FileCheck %s ; RUN: -polly-allow-differing-element-types < %s | FileCheck %s
; CHECK: polly ; CHECK: polly
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 @hoge(i8* %arg) #0 { define void @hoge(i8* %arg) #0 {
Show All 27 Lines

test/Isl/CodeGen/multiple-types-invariant-load.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -S \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-codegen -S \ ; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; CHECK: %polly.access.cast.global.load = bitcast %struct.hoge* %global.load to i32* ; CHECK: %polly.access.cast.global.load = bitcast %struct.hoge* %global.load to i32*
; CHECK: %polly.access.global.load = getelementptr i32, i32* %polly.access.cast.global.load, i64 0 ; CHECK: %polly.access.global.load = getelementptr i32, i32* %polly.access.cast.global.load, i64 0
; CHECK: %polly.access.global.load.load = load i32, i32* %polly.access.global.load ; CHECK: %polly.access.global.load.load = load i32, i32* %polly.access.global.load
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 28 Lines

test/Isl/CodeGen/multiple_sai_fro_same_base_address.ll

; RUN: opt %loadPolly -polly-position=before-vectorizer -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-position=before-vectorizer -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-position=before-vectorizer -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-position=before-vectorizer -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=IR
; RUN: opt %loadPolly -polly-position=before-vectorizer -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-position=before-vectorizer -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; The IR has two ScopArrayInfo for the value %next.0. This used to produce two ; The IR has two ScopArrayInfo for the value %next.0. This used to produce two
; phi nodes in polly.merge_new_and_old, one illegaly using the result of the ; phi nodes in polly.merge_new_and_old, one illegaly using the result of the
; other. There must be only one merge phi, no need to generate them for arrays ; other. There must be only one merge phi, no need to generate them for arrays
; of type MK_Array. ; of type MK_Array.
; Derived from test-suite/MultiSource/Applications/siod/slib.c ; Derived from test-suite/MultiSource/Applications/siod/slib.c
Show All 35 Lines

test/Isl/CodeGen/no-overflow-tracking.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -analyze -polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-overflow-tracking=never \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -S -polly-codegen -polly-overflow-tracking=never \ ; RUN: opt %loadPolly -S -polly-codegen -polly-overflow-tracking=never \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; ;
; As (p + q) can overflow we have to check that we load from ; As (p + q) can overflow we have to check that we load from
; I[p + q] only if it does not. ; I[p + q] only if it does not.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/Isl/CodeGen/no_guard_bb.ll

; RUN: opt %loadPolly -S -verify-dom-info -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-codegen -S -verify-dom-info < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S -verify-dom-info < %s | FileCheck %s
; ;
; CHECK-NOT: br i1 true, label %polly.{{.*}}, label %polly.{{.*}} ; CHECK-NOT: br i1 true, label %polly.{{.*}}, label %polly.{{.*}}
; ;
; void jd(int *A) { ; void jd(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 25 Lines

test/Isl/CodeGen/non-affine-dominance-generated-entering.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR25439 ; llvm.org/PR25439
; Scalar reloads in the generated entering block were not recognized as ; Scalar reloads in the generated entering block were not recognized as
; dominating the subregion blocks when there were multiple entering nodes. This ; dominating the subregion blocks when there were multiple entering nodes. This
; resulted in values defined in there (here: %cond used in subregionB_entry) not ; resulted in values defined in there (here: %cond used in subregionB_entry) not
; being copied. We check whether it is reusing the reloaded scalar. ; being copied. We check whether it is reusing the reloaded scalar.
; ;
Show All 36 Lines

test/Isl/CodeGen/non-affine-exit-node-dominance.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR25439 ; llvm.org/PR25439
; The dominance of the generated non-affine subregion block was based on the ; The dominance of the generated non-affine subregion block was based on the
; scop's merge block, therefore resulted in an invalid DominanceTree. ; scop's merge block, therefore resulted in an invalid DominanceTree.
; It resulted in some values as assumed to be unusable in the actual generated ; It resulted in some values as assumed to be unusable in the actual generated
; exit block. Here we check whether the value %escaping is taken from the ; exit block. Here we check whether the value %escaping is taken from the
; generated block. ; generated block.
Show All 22 Lines

test/Isl/CodeGen/non-affine-phi-node-expansion-2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %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"
; CHECK: polly.stmt.bb3: ; preds = %polly.stmt.bb3.entry ; CHECK: polly.stmt.bb3: ; preds = %polly.stmt.bb3.entry
; CHECK: %tmp6_p_scalar_ = load double, double* %arg1{{[0-9]*}}, !alias.scope !0, !noalias !2 ; CHECK: %tmp6_p_scalar_ = load double, double* %arg1{{[0-9]*}}, !alias.scope !0, !noalias !2
; CHECK: %p_tmp7 = fadd double 1.000000e+00, %tmp6_p_scalar_ ; CHECK: %p_tmp7 = fadd double 1.000000e+00, %tmp6_p_scalar_
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-phi-node-expansion-3.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
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:
Show All 37 Lines

test/Isl/CodeGen/non-affine-phi-node-expansion-4.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
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:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-phi-node-expansion.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %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"
%struct.wombat = type {[4 x i32]} %struct.wombat = type {[4 x i32]}
; CHECK-NOT: polly.preload.begin: ; CHECK-NOT: polly.preload.begin:
; CHECK-NOT: %polly.access.B ; CHECK-NOT: %polly.access.B
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-region-exit-phi-incoming-synthesize-2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused the code generation to generate invalid code as the same operand ; This caused the code generation to generate invalid code as the same operand
; of the PHI node in the non-affine region was synthesized at the wrong place. ; of the PHI node in the non-affine region was synthesized at the wrong place.
; Check we do not generate wrong code. ; Check we do not generate wrong code.
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-region-exit-phi-incoming-synthesize.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused the code generation to generate invalid code as the same BBMap was ; This caused the code generation to generate invalid code as the same BBMap was
; used for the whole non-affine region. When %add is synthesized for the ; used for the whole non-affine region. When %add is synthesized for the
; incoming value of subregion_if first, the code for it was generated into ; incoming value of subregion_if first, the code for it was generated into
; subregion_if, but reused for the incoming value of subregion_exit, although it ; subregion_if, but reused for the incoming value of subregion_exit, although it
; is not dominated by subregion_if. ; is not dominated by subregion_if.
; ;
Show All 25 Lines

test/Isl/CodeGen/non-affine-region-implicit-store.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR25438 ; llvm.org/PR25438
; After loop versioning, a dominance check of a non-affine subregion's exit node ; After loop versioning, a dominance check of a non-affine subregion's exit node
; causes the dominance check to always fail any block in the scop. The ; causes the dominance check to always fail any block in the scop. The
; subregion's exit block has become polly_merge_new_and_old, which also receives ; subregion's exit block has become polly_merge_new_and_old, which also receives
; the control flow of the generated code. This would cause that any value for ; the control flow of the generated code. This would cause that any value for
; implicit stores is assumed to be not from the scop. ; implicit stores is assumed to be not from the scop.
Show All 40 Lines

test/Isl/CodeGen/non-affine-region-phi-references-in-scop-value.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -S -passes=polly-codegen < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-allow-nonaffine-loops \ ; RUN: opt %loadPolly -polly-codegen -polly-allow-nonaffine-loops \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; This test verifies that values defined in another scop statement and used by ; This test verifies that values defined in another scop statement and used by
; PHI-nodes in non-affine regions are code generated correctly. ; PHI-nodes in non-affine regions are code generated correctly.
; CHECK: polly.stmt.bb3.entry: ; CHECK: polly.stmt.bb3.entry:
; CHECK-NEXT: %j.0.phiops.reload = load i64, i64* %j.0.phiops ; CHECK-NEXT: %j.0.phiops.reload = load i64, i64* %j.0.phiops
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-subregion-dominance-reuse.ll

; RUN: opt %loadPolly -S -verify-dom-info -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S -verify-dom-info \ ; RUN: opt %loadPolly -polly-codegen -S -verify-dom-info \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; Check that we do not reuse the B[i-1] GEP created in block S again in ; Check that we do not reuse the B[i-1] GEP created in block S again in
; block Q. Hence, we create two GEPs for B[i-1]: ; block Q. Hence, we create two GEPs for B[i-1]:
; ;
; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1 ; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1
; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1 ; CHECK: %scevgep{{.}} = getelementptr i32, i32* %B, i64 -1
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-switch.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s ; RUN: -S -polly-codegen < %s | FileCheck %s
; ;
; 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++)
; switch (A[i]) { ; switch (A[i]) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/non-affine-synthesized-in-branch.ll

; RUN: opt %loadPolly -polly-process-unprofitable -S -passes=polly-codegen < %s\
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -S < %s | FileCheck %s
; ;
; llvm.org/PR25412 ; llvm.org/PR25412
; %synthgep caused %gep to be synthesized in subregion_if which was reused for ; %synthgep caused %gep to be synthesized in subregion_if which was reused for
; %retval in subregion_exit, even though it is not dominating subregion_exit. ; %retval in subregion_exit, even though it is not dominating subregion_exit.
; ;
; CHECK-LABEL: polly.stmt.polly.merge_new_and_old.exit: ; CHECK-LABEL: polly.stmt.polly.merge_new_and_old.exit:
; CHECK: %scevgep[[R1:[0-9]*]] = getelementptr %struct.hoge, %struct.hoge* %arg, i64 0, i32 2 ; CHECK: %scevgep[[R1:[0-9]*]] = getelementptr %struct.hoge, %struct.hoge* %arg, i64 0, i32 2
Show All 22 Lines

test/Isl/CodeGen/non-hoisted-load-needed-as-base-ptr.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen \
; RUN: -aa-pipeline=type-based-aa %s 2>&1
; RUN: opt %loadPolly -tbaa -polly-codegen -disable-output %s ; RUN: opt %loadPolly -tbaa -polly-codegen -disable-output %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"
%struct.1 = type { %struct.2*, %struct.2*, %struct.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8*, i8*, i8*, i8*, i8*, i32, [38 x i8], [128 x i8], [38 x i32], [256 x i8], [256 x i8], [256 x i8], %struct.4, [25 x [16 x %struct.4]], [128 x [64 x i16]] } %struct.1 = type { %struct.2*, %struct.2*, %struct.3*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8*, i8*, i8*, i8*, i8*, i32, [38 x i8], [128 x i8], [38 x i32], [256 x i8], [256 x i8], [256 x i8], %struct.4, [25 x [16 x %struct.4]], [128 x [64 x i16]] }
%struct.2 = type { i16, i16, i32, i32 } %struct.2 = type { i16, i16, i32, i32 }
%struct.3 = type { i8, i8, i16, i16 } %struct.3 = type { i8, i8, i16, i16 }
%struct.4 = type { i16, i8, i8 } %struct.4 = type { i16, i8, i8 }
Show All 40 Lines

test/Isl/CodeGen/non_affine_float_compare.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -S -verify-dom-info \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen \ ; RUN: opt %loadPolly -polly-codegen \
; RUN: -polly-allow-nonaffine-branches -S -verify-dom-info \ ; RUN: -polly-allow-nonaffine-branches -S -verify-dom-info \
; RUN: < %s | FileCheck %s ; RUN: < %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]++;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/Isl/CodeGen/only_non_affine_error_region.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; CHECK-NOT: polly.start ; CHECK-NOT: polly.start
; ;
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 @f(i32 %argc, i32* %A) #0 { define void @f(i32 %argc, i32* %A) #0 {
Show All 23 Lines

test/Isl/CodeGen/openmp_limit_threads.ll

; RUN: opt %loadPolly -polly-parallel -S -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AUTO
; RUN: opt %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s --check-prefix=AUTO ; RUN: opt %loadPolly -polly-codegen -polly-parallel -S < %s | FileCheck %s --check-prefix=AUTO
; RUN: opt %loadPolly -polly-parallel -polly-num-threads=1 -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=ONE
; RUN: opt %loadPolly -polly-codegen -polly-parallel -polly-num-threads=1 -S < %s | FileCheck %s --check-prefix=ONE ; RUN: opt %loadPolly -polly-codegen -polly-parallel -polly-num-threads=1 -S < %s | FileCheck %s --check-prefix=ONE
; RUN: opt %loadPolly -polly-parallel -polly-num-threads=4 -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=FOUR
; RUN: opt %loadPolly -polly-codegen -polly-parallel -polly-num-threads=4 -S < %s | FileCheck %s --check-prefix=FOUR ; RUN: opt %loadPolly -polly-codegen -polly-parallel -polly-num-threads=4 -S < %s | FileCheck %s --check-prefix=FOUR
; ;
; AUTO: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 0, i64 0, i64 1024, i64 1) ; AUTO: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 0, i64 0, i64 1024, i64 1)
; ONE: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 1, i64 0, i64 1024, i64 1) ; ONE: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 1, i64 0, i64 1024, i64 1)
; FOUR: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 4, i64 0, i64 1024, i64 1) ; FOUR: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd_polly_subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 4, i64 0, i64 1024, i64 1)
; ;
; void jd(int *A) { ; void jd(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Isl/CodeGen/out-of-scop-phi-node-use.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %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"
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK-NEXT: %_s.sroa.343.0.ph5161118.ph.merge = phi i32 [ %_s.sroa.343.0.ph5161118.ph.final_reload, %polly.exiting ], [ %_s.sroa.343.0.ph516.lcssa2357, %for.cond.981.region_exiting ] ; CHECK-NEXT: %_s.sroa.343.0.ph5161118.ph.merge = phi i32 [ %_s.sroa.343.0.ph5161118.ph.final_reload, %polly.exiting ], [ %_s.sroa.343.0.ph516.lcssa2357, %for.cond.981.region_exiting ]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/Isl/CodeGen/param_div_div_div_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; ;
; Check that we guard the divisions because we moved them and thereby increased ; Check that we guard the divisions because we moved them and thereby increased
; their domain. ; their domain.
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [p_0] -> { : p_0 < 0 } ; CHECK-NEXT: [p_0] -> { : p_0 < 0 }
; CHECK-NEXT: p0: ((%a /u %b) /u (%c /u %d)) ; CHECK-NEXT: p0: ((%a /u %b) /u (%c /u %d))
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/CodeGen/partial_write_full_write_that_appears_partial.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; CHECK: polly.stmt.if.then81: ; preds = %polly.stmt.if.end75 ; CHECK: polly.stmt.if.then81: ; preds = %polly.stmt.if.end75
; CHECK-NEXT: %scevgep = getelementptr [2 x %S], [2 x %S]* %tmp, i64 0, i64 %.147 ; CHECK-NEXT: %scevgep = getelementptr [2 x %S], [2 x %S]* %tmp, i64 0, i64 %.147
; CHECK-NEXT: %scevgep1 = bitcast %S* %scevgep to float* ; CHECK-NEXT: %scevgep1 = bitcast %S* %scevgep to float*
; CHECK-NEXT: store float undef, float* %scevgep1, align 4, !alias.scope !0, !noalias !2 ; CHECK-NEXT: store float undef, float* %scevgep1, align 4, !alias.scope !0, !noalias !2
; CHECK-NEXT: br label %polly.stmt.if.end87.region_exiting ; CHECK-NEXT: br label %polly.stmt.if.end87.region_exiting
Show All 26 Lines

test/Isl/CodeGen/perf_monitoring.ll

; RUN: opt %loadPolly -polly-codegen-perf-monitoring -S -passes=polly-codegen <\
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \ ; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/Isl/CodeGen/perf_monitoring_cycles_per_scop.ll

; RUN: opt %loadPolly -polly-codegen-perf-monitoring -S -passes=polly-codegen <\
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \ ; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/Isl/CodeGen/perf_monitoring_trip_counts_per_scop.ll

; RUN: opt %loadPolly -polly-codegen-perf-monitoring -S -passes=polly-codegen <\
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \ ; RUN: opt %loadPolly -polly-codegen -polly-codegen-perf-monitoring \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi-defined-before-scop.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK-NEXT: %tmp7.ph.merge = phi %struct.wibble* [ %tmp7.ph.final_reload, %polly.exiting ], [ %tmp7.ph, %bb6.region_exiting ] ; CHECK-NEXT: %tmp7.ph.merge = phi %struct.wibble* [ %tmp7.ph.final_reload, %polly.exiting ], [ %tmp7.ph, %bb6.region_exiting ]
; CHECK-LABEL: polly.stmt.bb3: ; CHECK-LABEL: polly.stmt.bb3:
; CHECK-NEXT: store %struct.wibble* %tmp2, %struct.wibble** %tmp7.s2a ; CHECK-NEXT: store %struct.wibble* %tmp2, %struct.wibble** %tmp7.s2a
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_condition_modeling_1.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %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
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_condition_modeling_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %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
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_conditional_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -analyze -polly-ast < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -analyze -polly-ast < %s | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; void jd(int *A, int c) { ; void jd(int *A, int c) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (c) ; if (c)
; A[i] = 1; ; A[i] = 1;
; else ; else
; A[i] = 2; ; A[i] = 2;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_in_exit_early_lnt_failure_1.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused an lnt crash at some point, just verify it will run through. ; This caused an lnt crash at some point, just verify it will run through.
; ;
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK-NEXT: br label %for.body.6 ; CHECK-NEXT: br label %for.body.6
; ;
; CHECK-LABEL: for.body.6: ; CHECK-LABEL: for.body.6:
Show All 34 Lines

test/Isl/CodeGen/phi_in_exit_early_lnt_failure_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused an lnt crash at some point, just verify it will run through and ; This caused an lnt crash at some point, just verify it will run through and
; produce the PHI node in the exit we are looking for. ; produce the PHI node in the exit we are looking for.
; ;
; CHECK: %eps1.addr.0.s2a = alloca double ; CHECK: %eps1.addr.0.s2a = alloca double
; CHECK-NOT: %eps1.addr.0.ph.s2a = alloca double ; CHECK-NOT: %eps1.addr.0.ph.s2a = alloca double
; ;
Show All 40 Lines

test/Isl/CodeGen/phi_in_exit_early_lnt_failure_3.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused an lnt crash at some point, just verify it will run through and ; This caused an lnt crash at some point, just verify it will run through and
; produce the PHI node in the exit we are looking for. ; produce the PHI node in the exit we are looking for.
; ;
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK-NEXT: %n2ptr.2.ph.merge = phi i8* [ %n2ptr.2.ph.final_reload, %polly.exiting ], [ %n2ptr.2.ph, %if.end.45.region_exiting ] ; CHECK-NEXT: %n2ptr.2.ph.merge = phi i8* [ %n2ptr.2.ph.final_reload, %polly.exiting ], [ %n2ptr.2.ph, %if.end.45.region_exiting ]
; ;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_in_exit_early_lnt_failure_5.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; This caused an lnt crash at some point, just verify it will run through and ; This caused an lnt crash at some point, just verify it will run through and
; produce the PHI node in the exit we are looking for. ; produce the PHI node in the exit we are looking for.
; ;
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK-NEXT: %eps1.addr.0.ph.merge = phi double [ %eps1.addr.0.ph.final_reload, %polly.exiting ], [ %eps1.addr.0.ph, %if.end.47.region_exiting ] ; CHECK-NEXT: %eps1.addr.0.ph.merge = phi double [ %eps1.addr.0.ph.final_reload, %polly.exiting ], [ %eps1.addr.0.ph, %if.end.47.region_exiting ]
; CHECK-NEXT: br label %if.end.47 ; CHECK-NEXT: br label %if.end.47
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_loop_carried_float.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %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];
; } ; }
; ;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_loop_carried_float_escape.ll

; RUN: opt %loadPolly -S -polly-analyze-read-only-scalars=false \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S \ ; RUN: opt %loadPolly -S \
; RUN: -polly-analyze-read-only-scalars=false -polly-codegen < %s | FileCheck %s ; RUN: -polly-analyze-read-only-scalars=false -polly-codegen < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-analyze-read-only-scalars=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S \ ; RUN: opt %loadPolly -S \
; RUN: -polly-analyze-read-only-scalars=true -polly-codegen < %s | FileCheck %s ; RUN: -polly-analyze-read-only-scalars=true -polly-codegen < %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];
; return tmp; ; return tmp;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_scalar_simple_1.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; 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;
; } ; }
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %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;
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

test/Isl/CodeGen/phi_with_multi_exiting_edges_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; CHECK: polly.merge_new_and_old: ; CHECK: polly.merge_new_and_old:
; CHECK: %result.ph.merge = phi float [ %result.ph.final_reload, %polly.exiting ], [ %result.ph, %next.region_exiting ] ; CHECK: %result.ph.merge = phi float [ %result.ph.final_reload, %polly.exiting ], [ %result.ph, %next.region_exiting ]
; CHECK: br label %next ; CHECK: br label %next
; ;
; CHECK: next: ; CHECK: next:
; CHECK: %result = phi float [ %result.ph.merge, %polly.merge_new_and_old ] ; CHECK: %result = phi float [ %result.ph.merge, %polly.merge_new_and_old ]
Show All 33 Lines

test/Isl/CodeGen/phi_with_one_exit_edge.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; ;
; CHECK: polly.merge_new_and_old: ; CHECK: polly.merge_new_and_old:
; CHECK: %sumA.merge = phi float [ %sumA.final_reload, %polly.exiting ], [ %sumA, %loopA ] ; CHECK: %sumA.merge = phi float [ %sumA.final_reload, %polly.exiting ], [ %sumA, %loopA ]
; CHECK: br label %next ; CHECK: br label %next
; ;
; CHECK: next: ; CHECK: next:
Show All 24 Lines

test/Isl/CodeGen/pointer-type-expressions-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
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(i8* %start, i8* %end) { define void @foo(i8* %start, i8* %end) {
entry: entry:
%A = alloca i32 %A = alloca i32
br label %body br label %body
Show All 20 Lines

test/Isl/CodeGen/pointer-type-expressions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; void f(int a[], int N, float *P) { ; void f(int a[], int N, float *P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P != 0) ; if (P != 0)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 38 Lines

test/Isl/CodeGen/pointer-type-pointer-type-comparison.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; ;
; void f(int a[], int N, float *P, float *Q) { ; void f(int a[], int N, float *P, float *Q) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P != Q) ; if (P != Q)
; a[i] = i; ; a[i] = i;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/CodeGen/pointer_rem.ll

; RUN: opt %loadPolly -polly-process-unprofitable -disable-output -S \
; RUN: "-passes=scop(print<polly-ast>)" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-ast -analyze -S < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-ast -analyze -S < %s | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-process-unprofitable -S \
; RUN: "-passes=scop(polly-codegen)" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
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"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
; This test is to ensure that for we generate signed remainder for ; This test is to ensure that for we generate signed remainder for
; the polly.cond check. ; the polly.cond check.
Show All 39 Lines

test/Isl/CodeGen/pr25241.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; PR25241 (https://llvm.org/bugs/show_bug.cgi?id=25241) ; PR25241 (https://llvm.org/bugs/show_bug.cgi?id=25241)
; Ensure that synthesized values of a PHI node argument are generated in the ; Ensure that synthesized values of a PHI node argument are generated in the
; incoming block, not in the PHI's block. ; incoming block, not in the PHI's block.
; CHECK-LABEL: polly.stmt.if.then.862: ; CHECK-LABEL: polly.stmt.if.then.862:
; CHECK: %[[R1:[0-9]+]] = add i32 %tmp, 1 ; CHECK: %[[R1:[0-9]+]] = add i32 %tmp, 1
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/Isl/CodeGen/ptrtoint_as_parameter.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; CHECK: polly.split_new_and_old: ; CHECK: polly.split_new_and_old:
; CHECK-NEXT: %pollysub.ptr.lhs.cast263 = ptrtoint i8* inttoptr (i64 1 to i8*) to i64 ; CHECK-NEXT: %pollysub.ptr.lhs.cast263 = ptrtoint i8* inttoptr (i64 1 to i8*) to i64
; ;
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
Show All 26 Lines

test/Isl/CodeGen/read-only-scalars.ll

; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --allow-empty
; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -polly-codegen \ ; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -polly-codegen \
; RUN: \ ; RUN: \
; RUN: -S < %s | FileCheck %s ; RUN: -S < %s | FileCheck %s
; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: -check-prefix=SCALAR
; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -polly-codegen \ ; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -polly-codegen \
; RUN: \ ; RUN: \
; RUN: -S < %s | FileCheck %s -check-prefix=SCALAR ; RUN: -S < %s | FileCheck %s -check-prefix=SCALAR
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; SCALAR-LABEL: entry: ; SCALAR-LABEL: entry:
; SCALAR-NEXT: %scalar.s2a = alloca float ; SCALAR-NEXT: %scalar.s2a = alloca float
Show All 31 Lines

test/Isl/CodeGen/reduction.ll

; RUN: opt %loadPolly -S < %s 2>&1 -passes=polly-codegen -aa-pipeline=basic-aa \
; RUN: | not FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s 2>&1 | not FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s 2>&1 | not FileCheck %s
;#include <string.h> ;#include <string.h>
;#include <stdio.h> ;#include <stdio.h>
;#define N 1021 ;#define N 1021
; ;
;int main () { ;int main () {
; int i; ; int i;
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/Isl/CodeGen/reduction_2.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-ast>" -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: %s --allow-empty
; RUN: opt %loadPolly -basicaa -polly-ast -analyze \ ; RUN: opt %loadPolly -basicaa -polly-ast -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#include <stdio.h> ;#include <stdio.h>
;#define N 1021 ;#define N 1021
; ;
;int main () { ;int main () {
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/Isl/CodeGen/reduction_simple_binary.ll

; RUN: opt %loadPolly -polly-ast-detect-parallel -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: pragma simd reduction ; CHECK: pragma simd reduction
; ;
; int prod; ; int prod;
; void f() { ; void f() {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; prod *= i; ; prod *= i;
Show All 29 Lines

test/Isl/CodeGen/region_exiting-domtree.ll

; RUN: opt %loadPolly -verify-dom-info -disable-output -passes=polly-codegen < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -verify-dom-info -analyze < %s ; RUN: opt %loadPolly -polly-codegen -verify-dom-info -analyze < %s
; Verify that the DominatorTree is preserved correctly for the inserted ; Verify that the DominatorTree is preserved correctly for the inserted
; %polly.stmt.exit.exit block, which serves as new exit block for the generated ; %polly.stmt.exit.exit block, which serves as new exit block for the generated
; subregion. In particulat, it must be dominated by %polly.stmt.subregion.enter, ; subregion. In particulat, it must be dominated by %polly.stmt.subregion.enter,
; the generated subregion's entry block. ; the generated subregion's entry block.
define void @func(i32 %n, i32* noalias nonnull %A) { define void @func(i32 %n, i32* noalias nonnull %A) {
Show All 37 Lines

test/Isl/CodeGen/run-time-condition-with-scev-parameters.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; TODO: FIXME: Simplify the context. ; TODO: FIXME: Simplify the context.
; AST: if (n >= 1 && 0 == n <= -1) ; AST: if (n >= 1 && 0 == n <= -1)
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %0 = zext i32 %n to i64 ; CHECK-NEXT: %0 = zext i32 %n to i64
Show All 29 Lines

test/Isl/CodeGen/run-time-condition.ll

; RUN: opt %loadPolly -S -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -S < %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"
define void @run-time-condition(i16* noalias %A, i16* noalias %B) { define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
entry: entry:
br label %for.cond br label %for.cond
Show All 22 Lines

test/Isl/CodeGen/scalar-references-used-in-scop-compute.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; Test the code generation in the presence of a scalar out-of-scop value being ; Test the code generation in the presence of a scalar out-of-scop value being
; used from within the SCoP. ; used from within the SCoP.
; CHECH-LABEL: @scalar-function-argument ; CHECH-LABEL: @scalar-function-argument
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/Isl/CodeGen/scalar-store-from-same-bb.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; This test ensures that the expression N + 1 that is stored in the phi-node ; This test ensures that the expression N + 1 that is stored in the phi-node
; alloca, is directly computed and not incorrectly transfered through memory. ; alloca, is directly computed and not incorrectly transfered through memory.
; CHECK: store i64 [[REG:%.*]], i64* %res.phiops ; CHECK: store i64 [[REG:%.*]], i64* %res.phiops
; CHECK: [[REG]] = add i64 %N, 1 ; CHECK: [[REG]] = add i64 %N, 1
Show All 24 Lines

test/Isl/CodeGen/scalar_codegen_crash.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; This test cases used to crash the scalar code generation. Check that we ; This test cases used to crash the scalar code generation. Check that we
; can generate code for it. ; can generate code for it.
; CHECK: polly.start ; CHECK: polly.start
@endposition = external global i32, align 4 @endposition = external global i32, align 4
Show All 37 Lines

test/Isl/CodeGen/scev-division-invariant-load.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -S -polly-codegen < %s ; RUN: opt %loadPolly -S -polly-codegen < %s
; ;
; Check that we generate valid code as we did not use the preloaded ; Check that we generate valid code as we did not use the preloaded
; value of %tmp1 for the access function of the preloaded %tmp4. ; value of %tmp1 for the access function of the preloaded %tmp4.
; ;
; ModuleID = 'bug.ll' ; ModuleID = 'bug.ll'
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 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/Isl/CodeGen/scev.ll

; RUN: opt %loadPolly "-passes=require<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect < %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" 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"
define fastcc void @f () inlinehint align 2 { define fastcc void @f () inlinehint align 2 {
entry: entry:
%0 = fmul double undef, 1.250000e+00 ; <double> [#uses=1] %0 = fmul double undef, 1.250000e+00 ; <double> [#uses=1]
%1 = fptoui double %0 to i32 ; <i32> [#uses=0] %1 = fptoui double %0 to i32 ; <i32> [#uses=0]
br i1 false, label %bb5.i, label %bb.nph.i br i1 false, label %bb5.i, label %bb.nph.i
Show All 13 Lines

test/Isl/CodeGen/scev_expansion_in_nonaffine.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; bugpoint-reduced testcase of MiBench/consumer-lame/quantize-pvt.c from the ; bugpoint-reduced testcase of MiBench/consumer-lame/quantize-pvt.c from the
; test-suite. ; test-suite.
; It features a SCEV that is used in two BasicBlock within a non-affine ; It features a SCEV that is used in two BasicBlock within a non-affine
; subregion where none of the blocks dominate the other. We check that the SCEV ; subregion where none of the blocks dominate the other. We check that the SCEV
; is expanded independently for both BasicBlocks instead of just once for the ; is expanded independently for both BasicBlocks instead of just once for the
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/Isl/CodeGen/scop_expander_insert_point.ll

; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %outvalue.141.phiops = alloca i64 ; CHECK-NEXT: %outvalue.141.phiops = alloca i64
; CHECK-NEXT: %.preload.s2a = alloca i8 ; CHECK-NEXT: %.preload.s2a = alloca i8
; CHECK-NEXT: %divpolly = sdiv i32 undef, 1 ; CHECK-NEXT: %divpolly = sdiv i32 undef, 1
; CHECK-NEXT: %div = sdiv i32 undef, undef ; CHECK-NEXT: %div = sdiv i32 undef, undef
Show All 36 Lines

test/Isl/CodeGen/scop_expander_segfault.ll

; RUN: opt %loadPolly -S -passes=polly-codegen %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S %s | FileCheck %s
; ;
; This test was extracted from gcc in SPEC2006 and it crashed our code ; This test was extracted from gcc in SPEC2006 and it crashed our code
; generation, or to be more precise, the ScopExpander due to a endless ; generation, or to be more precise, the ScopExpander due to a endless
; recursion. It was fixed in r261474 (git: 61cba205ca59). ; recursion. It was fixed in r261474 (git: 61cba205ca59).
; ;
; CHECK: polly.start: ; CHECK: polly.start:
; ;
Show All 23 Lines

test/Isl/CodeGen/scop_never_executed_runtime_check_location.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; Verify that we generate the runtime check code after the conditional branch ; Verify that we generate the runtime check code after the conditional branch
; in the SCoP region entering block (here %entry). ; in the SCoP region entering block (here %entry).
; ;
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %0 = zext i32 %n to i64 ; CHECK-NEXT: %0 = zext i32 %n to i64
; CHECK-NEXT: br i1 false ; CHECK-NEXT: br i1 false
Show All 23 Lines

test/Isl/CodeGen/select-base-pointer.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen \
; RUN: -aa-pipeline=type-based-aa %s 2>&1
; RUN: opt %loadPolly -tbaa -polly-codegen -disable-output %s ; RUN: opt %loadPolly -tbaa -polly-codegen -disable-output %s
; ;
; Check that we do not crash here. ; Check that we do not crash here.
; ;
; ModuleID = 'bugpoint-reduced-simplified.bc' ; ModuleID = 'bugpoint-reduced-simplified.bc'
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"
%"DOMParentNode" = type { %"DOMNode"*, %"DOMNode"*, %"DOMNodeListImpl" } %"DOMParentNode" = type { %"DOMNode"*, %"DOMNode"*, %"DOMNodeListImpl" }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/Isl/CodeGen/sequential_loops.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
; ;
;int A[N]; ;int A[N];
; ;
;void sequential_loops() { ;void sequential_loops() {
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_loop_non_single_exit.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CHECK-CODE
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 26 Lines

test/Isl/CodeGen/simple_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CHECK-CODE
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
Show All 27 Lines

test/Isl/CodeGen/simple_non_single_entry.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CHECK-CODE
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true){ ; if (true){
; i = 0; ; i = 0;
; goto next; ; goto next;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_nonaffine_loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s
;#include <stdio.h> ;#include <stdio.h>
;#include <stdlib.h> ;#include <stdlib.h>
;#include <math.h> ;#include <math.h>
; ;
;int main() ;int main()
;{ ;{
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_vec_assign_scalar.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen \ ; RUN: opt %loadPolly -basicaa -polly-codegen \
; RUN: -polly-vectorizer=polly -dce -S < %s | FileCheck %s ; RUN: -polly-vectorizer=polly -dce -S < %s | FileCheck %s
; RUN: opt %loadPolly -polly-vectorizer=stripmine -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s --check-prefix=STRIPMINE --allow-empty
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=stripmine -dce -S < %s | FileCheck %s --check-prefix=STRIPMINE ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=stripmine -dce -S < %s | FileCheck %s --check-prefix=STRIPMINE
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_vec_assign_scalar_2.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_vec_call.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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" 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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 29 Lines

test/Isl/CodeGen/simple_vec_call_2.ll

; RUN: opt %loadPolly -polly-vectorizer=polly \
; RUN: -polly-invariant-load-hoisting=true -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce \
; RUN: -polly-invariant-load-hoisting=true -S < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -S < %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" 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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float** @foo(float) readnone declare float** @foo(float) readnone
Show All 29 Lines

test/Isl/CodeGen/simple_vec_cast.ll

; RUN: opt %loadPolly -polly-vectorizer=polly \
; RUN: -polly-invariant-load-hoisting=true -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly \
; RUN: -polly-invariant-load-hoisting=true -dce -S < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -dce -S < %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" 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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x double] zeroinitializer, align 16 @B = common global [1024 x double] zeroinitializer, align 16
define void @simple_vec_const() nounwind { define void @simple_vec_const() nounwind {
Show All 30 Lines

test/Isl/CodeGen/simple_vec_const.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_vec_large_width.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %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" 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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
define void @simple_vec_large_width() nounwind { define void @simple_vec_large_width() nounwind {
; <label>:0 ; <label>:0
Show All 31 Lines

test/Isl/CodeGen/simple_vec_ptr_ptr_ty.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \ ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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" 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"
@A = common global [1024 x float**] zeroinitializer, align 16 @A = common global [1024 x float**] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 23 Lines

test/Isl/CodeGen/simple_vec_stride_negative_one.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S -passes=polly-codegen < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly -S < %s | FileCheck %s
; ModuleID = 'reverse.c' ; ModuleID = 'reverse.c'
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"
;int A[100]; ;int A[100];
;void foo() { ;void foo() {
; for (int i=3; i >= 0; i--) ; for (int i=3; i >= 0; i--)
Show All 29 Lines

test/Isl/CodeGen/simple_vec_stride_one.ll

; RUN: opt %loadPolly -polly-vectorizer=polly < %s -S -passes=polly-codegen \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly \ ; RUN: opt %loadPolly -polly-codegen -polly-vectorizer=polly \
; RUN: < %s -S | FileCheck %s ; RUN: < %s -S | FileCheck %s
; CHECK: store <4 x double> %val.s2a_p_splat, <4 x double>* %vector_ptr ; CHECK: store <4 x double> %val.s2a_p_splat, <4 x double>* %vector_ptr
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 @update_access_functions(i64 %arg, double* %A, double* %B) { define void @update_access_functions(i64 %arg, double* %A, double* %B) {
bb3: bb3:
Show All 29 Lines

test/Isl/CodeGen/simple_vec_stride_x.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_stride_x(void) { ;void simple_vec_stride_x(void) {
; int i; ; int i;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/Isl/CodeGen/simple_vec_two_stmts.ll

; RUN: opt %loadPolly -polly-vectorizer=polly -S \
; RUN: "-passes=function(scop(polly-codegen),dce)" -aa-pipeline=basic-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-codegen -polly-vectorizer=polly -dce -S < %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" 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"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
@C = common global [1024 x float] zeroinitializer, align 16 @C = common global [1024 x float] zeroinitializer, align 16
define void @simple_vec_stride_one() nounwind { define void @simple_vec_stride_one() nounwind {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_do_loop_int_max_iterations.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;#include <stdio.h> ;#include <stdio.h>
;int A[N]; ;int A[N];
; ;
;void single_do_loop_int_max_iterations() { ;void single_do_loop_int_max_iterations() {
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_do_loop_int_param_iterations.ll

; RUN: opt %loadPolly -S -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;define N 20 ;define N 20
;#include "limits.h" ;#include "limits.h"
;int A[N]; ;int A[N];
; ;
;void bar (int n) { ;void bar (int n) {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_do_loop_ll_max_iterations.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s
; RUN: opt %loadPolly -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen < %s ; RUN: opt %loadPolly -polly-codegen < %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;long long A[N]; ;long long A[N];
; ;
;int main () { ;int main () {
; long long i; ; long long i;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_do_loop_one_iteration.ll

; RUN: opt %loadPolly -S -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
; ;
;int main () { ;int main () {
; int i; ; int i;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_do_loop_scev_replace.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;#include <stdio.h> ;#include <stdio.h>
;int A[2 * N]; ;int A[2 * N];
; ;
;void single_do_loop_scev_replace() { ;void single_do_loop_scev_replace() {
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop_int_max_iterations.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop_ll_max_iterations.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; long long i; ; long long i;
; long long A[N]; ; long long A[N];
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop_one_iteration.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop_param.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %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" 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"
@A = common global [1024 x i32] zeroinitializer, align 16 ; <[1024 x i32]*> [#uses=3] @A = common global [1024 x i32] zeroinitializer, align 16 ; <[1024 x i32]*> [#uses=3]
define void @bar(i64 %n) nounwind { define void @bar(i64 %n) nounwind {
bb: bb:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/Isl/CodeGen/single_loop_zero_iterations.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=SCALAR -allow-empty
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s -check-prefix=SCALAR
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/split_edge_of_exit.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -verify-region-info -disable-output -passes=polly-codegen\
; RUN: < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -verify-region-info -analyze < %s ; RUN: opt %loadPolly -polly-codegen -verify-region-info -analyze < %s
; ;
; This is a scop directly precedented by a region, i.e. the scop's entry is the ; This is a scop directly precedented by a region, i.e. the scop's entry is the
; region's exit block. This test is to ensure that the RegionInfo is correctly ; region's exit block. This test is to ensure that the RegionInfo is correctly
; preserved. ; preserved.
; ;
; CHECK: Valid Region for Scop: region2 => return ; CHECK: Valid Region for Scop: region2 => return
; ;
Show All 22 Lines

test/Isl/CodeGen/split_edges.ll

; RUN: opt %loadPolly -verify-region-info -verify-dom-info -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -verify-region-info -verify-dom-info -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -verify-region-info -verify-dom-info -S < %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" 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"
@A = common global [1536 x float] zeroinitializer @A = common global [1536 x float] zeroinitializer
define void @loop_with_condition() nounwind { define void @loop_with_condition() nounwind {
bb0: bb0:
fence seq_cst fence seq_cst
Show All 29 Lines

test/Isl/CodeGen/split_edges_2.ll

; RUN: opt %loadPolly -verify-region-info -verify-dom-info -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -verify-region-info -verify-dom-info -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -verify-region-info -verify-dom-info -S < %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" 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"
@A = common global [1536 x float] zeroinitializer @A = common global [1536 x float] zeroinitializer
define void @loop_with_condition() nounwind { define void @loop_with_condition() nounwind {
bb0: bb0:
Show All 28 Lines

test/Isl/CodeGen/srem-in-other-bb.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: < %s | FileCheck %s ; RUN: < %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;
; } ; }
; ;
Show All 35 Lines

test/Isl/CodeGen/stack-overflow-in-load-hoisting.ll

; RUN: opt %loadPolly -verify-dom-info -S < %s \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -verify-dom-info -polly-codegen -S < %s \ ; RUN: opt %loadPolly -verify-dom-info -polly-codegen -S < %s \
; RUN: -polly-invariant-load-hoisting=true | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true | FileCheck %s
; ;
; This caused an infinite recursion during invariant load hoisting at some ; This caused an infinite recursion during invariant load hoisting at some
; point. Check it does not and we add a "false" runtime check. ; point. Check it does not and we add a "false" runtime check.
; ;
; CHECK: polly.preload.begin: ; CHECK: polly.preload.begin:
; CHECK-NEXT: br i1 false, label %polly.start, label %for.body.14.lr.ph ; CHECK-NEXT: br i1 false, label %polly.start, label %for.body.14.lr.ph
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/Isl/CodeGen/switch-in-non-affine-region.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s ; RUN: -S -polly-codegen < %s | FileCheck %s
; ;
; 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++)
; if (A[i]) ; if (A[i])
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/Isl/CodeGen/synthesizable_phi_write_after_loop.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Check for the correct written value of a scalar phi write whose value is ; Check for the correct written value of a scalar phi write whose value is
; defined within the loop, but its effective value is its last definition when ; defined within the loop, but its effective value is its last definition when
; leaving the loop (in this test it is the value 2 for %i.inc). This can be ; leaving the loop (in this test it is the value 2 for %i.inc). This can be
; either computed: ; either computed:
; - Using SCEVExpander: ; - Using SCEVExpander:
; In this case the Loop passed to the expander must NOT be the loop ; In this case the Loop passed to the expander must NOT be the loop
Show All 31 Lines

test/Isl/CodeGen/test-invalid-operands-for-select-2.ll

; RUN: opt %loadPolly -S -verify-loop-info -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen -verify-loop-info < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen -verify-loop-info < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/bugs/show_bug.cgi?id=21167 ; Check that we do not crash as described here: http://llvm.org/bugs/show_bug.cgi?id=21167
; ;
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
; ;
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 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/Isl/CodeGen/test-invalid-operands-for-select.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/PR21167 ; Check that we do not crash as described here: http://llvm.org/PR21167
; ;
; In case the pieceweise affine function used to create an isl_ast_expr ; In case the pieceweise affine function used to create an isl_ast_expr
; had empty cases (e.g., with contradicting constraints on the ; had empty cases (e.g., with contradicting constraints on the
; parameters), it was possible that the condition of the isl_ast_expr ; parameters), it was possible that the condition of the isl_ast_expr
; select was not a comparison but a constant (thus of type i64). ; select was not a comparison but a constant (thus of type i64).
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/Isl/CodeGen/test.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;int bar1(); ;int bar1();
;int bar2(); ;int bar2();
;int bar3(); ;int bar3();
;int k; ;int k;
;#define N 100 ;#define N 100
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/Isl/CodeGen/two-loops-right-after-each-other-2.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; CHECK: polly.merge_new_and_old: ; CHECK: polly.merge_new_and_old:
; CHECK-NEXT: merge = phi ; CHECK-NEXT: merge = phi
%struct.ImageParameters = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8**, i8**, i32, i32***, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [9 x [16 x [16 x i16]]], [5 x [16 x [16 x i16]]], [9 x [8 x [8 x i16]]], [2 x [4 x [16 x [16 x i16]]]], [16 x [16 x i16]], [16 x [16 x i32]], i32****, i32***, i32***, i32***, i32****, i32****, %struct.Picture*, %struct.Slice*, %struct.macroblock*, i32*, i32*, i32, i32, i32, i32, [4 x [4 x i32]], i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i16******, i16******, i16******, i16******, [15 x i16], i32, i32, i32, i32, i32, i32, i32, i32, [6 x [32 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1 x i32], i32, i32, [2 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.DecRefPicMarking*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double**, double***, i32***, double**, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x [2 x i32]], [2 x i32], i32, i32, i16, i32, i32, i32, i32, i32 } %struct.ImageParameters = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i8**, i8**, i32, i32***, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [9 x [16 x [16 x i16]]], [5 x [16 x [16 x i16]]], [9 x [8 x [8 x i16]]], [2 x [4 x [16 x [16 x i16]]]], [16 x [16 x i16]], [16 x [16 x i32]], i32****, i32***, i32***, i32***, i32****, i32****, %struct.Picture*, %struct.Slice*, %struct.macroblock*, i32*, i32*, i32, i32, i32, i32, [4 x [4 x i32]], i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i16******, i16******, i16******, i16******, [15 x i16], i32, i32, i32, i32, i32, i32, i32, i32, [6 x [32 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1 x i32], i32, i32, [2 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.DecRefPicMarking*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double**, double***, i32***, double**, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x [2 x i32]], [2 x i32], i32, i32, i16, i32, i32, i32, i32, i32 }
%struct.Picture = type { i32, i32, [100 x %struct.Slice*], i32, float, float, float } %struct.Picture = type { i32, i32, [100 x %struct.Slice*], i32, float, float, float }
%struct.Slice = type { i32, i32, i32, i32, i32, i32, %struct.datapartition*, %struct.MotionInfoContexts*, %struct.TextureInfoContexts*, i32, i32*, i32*, i32*, i32, i32*, i32*, i32*, i32 (i32)*, [3 x [2 x i32]] } %struct.Slice = type { i32, i32, i32, i32, i32, i32, %struct.datapartition*, %struct.MotionInfoContexts*, %struct.TextureInfoContexts*, i32, i32*, i32*, i32*, i32, i32*, i32*, i32*, i32 (i32)*, [3 x [2 x i32]] }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Isl/CodeGen/two-scops-in-row-invalidate-scevs.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; CHECK-LABEL: for.cond: ; CHECK-LABEL: for.cond:
; CHECK: %num.0 = phi i32 [ %add, %for.body15 ], [ 0, %for.cond.pre_entry_bb ] ; CHECK: %num.0 = phi i32 [ %add, %for.body15 ], [ 0, %for.cond.pre_entry_bb ]
; CHECK: br i1 false, label %for.body15, label %for.end22 ; CHECK: br i1 false, label %for.body15, label %for.end22
; CHECK-LABEL: polly.merge_new_and_old: ; CHECK-LABEL: polly.merge_new_and_old:
; CHECK: %num.0.merge = phi i32 [ %num.0.final_reload, %polly.exiting ], [ %num.0, %for.end22 ] ; CHECK: %num.0.merge = phi i32 [ %num.0.final_reload, %polly.exiting ], [ %num.0, %for.end22 ]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/Isl/CodeGen/two-scops-in-row.ll

; RUN: opt %loadPolly -disable-output -polly-ignore-aliasing \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s -check-prefix=SCALAR
; RUN: opt %loadPolly -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt %loadPolly -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s -check-prefix=SCALAR
; RUN: opt %loadPolly -polly-ignore-aliasing -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -disable-output < %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"
; SCALAR: if ( ; SCALAR: if (
; SCALAR: { ; SCALAR: {
; SCALAR: Stmt_for_1(0); ; SCALAR: Stmt_for_1(0);
; SCALAR: for (int c0 = 1; c0 <= -Scalar0_val + 99; c0 += 1) ; SCALAR: for (int c0 = 1; c0 <= -Scalar0_val + 99; c0 += 1)
; SCALAR: Stmt_for_1(c0); ; SCALAR: Stmt_for_1(c0);
Show All 31 Lines

test/Isl/CodeGen/udiv_expansion_position.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Verify we do not crash when we synthezise code for the udiv in the SCoP. ; Verify we do not crash when we synthezise code for the udiv in the SCoP.
; ;
; CHECK: polly.start ; CHECK: polly.start
; ;
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 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/Isl/CodeGen/uninitialized_scalar_memory.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
; ;
; Verify we initialize the scalar locations reserved for the incoming phi ; Verify we initialize the scalar locations reserved for the incoming phi
; values. ; values.
; ;
; CHECK: polly.start: ; CHECK: polly.start:
; CHECK-NEXT: store float %ebig.0, float* %ebig.0.s2a ; CHECK-NEXT: store float %ebig.0, float* %ebig.0.s2a
; CHECK-NEXT: br label %polly.stmt.if.end.entry ; CHECK-NEXT: br label %polly.stmt.if.end.entry
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/Isl/CodeGen/unpredictable-loop-unsynthesizable.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-invariant-load-hoisting=true -passes=polly-codegen \
; RUN: -aa-pipeline=basic-aa < %s 2>&1
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s ; RUN: -polly-invariant-load-hoisting=true < %s
; The loop for.body is a scop with invariant load hoisting, but does not ; The loop for.body is a scop with invariant load hoisting, but does not
; terminate predictably for ScalarEvolution. The scalar %1 therefore is not ; terminate predictably for ScalarEvolution. The scalar %1 therefore is not
; synthesizable using SCEVExpander. We therefore must have Stmt_for_end_loopexit ; synthesizable using SCEVExpander. We therefore must have Stmt_for_end_loopexit
; to catch the induction variable at loop exit. We also check for not crashing ; to catch the induction variable at loop exit. We also check for not crashing
; at codegen because SCEVExpander would use the original induction variable in ; at codegen because SCEVExpander would use the original induction variable in
; generated code. ; generated code.
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/Isl/CodeGen/variant_load_empty_domain.ll

; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -analyze < %s
; ;
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 1; i < 10; i++) { ; for (int i = 1; i < 10; i++) {
; A[i]++; ; A[i]++;
; if (i > 10) ; if (i > 10)
; A[i] += A[0]; ; A[i] += A[0];
Show All 39 Lines

test/Isl/CodeGen/whole-scop-non-affine-subregion.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %s | FileCheck %s
; CHECK: polly.start ; CHECK: polly.start
; int /* pure */ g() ; int /* pure */ g()
; void f(int *A) { ; void f(int *A) {
; if (g()) ; if (g())
; *A = *A + 1; ; *A = *A + 1;
Show All 34 Lines

test/Isl/single_loop_param_less_equal.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(scop(polly-codegen),print<loops>)" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=LOOPS
; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
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"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
%n_plus_one = add i64 %n, 1 %n_plus_one = add i64 %n, 1
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/Isl/single_loop_param_less_than.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
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"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/Isl/single_loop_uint_max_iterations.ll

; RUN: opt %loadPolly -S -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; unsigned int i; ; unsigned int i;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/Isl/single_loop_ull_max_iterations.ll

; RUN: opt %loadPolly -S -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; unsigned long long i; ; unsigned long long i;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopDetect/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
Show All 27 Lines

test/ScopDetect/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
Show All 31 Lines

test/ScopDetect/aliasing_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[0]; ; A[i] = B[0];
; } ; }
Show All 25 Lines

test/ScopDetect/aliasing_simple_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[0] + B[1023]; ; A[i] = B[0] + B[1023];
; } ; }
Show All 28 Lines

test/ScopDetect/base_pointer.ll

; RUN: opt %loadPolly -disable-basicaa -polly-invariant-load-hoisting=true \
; RUN: -disable-output "-passes=print<polly-detect>" < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -disable-basicaa -polly-detect -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -disable-basicaa -polly-detect -polly-invariant-load-hoisting=true -analyze < %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" 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 @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind { define void @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind {
entry: entry:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

test/ScopDetect/cross_loop_non_single_exit.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; else ; else
Show All 40 Lines

test/ScopDetect/cross_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; else ; else
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopDetect/dependency_to_phi_node_outside_of_region.ll

; RUN: opt %loadPolly -disable-output "-passes=require<polly-detect>" < %s 2>&1\
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-detect -disable-output < %s ; RUN: opt %loadPolly -polly-detect -disable-output < %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" 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* %A, i64 %N, i64 %M) nounwind { define void @f(i64* %A, i64 %N, i64 %M) nounwind {
entry: entry:
fence seq_cst fence seq_cst
br label %for.i br label %for.i
Show All 25 Lines

test/ScopDetect/error-block-always-executed.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-detect -analyze < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
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"
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/ScopDetect/error-block-referenced-from-scop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-detect -analyze < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
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"
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopDetect/expand-region-correctly-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-detect \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer ; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer
; ;
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopDetect/expand-region-correctly.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-detect \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer ; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer
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 @qtm_decompress() { define void @qtm_decompress() {
Show All 37 Lines

test/ScopDetect/index_from_unpredictable_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AFFINE
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=AFFINE ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=AFFINE
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE
; The loop for.body => for.inc has an unpredictable iteration count could due to ; The loop for.body => for.inc has an unpredictable iteration count could due to
; the undef start value that it is compared to. Therefore the array element ; the undef start value that it is compared to. Therefore the array element
; %arrayidx101 that depends on that exit value cannot be affine. ; %arrayidx101 that depends on that exit value cannot be affine.
; Derived from test-suite/MultiSource/Benchmarks/BitBench/uuencode/uuencode.c ; Derived from test-suite/MultiSource/Benchmarks/BitBench/uuencode/uuencode.c
define void @encode_line(i8* nocapture readonly %input, i32 %octets, i64 %p) { define void @encode_line(i8* nocapture readonly %input, i32 %octets, i64 %p) {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopDetect/indvars.ll

; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(print<polly-detect>,scop(polly-codegen))" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-detect -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-detect -polly-codegen < %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" 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"
define void @main(i64* %A, i64* %B) nounwind { define void @main(i64* %A, i64* %B) nounwind {
entry: entry:
br label %for.i br label %for.i
Show All 31 Lines

test/ScopDetect/intrinsics_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: for.cond => for.end ; CHECK: Valid Region for Scop: for.cond => for.end
; ;
; #include "math.h" ; #include "math.h"
; ;
; void jd(int *restrict A, float *restrict B) { ; void jd(int *restrict A, float *restrict B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

test/ScopDetect/intrinsics_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify that we allow the lifetime markers for the tmp array. ; Verify that we allow the lifetime markers for the tmp array.
; ;
; CHECK: Valid Region for Scop: for.cond => for.end13 ; CHECK: Valid Region for Scop: for.cond => for.end13
; ;
; int A[1024]; ; int A[1024];
; void jd() { ; void jd() {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopDetect/intrinsics_3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify that we allow the misc intrinsics. ; Verify that we allow the misc intrinsics.
; ;
; CHECK: Valid Region for Scop: for.cond => for.end13 ; CHECK: Valid Region for Scop: for.cond => for.end13
; ;
; int A[1024]; ; int A[1024];
; void jd() { ; void jd() {
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

test/ScopDetect/invalid-latch-conditions.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect -analyze < %s | FileCheck %s ; RUN: -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=NALOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-loops \ ; RUN: opt %loadPolly -polly-allow-nonaffine-loops \
; RUN: -polly-detect -analyze < %s | FileCheck %s --check-prefix=NALOOPS ; RUN: -polly-detect -analyze < %s | FileCheck %s --check-prefix=NALOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: -polly-process-unprofitable=false "-passes=print<polly-detect>" < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=PROFIT \
; RUN: --allow-empty
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-detect -analyze \ ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-detect -analyze \
; RUN: -polly-process-unprofitable=false < %s | \ ; RUN: -polly-process-unprofitable=false < %s | \
; RUN: FileCheck %s --check-prefix=PROFIT ; RUN: FileCheck %s --check-prefix=PROFIT
; The latch conditions of the outer loop are not affine, thus the loop cannot ; The latch conditions of the outer loop are not affine, thus the loop cannot
; handled by the domain generation and needs to be overapproximated. ; handled by the domain generation and needs to be overapproximated.
; CHECK-NOT: Valid ; CHECK-NOT: Valid
Show All 33 Lines

test/ScopDetect/invalidate_scalar_evolution.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=PHI
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s -check-prefix=PHI ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s -check-prefix=PHI
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 34 Lines

test/ScopDetect/keep_going_expansion.ll

; RUN: opt %loadPolly -polly-detect-track-failures -polly-detect-keep-going \
; RUN: -disable-output "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s\
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect-track-failures -polly-detect-keep-going -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-detect-track-failures -polly-detect-keep-going -polly-detect -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"
define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 { define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 {
entry: entry:
br label %entry.split br label %entry.split
Show All 37 Lines

test/ScopDetect/mod_ref_read_pointer.ll

; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=MODREF
; RUN: opt %loadPolly -basicaa -polly-detect -analyze \ ; RUN: opt %loadPolly -basicaa -polly-detect -analyze \
; RUN: -polly-allow-modref-calls < %s | FileCheck %s -check-prefix=MODREF ; RUN: -polly-allow-modref-calls < %s | FileCheck %s -check-prefix=MODREF
; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --allow-empty
; RUN: opt %loadPolly -basicaa -polly-detect -analyze \ ; RUN: opt %loadPolly -basicaa -polly-detect -analyze \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: for.body => for.end ; CHECK-NOT: Valid Region for Scop: for.body => for.end
; MODREF: Valid Region for Scop: for.body => for.end ; MODREF: Valid Region for Scop: for.body => for.end
; ;
; #pragma readonly ; #pragma readonly
; int func(int *A); ; int func(int *A);
Show All 32 Lines

test/ScopDetect/more-than-one-loop.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: \ ; RUN: \
; RUN: -polly-detect -analyze < %s | FileCheck %s ; RUN: -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=true \ ; RUN: opt %loadPolly -polly-process-unprofitable=true \
; RUN: \ ; RUN: \
; RUN: -polly-detect -analyze < %s | FileCheck %s ; RUN: -polly-detect -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; void foo(float *A, float *B, long N) { ; void foo(float *A, float *B, long N) {
; if (N > 100) ; if (N > 100)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/ScopDetect/multidim-with-undef-size.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -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"
; CHECK: Valid Region for Scop: bb14 => bb17 ; CHECK: Valid Region for Scop: bb14 => bb17
; Make sure we do not detect the larger region bb14->bb19 that contains ; Make sure we do not detect the larger region bb14->bb19 that contains
; a multi-dimensional memory access with a size of 'undef * undef'. ; a multi-dimensional memory access with a size of 'undef * undef'.
Show All 28 Lines

test/ScopDetect/multidim.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -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"
; CHECK: Valid Region for Scop: bb19 => bb20 ; CHECK: Valid Region for Scop: bb19 => bb20
; Make sure we do not crash in this test case. ; Make sure we do not crash in this test case.
define void @hoge(i8* %arg) { define void @hoge(i8* %arg) {
Show All 28 Lines

test/ScopDetect/multidim_indirect_access.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; Check that we will recognize this SCoP. ; Check that we will recognize this SCoP.
; ;
; void f(int *A, long N) { ; void f(int *A, long N) {
; int j = 0; ; int j = 0;
; while (N > j) { ; while (N > j) {
; int x = A[0]; ; int x = A[0];
Show All 38 Lines

test/ScopDetect/multidim_two_accesses_different_delinearization.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %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) { ; void foo(long n, long m, double *A) {
; 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++)
Show All 36 Lines

test/ScopDetect/nested_loop_single_exit.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -analyze < %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i, j; ; long i, j;
; if (true) ; if (true)
; for (j = 0; j < N; ++j) ; for (j = 0; j < N; ++j)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
Show All 35 Lines

test/ScopDetect/non-affine-conditional.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-detect \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-detect \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; A[i] = 0; ; A[i] = 0;
; } ; }
Show All 35 Lines

test/ScopDetect/non-affine-float-compare.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -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]++;
; } ; }
Show All 39 Lines

test/ScopDetect/non-affine-loop-condition-dependent-access.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=REJECTNONAFFINELOOPS --allow-empty
; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: opt %loadPolly -basicaa -polly-detect -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -disable-output "-passes=print<polly-detect>" -aa-pipeline=basic-aa < %s\
; RUN: 2>&1 | FileCheck %s --check-prefix=PROFIT --allow-empty
; RUN: opt %loadPolly -basicaa -polly-detect -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -basicaa -polly-detect -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \ ; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -analyze < %s \ ; RUN: -polly-allow-nonaffine-loops=true -analyze < %s \
; RUN: | FileCheck %s --check-prefix=PROFIT ; RUN: | FileCheck %s --check-prefix=PROFIT
; ;
; Here we have a non-affine loop but also a non-affine access which should ; Here we have a non-affine loop but also a non-affine access which should
; be rejected as long as -polly-allow-nonaffine isn't given. ; be rejected as long as -polly-allow-nonaffine isn't given.
; ;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopDetect/non-affine-loop-condition-dependent-access_2.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: -polly-allow-nonaffine-loops=false \
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-detect -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 \ ; RUN: -analyze < %s \
; RUN: | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; ;
; 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 detect the ; and also a non-affine access (A[k]). While we can always detect the
; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not ; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/ScopDetect/non-affine-loop-condition-dependent-access_3.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: -polly-allow-nonaffine-loops=false \
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-detect -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 \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; ;
; 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 detect the ; and also a non-affine access (A[k]). While we can always detect the
; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not ; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/ScopDetect/non-affine-loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=REJECTNONAFFINELOOPS --allow-empty
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: -polly-allow-nonaffine-loops=false \
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -polly-allow-nonaffine \
; RUN: -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES --allow-empty
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -polly-allow-nonaffine \ ; RUN: -polly-allow-nonaffine-loops=false -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES ; RUN: --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -disable-output\
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \ ; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -polly-allow-nonaffine -disable-output "-passes=print<polly-detect>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=PROFIT \
; RUN: --allow-empty
; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect -polly-allow-nonaffine-branches \ ; RUN: -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \ ; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=PROFIT ; RUN: --check-prefix=PROFIT
; ;
; This function/region does contain a loop, however it is non-affine, hence the access ; This function/region does contain a loop, however it is non-affine, hence the access
; A[i] is also. Furthermore, it is the only loop, thus when we over approximate ; A[i] is also. Furthermore, it is the only loop, thus when we over approximate
; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will ; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopDetect/non-beneficial-loops-small-trip-count.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-detect \ ; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-detect \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: Valid ; CHECK-NOT: Valid
; ;
; Do not consider this a SCoP as we do not perform any optimizations for ; Do not consider this a SCoP as we do not perform any optimizations for
; loops with a small trip count. ; loops with a small trip count.
; ;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/ScopDetect/non-constant-add-rec-start-expr.ll

; RUN: opt %loadPolly - -disable-output "-passes=print<polly-detect>" < %s 2>&1\
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -\ ; RUN: opt %loadPolly -polly-detect -\
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: bb11 => bb25 ; CHECK: Valid Region for Scop: bb11 => bb25
; Ensure that this test case does not trigger an assertion. At some point, ; Ensure that this test case does not trigger an assertion. At some point,
; we asserted on scops containing accesses where the access function contained ; we asserted on scops containing accesses where the access function contained
; an AddRec expression with a non-constant step expression. This got missed, as ; an AddRec expression with a non-constant step expression. This got missed, as
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopDetect/non-simple-memory-accesses.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-detect \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; Verify that we do not model atomic memory accesses. We did not reason about ; Verify that we do not model atomic memory accesses. We did not reason about
; how to handle them correctly and the Alias Set Tracker models some of them ; how to handle them correctly and the Alias Set Tracker models some of them
; only as Unknown Instructions, which we do not know how to handle either.; ; only as Unknown Instructions, which we do not know how to handle either.;
; ;
; CHECK-NOT: Valid ; CHECK-NOT: Valid
Show All 22 Lines

test/ScopDetect/non_affine_loop_condition.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \ ; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=PROFIT --allow-empty
; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \ ; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \
; RUN: < %s | FileCheck %s --check-prefix=PROFIT ; RUN: < %s | FileCheck %s --check-prefix=PROFIT
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; while (A[i]) ; while (A[i])
; A[i]--; ; A[i]--;
; } ; }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopDetect/only-one-affine-loop.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false -disable-output \
; RUN: -polly-allow-nonaffine-loops "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-process-unprofitable=false -analyze \ ; RUN: opt %loadPolly -polly-detect -polly-process-unprofitable=false -analyze \
; RUN: -polly-allow-nonaffine-loops < %s | FileCheck %s ; RUN: -polly-allow-nonaffine-loops < %s | FileCheck %s
; ;
; Even if we allow non-affine loops we can only model the outermost loop, all ; Even if we allow non-affine loops we can only model the outermost loop, all
; other loops are boxed in non-affine regions. However, the inner loops can be ; other loops are boxed in non-affine regions. However, the inner loops can be
; distributed as black-boxes, thus we will recognize the outer loop as profitable. ; distributed as black-boxes, thus we will recognize the outer loop as profitable.
; ;
; CHECK: Valid Region for Scop: for.cond => for.end.51 ; CHECK: Valid Region for Scop: for.cond => for.end.51
▲ Show 20 Lines • Show All 159 Lines • Show Last 20 Lines

test/ScopDetect/only_func_flag.ll

; RUN: opt %loadPolly -disable-output "-polly-only-func=f,g" \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -polly-only-func=f,g < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-only-func=f,g < %s | FileCheck %s
; ;
; Check that the flag `-polly-only-func` limits analysis to `f` and `g`. ; Check that the flag `-polly-only-func` limits analysis to `f` and `g`.
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
; ;
; CHECK: Function: g ; CHECK: Function: g
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

test/ScopDetect/parametric-multiply-in-scev-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; CHECK-NOT: Valid Region ; CHECK-NOT: Valid Region
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define void @blam(float* %A, float* %B) { define void @blam(float* %A, float* %B) {
bb: bb:
Show All 20 Lines

test/ScopDetect/parametric-multiply-in-scev.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; foo(float *A, long n, long k) { ; foo(float *A, long n, long k) {
; if (true) ; if (true)
; A[n * k] = 0; ; A[n * k] = 0;
; } ; }
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"
Show All 18 Lines

test/ScopDetect/phi_with_multi_exiting_edges.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-detect>" < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze -S < %s | FileCheck %s
; ;
; Region with an exit node that has a PHI node multiple incoming edges from ; Region with an exit node that has a PHI node multiple incoming edges from
; inside the region. Motivation for supporting such cases in Polly. ; inside the region. Motivation for supporting such cases in Polly.
; ;
; float test(long n, float A[static const restrict n]) { ; float test(long n, float A[static const restrict n]) {
; float sum = 0; ; float sum = 0;
; for (long i = 0; i < n; i += 1) ; for (long i = 0; i < n; i += 1)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopDetect/profitability-large-basic-blocks.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect-profitability-min-per-loop-insts=40 -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect-profitability-min-per-loop-insts=40 \ ; RUN: -polly-detect-profitability-min-per-loop-insts=40 \
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE ; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=true -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=true \ ; RUN: opt %loadPolly -polly-process-unprofitable=true \
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE ; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=false -disable-output \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=UNPROFITABLE --allow-empty
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: \ ; RUN: \
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=UNPROFITABLE ; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=UNPROFITABLE
; UNPROFITABLE-NOT: Valid Region for Scop: ; UNPROFITABLE-NOT: Valid Region for Scop:
; PROFITABLE: Valid Region for Scop: ; PROFITABLE: Valid Region for Scop:
; void foo(float *A, float *B, long N) { ; void foo(float *A, float *B, long N) {
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/ScopDetect/remove_all_children.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %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"
define void @remove_all_children(i32* %eclass) { define void @remove_all_children(i32* %eclass) {
entry: entry:
br label %while.body br label %while.body
Show All 36 Lines

test/ScopDetect/report-scop-location.ll

; RUN: opt %loadPolly -polly-report -disable-output < %s 2>&1 \
; RUN: "-passes=require<polly-detect>" -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-report -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-detect -polly-report -disable-output < %s 2>&1 | FileCheck %s
target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(float* %A) #0 !dbg !4 { define void @foo(float* %A) #0 !dbg !4 {
entry: entry:
br label %entry.split br label %entry.split
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopDetect/restrict-undef-size-scopdetect.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
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"
%struct.bar = type { i32, [4 x i32] } %struct.bar = type { i32, [4 x i32] }
define void @f(%struct.bar* %arg) { define void @f(%struct.bar* %arg) {
Show All 25 Lines

test/ScopDetect/run_time_alias_check.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %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" 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"
declare float* @getNextBasePtr(float*) readnone nounwind declare float* @getNextBasePtr(float*) readnone nounwind
define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) { define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) {
entry: entry:
Show All 27 Lines

test/ScopDetect/scev_remove_max.ll

; RUN: opt %loadPolly "-passes=require<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect < %s
; This test case helps to determine wether SCEVRemoveMax::remove produces ; This test case helps to determine wether SCEVRemoveMax::remove produces
; an infinite loop and a segmentation fault, if it processes, for example, ; an infinite loop and a segmentation fault, if it processes, for example,
; '((-1 + (-1 * %b1)) umax {(-1 + (-1 * %yStart)),+,-1}<%.preheader>)'. ; '((-1 + (-1 * %b1)) umax {(-1 + (-1 * %yStart)),+,-1}<%.preheader>)'.
; ;
; In this case, the SCoP is invalid. However, SCoP detection failed when ; In this case, the SCoP is invalid. However, SCoP detection failed when
; running over it. ; running over it.
Show All 32 Lines

test/ScopDetect/sequential_loops.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %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" 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"
; Two sequential loops right after each other. ; Two sequential loops right after each other.
; ;
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
define void @f1(i64* %A, i64 %N) nounwind { define void @f1(i64* %A, i64 %N) nounwind {
; CHECK-LABEL: 'Polly - Detect static control parts (SCoPs)' for function 'f1' ; CHECK-LABEL: f1
entry: entry:
fence seq_cst fence seq_cst
br label %for.i.1 br label %for.i.1
for.i.1: for.i.1:
%indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.i.1 ] %indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.i.1 ]
%scevgep = getelementptr i64, i64* %A, i64 %indvar %scevgep = getelementptr i64, i64* %A, i64 %indvar
store i64 %indvar, i64* %scevgep store i64 %indvar, i64* %scevgep
Show All 30 Lines
; preheader: ; preheader:
; ; ; ;
; ;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
define void @f2(i64* %A, i64 %N) nounwind { define void @f2(i64* %A, i64 %N) nounwind {
; CHECK-LABEL: 'Polly - Detect static control parts (SCoPs)' for function 'f2' ; CHECK-LABEL: f2
entry: entry:
fence seq_cst fence seq_cst
br label %for.i.1 br label %for.i.1
for.i.1: for.i.1:
%indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.i.1 ] %indvar = phi i64 [ 0, %entry ], [ %indvar.next, %for.i.1 ]
%scevgep = getelementptr i64, i64* %A, i64 %indvar %scevgep = getelementptr i64, i64* %A, i64 %indvar
store i64 %indvar, i64* %scevgep store i64 %indvar, i64* %scevgep
Show All 21 Lines

test/ScopDetect/simple_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 21 Lines

test/ScopDetect/simple_loop_non_single_entry.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true) ; if (true)
; goto loop; ; goto loop;
; else ; else
Show All 36 Lines

test/ScopDetect/simple_loop_non_single_exit.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 25 Lines

test/ScopDetect/simple_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
Show All 26 Lines

test/ScopDetect/simple_loop_two_phi_nodes.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; long i_non_canonical = 1; ; long i_non_canonical = 1;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = i_non_canonical; ; A[i] = i_non_canonical;
; i_non_canonical += 1; ; i_non_canonical += 1;
Show All 25 Lines

test/ScopDetect/simple_loop_with_param.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s -check-prefix=PHI
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s -check-prefix=PHI ; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s -check-prefix=PHI
; void f(long A[], long N, long *init_ptr) { ; void f(long A[], long N, long *init_ptr) {
; long i, j; ; long i, j;
; long i_non_canonical; ; long i_non_canonical;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopDetect/simple_loop_with_param_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-detect -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) {
Show All 38 Lines

test/ScopDetect/simple_non_single_entry.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true){ ; if (true){
; i = 0; ; i = 0;
; goto next; ; goto next;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopDetect/skip_function_attribute.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify polly skips this function ; Verify polly skips this function
; ;
; CHECK-NOT: Valid Region for Scop ; CHECK-NOT: Valid Region for Scop
; ;
; void polly_skip_me(int *A, int N) { ; void polly_skip_me(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
Show All 36 Lines

test/ScopDetect/srem_with_parametric_divisor.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
; ;
; void foo(float *A, long n, long p) { ; void foo(float *A, long n, long p) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[n % p] += 1; ; A[n % p] += 1;
; } ; }
Show All 27 Lines

test/ScopDetect/statistics.ll

; RUN: opt %loadPolly -stats -disable-output "-passes=require<polly-detect>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-detect -stats -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-detect -stats -disable-output < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-DAG: 4 polly-detect - Maximal number of loops in scops (profitable scops only) ; CHECK-DAG: 4 polly-detect - Maximal number of loops in scops (profitable scops only)
; CHECK-DAG: 4 polly-detect - Maximal number of loops in scops ; CHECK-DAG: 4 polly-detect - Maximal number of loops in scops
; CHECK-DAG: 11 polly-detect - Number of loops in scops (profitable scops only) ; CHECK-DAG: 11 polly-detect - Number of loops in scops (profitable scops only)
; CHECK-DAG: 11 polly-detect - Number of loops in scops ; CHECK-DAG: 11 polly-detect - Number of loops in scops
▲ Show 20 Lines • Show All 270 Lines • Show Last 20 Lines

test/ScopDetect/switch-in-loop-patch.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; CHECK-NOT: Valid ; CHECK-NOT: Valid
; Verify that we do not detect loops where the loop latch is a switch statement. ; Verify that we do not detect loops where the loop latch is a switch statement.
; Such loops are not yet supported by Polly. ; Such loops are not yet supported by Polly.
define void @f() { define void @f() {
Show All 13 Lines

test/ScopInfo/20110312-Fail-without-basicaa.ll

; This should be run without alias analysis enabled. ; This should be run without alias analysis enabled.
; RUN: opt %loadPolly "-passes=require<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
;RUN: opt %loadPolly -polly-scops < %s ;RUN: opt %loadPolly -polly-scops < %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%t.02.reg2mem = alloca float %t.02.reg2mem = alloca float
br label %entry.split br label %entry.split
Show All 17 Lines

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

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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"
declare void @foo() declare void @foo()
define i32 @main(i8* %A) nounwind uwtable { define i32 @main(i8* %A) nounwind uwtable {
entry: entry:
br label %for.cond br label %for.cond
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopInfo/2012-03-16-Crash-because-of-unsigned-in-scev.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
@array = external global [64 x i8], align 8 @array = external global [64 x i8], align 8
define void @foo(i32* %A) nounwind { define void @foo(i32* %A) nounwind {
entry: entry:
Show All 23 Lines

test/ScopInfo/2015-10-04-Crash-in-domain-generation.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %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"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @kernel_reg_detect([6 x i32]* %path) { define void @kernel_reg_detect([6 x i32]* %path) {
entry: entry:
br label %for.body.6 br label %for.body.6
Show All 24 Lines

test/ScopInfo/Alias-0.ll

; RUN: opt %loadPolly -disable-output < %s -stats 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-use-runtime-alias-checks=false -disable-output < \
; RUN: %s -stats 2>&1 "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NORTA
; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
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"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
%0 = tail call i32 (...) @rnd() nounwind ; <i32> [#uses=1] %0 = tail call i32 (...) @rnd() nounwind ; <i32> [#uses=1]
Show All 27 Lines

test/ScopInfo/Alias-1.ll

; RUN: opt %loadPolly -disable-output < %s -stats 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-use-runtime-alias-checks=false -disable-output < \
; RUN: %s -stats 2>&1 "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NORTA
; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
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"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
%0 = tail call i32 (...) @rnd() nounwind ; <i32> [#uses=1] %0 = tail call i32 (...) @rnd() nounwind ; <i32> [#uses=1]
Show All 28 Lines

test/ScopInfo/Alias-2.ll

; RUN: opt %loadPolly -disable-output < %s -stats 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-use-runtime-alias-checks=false -disable-output < \
; RUN: %s -stats 2>&1 "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NORTA
; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
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"
define void @f(i32** nocapture %ptrs, i64 %p0, i64 %p1, i64 %p2) nounwind { define void @f(i32** nocapture %ptrs, i64 %p0, i64 %p1, i64 %p2) nounwind {
bb.nph: bb.nph:
%0 = getelementptr inbounds i32*, i32** %ptrs, i64 %p0 ; <i32**> [#uses=1] %0 = getelementptr inbounds i32*, i32** %ptrs, i64 %p0 ; <i32**> [#uses=1]
Show All 26 Lines

test/ScopInfo/Alias-3.ll

; RUN: opt %loadPolly -disable-output < %s -stats 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-use-runtime-alias-checks=false -disable-output < \
; RUN: %s -stats 2>&1 "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NORTA
; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
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"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
br label %bb br label %bb
Show All 19 Lines

test/ScopInfo/Alias-4.ll

; RUN: opt %loadPolly -disable-basicaa -disable-output < %s -stats 2>&1 \
; RUN: "-passes=print<polly-function-scops>" | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -disable-basicaa -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -disable-basicaa -polly-scops -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -disable-basicaa -polly-use-runtime-alias-checks=false \
; RUN: -disable-output < %s -stats 2>&1 "-passes=print<polly-function-scops>" |\
; RUN: FileCheck %s --check-prefix=NORTA
; RUN: opt %loadPolly -disable-basicaa -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -disable-basicaa -polly-scops -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
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"
define void @f(i32* noalias nocapture %a, i32* noalias nocapture %b) nounwind { define void @f(i32* noalias nocapture %a, i32* noalias nocapture %b) nounwind {
bb.nph: bb.nph:
br label %bb br label %bb
Show All 19 Lines

test/ScopInfo/BoundChecks/single-loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST
; ;
; This only works after the post-dominator tree has been fixed. ; This only works after the post-dominator tree has been fixed.
; ;
; XFAIL: * ; XFAIL: *
; ;
; void exception() __attribute__((noreturn)); ; void exception() __attribute__((noreturn));
; ;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/BoundChecks/two-loops.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST
; ;
; This only works after the post-dominator tree has fixed. ; This only works after the post-dominator tree has fixed.
; XFAIL: * ; XFAIL: *
; ;
; void exception() __attribute__((noreturn)); ; void exception() __attribute__((noreturn));
; ;
; void foo(long n, float A[100]) { ; void foo(long n, float A[100]) {
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/div_backedge.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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 = 1;; i++) { ; for (long i = 1;; i++) {
; A[i] += 1; ; A[i] += 1;
; if (i / 7 == 4) ; if (i / 7 == 4)
; break; ; break;
; } ; }
Show All 34 Lines

test/ScopInfo/NonAffine/div_domain.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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;
; } ; }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/invariant_loads_dependent_in_non_affine_region.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(int *A, int *B, int *C) { ; void f(int *A, int *B, int *C) {
; for (int i = 0; i < 1000; i++) ; for (int i = 0; i < 1000; i++)
; if (A[i] == *B) ; if (A[i] == *B)
; A[i] = *C; ; A[i] = *C;
; } ; }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/modulo_backedge.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 6 }; ; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 6 };
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 1;; i++) { ; for (long i = 1;; i++) {
; A[i] += 1; ; A[i] += 1;
Show All 34 Lines

test/ScopInfo/NonAffine/modulo_domain.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; TODO: The new domain generation cannot handle modulo domain constraints, ; TODO: The new domain generation cannot handle modulo domain constraints,
; hence modulo handling has been disabled completely. Once this is ; hence modulo handling has been disabled completely. Once this is
; resolved this test should work again. Until then we approximate the ; resolved this test should work again. Until then we approximate the
; whole loop body. ; whole loop body.
; ;
; CHECK: Domain := ; CHECK: Domain :=
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=SCALAR
; 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 -polly-allow-nonaffine -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s -check-prefix=PROFIT \
; RUN: --allow-empty
; 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-NEXT: Region: %bb1---%bb13 ; SCALAR-NEXT: Region: %bb1---%bb13
; SCALAR-NEXT: Max Loop Depth: 1 ; SCALAR-NEXT: Max Loop Depth: 1
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: 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=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 -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: 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 -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=ALL
; 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 \ ; RUN: -analyze < %s | FileCheck %s \
; 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
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: 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=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 -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: 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 -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=ALL
; 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
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_access_with_range_2.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; 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]++;
; } ; }
; ;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_but_sdiv.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : 0 <= i0 < N }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : 0 <= i0 < N };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0] }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0] };
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_but_srem.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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;
; } ; }
; ;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_conditional_nested.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; 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(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; if (A[i - 1]) ; if (A[i - 1])
; A[i] = A[i - 2]; ; A[i] = A[i - 2];
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_conditional_surrounding_affine_loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true -polly-allow-nonaffine-loops=true \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; 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 -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALL
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; 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 \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALL ; RUN: --check-prefix=ALL
; ;
; Negative test for INNERMOST. ; Negative test for INNERMOST.
; At the moment we will optimistically assume A[i] in the conditional before the inner ; At the moment we will optimistically assume A[i] in the conditional before the inner
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_conditional_surrounding_non_affine_loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true -polly-allow-nonaffine-loops=true \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; 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 -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=ALL
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; 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
; RUN: opt %loadPolly -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=PROFIT --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; 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
; ;
; Negative test for INNERMOST. ; Negative test for INNERMOST.
; At the moment we will optimistically assume A[i] in the conditional before the inner ; At the moment we will optimistically assume A[i] in the conditional before the inner
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_float_compare.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; 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]++;
; } ; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_loop_condition.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-scops \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-process-unprofitable=false -polly-allow-nonaffine-loops \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=PROFIT --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-process-unprofitable=false \ ; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s \ ; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s \
; RUN: --check-prefix=PROFIT ; RUN: --check-prefix=PROFIT
; RUN: opt %loadPolly -polly-detect-reductions -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops -disable-output < %s \
; RUN: -polly-detect-reductions=false "-passes=print<polly-function-scops>" \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=NO-REDUCTION \
; RUN: --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-detect-reductions \ ; RUN: opt %loadPolly -polly-scops -polly-detect-reductions \
; RUN: -polly-allow-nonaffine-branches \ ; RUN: -polly-allow-nonaffine-branches \
; RUN: \ ; RUN: \
; RUN: -polly-allow-nonaffine-loops -analyze < %s \ ; RUN: -polly-allow-nonaffine-loops -analyze < %s \
; RUN: -polly-detect-reductions=false \ ; RUN: -polly-detect-reductions=false \
; RUN: | FileCheck %s -check-prefix=NO-REDUCTION ; RUN: | FileCheck %s -check-prefix=NO-REDUCTION
; ;
; void f(int *A, int *C) { ; void f(int *A, int *C) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_loop_used_later.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; 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-allow-nonaffine \
; RUN: -polly-unprofitable-scalar-accs=true -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=PROFIT --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-unprofitable-scalar-accs=true \ ; RUN: -polly-unprofitable-scalar-accs=true \
; 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.
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/non_affine_parametric_loop.ll

; RUN: opt %loadPolly -disable-output -polly-allow-nonaffine \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-nonaffine < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-nonaffine < %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, double A[], int INDEX[]) { ; void foo(long n, double A[], int INDEX[]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[INDEX[i]] = i; ; A[INDEX[i]] = i;
; } ; }
Show All 31 Lines

test/ScopInfo/NonAffine/non_affine_region_guaranteed_non-entry.ll

; RUN: opt %loadPolly -disable-output -polly-allow-nonaffine-loops \
; RUN: "-passes=function(print<polly-detect>,print<polly-function-scops>)" < %s\
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-detect -polly-scops -analyze \
; RUN: -polly-allow-nonaffine-loops < %s | FileCheck %s ; RUN: -polly-allow-nonaffine-loops < %s | FileCheck %s
; The BasicBlock "guaranteed" is always executed inside the non-affine subregion ; The BasicBlock "guaranteed" is always executed inside the non-affine subregion
; region_entry->region_exit. As such, writes accesses in blocks that always ; region_entry->region_exit. As such, writes accesses in blocks that always
; execute are MustWriteAccesses. Before Polly commit r255473, we only assumed ; execute are MustWriteAccesses. Before Polly commit r255473, we only assumed
; that the subregion's entry block is guaranteed to execute. ; that the subregion's entry block is guaranteed to execute.
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/ScopInfo/NonAffine/whole-scop-non-affine-subregion-in-loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; ;
; Regression test that triggered a memory leak at some point (24947). ; Regression test that triggered a memory leak at some point (24947).
; ;
define void @snrm2() { define void @snrm2() {
entry: entry:
br label %for.body.56.lr.ph br label %for.body.56.lr.ph
Show All 22 Lines

test/ScopInfo/aliasing_conditional_alias_groups_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that there is no alias group because we either access A or B never both. ; Check that there is no alias group because we either access A or B never both.
; ;
; CHECK: Alias Groups (0): ; CHECK: Alias Groups (0):
; ;
; void jd(int b, int *A, int *B) { ; void jd(int b, int *A, int *B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_conditional_alias_groups_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that we create two alias groups since the mininmal/maximal accesses ; Check that we create two alias groups since the mininmal/maximal accesses
; depend on %b. ; depend on %b.
; ;
; CHECK: Alias Groups (2): ; CHECK: Alias Groups (2):
; ;
; void jd(int b, int *A, int *B) { ; void jd(int b, int *A, int *B) {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_dead_access.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; ;
; Check that we do not create a SCoP if there is no statement executed. ; Check that we do not create a SCoP if there is no statement executed.
; ;
; CHECK-NOT: Context ; CHECK-NOT: Context
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_many_arrays_to_compare.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=FOUND
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: < %s | FileCheck %s --check-prefix=FOUND ; RUN: < %s | FileCheck %s --check-prefix=FOUND
; RUN: opt %loadPolly -disable-output -polly-rtc-max-arrays-per-group=3 \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=IGNORED --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-rtc-max-arrays-per-group=3 < %s | FileCheck %s \ ; RUN: -polly-rtc-max-arrays-per-group=3 < %s | FileCheck %s \
; RUN: --check-prefix=IGNORED ; RUN: --check-prefix=IGNORED
; ;
; FOUND: Function: foo ; FOUND: Function: foo
; IGNORED-NOT: Function: foo ; IGNORED-NOT: Function: foo
; ;
; void foo(float *A, float *B, float *C, float *D) { ; void foo(float *A, float *B, float *C, float *D) {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

; RUN: opt %loadPolly -polly-rtc-max-parameters=8 -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=MAX8
; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8 ; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8
; RUN: opt %loadPolly -polly-rtc-max-parameters=7 -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=MAX7 --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7 ; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7
; ;
; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses. ; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A. ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
; ;
; MAX8-LABEL: Function: jd ; MAX8-LABEL: Function: jd
; MAX8-NEXT: Region: %for.cond---%for.end ; MAX8-NEXT: Region: %for.cond---%for.end
; MAX7: Invalid Scop! ; MAX7-NOT: Function:
; ;
; void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5, ; void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5,
; long p6, long p7, long p8, long p9, long p10) { ; long p6, long p7, long p8, long p9, long p10) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[p1] - B[p2] + B[-p3] - B[p4] + B[p5] - B[-p6] + B[p7] - C[p3] + ; A[i] = B[p1] - B[p2] + B[-p3] - B[p4] + B[p5] - B[-p6] + B[p7] - C[p3] +
; C[-p4] - C[p5] + C[p6] - C[-p7] + C[p8] - C[p9] + C[-p10]; ; C[-p4] - C[p5] + C[p6] - C[-p7] + C[p8] - C[p9] + C[-p10];
; } ; }
; ;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_many_read_only_acesses.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; ;
; Make sure the large number of read-only accesses does not cause make us ; Make sure the large number of read-only accesses does not cause make us
; invalidate the scop. ; invalidate the scop.
; ;
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_multiple_alias_groups.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=type-based-aa < %s 2>&1 | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-scops -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-scops -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
; ;
; void jd(int *Int0, int *Int1, float *Float0, float *Float1) { ; void jd(int *Int0, int *Int1, float *Float0, float *Float1) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; Int0[i] = Int1[i]; ; Int0[i] = Int1[i];
; Float0[i] = Float1[i]; ; Float0[i] = Float1[i];
; } ; }
; } ; }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/ScopInfo/aliasing_with_non_affine_access.ll

; RUN: opt %loadPolly -disable-output -polly-process-unprofitable \
; RUN: -polly-allow-nonaffine "-passes=print<polly-ast>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -analyze -polly-ast -polly-process-unprofitable -polly-allow-nonaffine < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-ast -polly-process-unprofitable -polly-allow-nonaffine < %s | FileCheck %s
; ;
; @test1 ; @test1
; Make sure we generate the correct aliasing check for a fixed-size memset operation. ; Make sure we generate the correct aliasing check for a fixed-size memset operation.
; CHECK: if (1 && (&MemRef_tmp0[15] <= &MemRef_tmp1[0] || &MemRef_tmp1[32] <= &MemRef_tmp0[14])) ; CHECK: if (1 && (&MemRef_tmp0[15] <= &MemRef_tmp1[0] || &MemRef_tmp1[32] <= &MemRef_tmp0[14]))
; ;
; @test2 ; @test2
; Make sure we generate the correct aliasing check for a variable-size memset operation. ; Make sure we generate the correct aliasing check for a variable-size memset operation.
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

test/ScopInfo/assume_gep_bounds.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; void foo(float A[][20][30], long n, long m, long p) { ; void foo(float A[][20][30], long n, long m, long p) {
; 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 < p; k++) ; for (long k = 0; k < p; k++)
; A[i][j][k] = i + j + k; ; A[i][j][k] = i + j + k;
; } ; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/assume_gep_bounds_2.ll

; RUN: opt %loadPolly -disable-output < %s -polly-precise-inbounds \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s \
; RUN: -polly-precise-inbounds | FileCheck %s ; RUN: -polly-precise-inbounds | FileCheck %s
; ;
; void foo(float A[restrict][20], float B[restrict][20], long n, long m, ; void foo(float A[restrict][20], float B[restrict][20], long n, long m,
; long p) { ; long p) {
; 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] = i + j; ; A[i][j] = i + j;
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/ScopInfo/assume_gep_bounds_many.ll

; RUN: opt %loadPolly -disable-output -polly-ignore-aliasing \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops -polly-ignore-aliasing \ ; RUN: opt %loadPolly -analyze -polly-scops -polly-ignore-aliasing \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [n1_a, n1_b, n1_c, n1_d, n2_a, n2_b, n2_c, n2_d, n3_a, n3_b, n3_c, n3_d, n4_a, n4_b, n4_c, n4_d, n5_a, n5_b, n5_c, n5_d, n6_a, n6_b, n6_c, n6_d, n7_a, n7_b, n7_c, n7_d, n8_a, n8_b, n8_c, n8_d, n9_a, n9_b, n9_c, n9_d, p1_b, p1_c, p1_d, p2_b, p2_c, p2_d, p3_b, p3_c, p3_d, p4_b, p4_c, p4_d, p5_b, p5_c, p5_d, p6_b, p6_c, p6_d, p7_b, p7_c, p7_d, p8_b, p8_c, p8_d, p9_b, p9_c, p9_d] -> { : p1_b >= n1_b and p1_c >= n1_c and p1_d >= n1_d and p2_b >= n2_b and p2_c >= n2_c and p2_d >= n2_d and p3_b >= n3_b and p3_c >= n3_c and p3_d >= n3_d and p4_b >= n4_b and p4_c >= n4_c and p4_d >= n4_d and p5_b >= n5_b and p5_c >= n5_c and p5_d >= n5_d and p6_b >= n6_b and p6_c >= n6_c and p6_d >= n6_d and p7_b >= n7_b and p7_c >= n7_c and p7_d >= n7_d and p8_b >= n8_b and p8_c >= n8_c and p8_d >= n8_d and p9_b >= n9_b and p9_c >= n9_c and p9_d >= n9_d } ; CHECK-NEXT: [n1_a, n1_b, n1_c, n1_d, n2_a, n2_b, n2_c, n2_d, n3_a, n3_b, n3_c, n3_d, n4_a, n4_b, n4_c, n4_d, n5_a, n5_b, n5_c, n5_d, n6_a, n6_b, n6_c, n6_d, n7_a, n7_b, n7_c, n7_d, n8_a, n8_b, n8_c, n8_d, n9_a, n9_b, n9_c, n9_d, p1_b, p1_c, p1_d, p2_b, p2_c, p2_d, p3_b, p3_c, p3_d, p4_b, p4_c, p4_d, p5_b, p5_c, p5_d, p6_b, p6_c, p6_d, p7_b, p7_c, p7_d, p8_b, p8_c, p8_d, p9_b, p9_c, p9_d] -> { : p1_b >= n1_b and p1_c >= n1_c and p1_d >= n1_d and p2_b >= n2_b and p2_c >= n2_c and p2_d >= n2_d and p3_b >= n3_b and p3_c >= n3_c and p3_d >= n3_d and p4_b >= n4_b and p4_c >= n4_c and p4_d >= n4_d and p5_b >= n5_b and p5_c >= n5_c and p5_d >= n5_d and p6_b >= n6_b and p6_c >= n6_c and p6_d >= n6_d and p7_b >= n7_b and p7_c >= n7_c and p7_d >= n7_d and p8_b >= n8_b and p8_c >= n8_c and p8_d >= n8_d and p9_b >= n9_b and p9_c >= n9_c and p9_d >= n9_d }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [n1_a, n1_b, n1_c, n1_d, n2_a, n2_b, n2_c, n2_d, n3_a, n3_b, n3_c, n3_d, n4_a, n4_b, n4_c, n4_d, n5_a, n5_b, n5_c, n5_d, n6_a, n6_b, n6_c, n6_d, n7_a, n7_b, n7_c, n7_d, n8_a, n8_b, n8_c, n8_d, n9_a, n9_b, n9_c, n9_d, p1_b, p1_c, p1_d, p2_b, p2_c, p2_d, p3_b, p3_c, p3_d, p4_b, p4_c, p4_d, p5_b, p5_c, p5_d, p6_b, p6_c, p6_d, p7_b, p7_c, p7_d, p8_b, p8_c, p8_d, p9_b, p9_c, p9_d] -> { : false } ; CHECK-NEXT: [n1_a, n1_b, n1_c, n1_d, n2_a, n2_b, n2_c, n2_d, n3_a, n3_b, n3_c, n3_d, n4_a, n4_b, n4_c, n4_d, n5_a, n5_b, n5_c, n5_d, n6_a, n6_b, n6_c, n6_d, n7_a, n7_b, n7_c, n7_d, n8_a, n8_b, n8_c, n8_d, n9_a, n9_b, n9_c, n9_d, p1_b, p1_c, p1_d, p2_b, p2_c, p2_d, p3_b, p3_c, p3_d, p4_b, p4_c, p4_d, p5_b, p5_c, p5_d, p6_b, p6_c, p6_d, p7_b, p7_c, p7_d, p8_b, p8_c, p8_d, p9_b, p9_c, p9_d] -> { : false }
▲ Show 20 Lines • Show All 763 Lines • Show Last 20 Lines

test/ScopInfo/avoid_new_parameters_from_geps.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that we do no introduce a parameter here that is actually not needed. ; Check that we do no introduce a parameter here that is actually not needed.
; ;
; CHECK: Region: %for.body58---%land.lhs.true ; CHECK: Region: %for.body58---%land.lhs.true
; CHECK-NEXT: Max Loop Depth: 0 ; CHECK-NEXT: Max Loop Depth: 0
; CHECK-NEXT: Invariant Accesses: { ; CHECK-NEXT: Invariant Accesses: {
; CHECK-NEXT: } ; CHECK-NEXT: }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/bool-addrec.ll

; RUN: opt %loadPolly -disable-output -polly-process-unprofitable \
; RUN: "-passes=print<polly-ast>" < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -analyze -polly-ast -polly-process-unprofitable < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-ast -polly-process-unprofitable < %s | FileCheck %s
; CHECK: for (int c0 = 0; c0 <= 19999; c0 += 1) { ; CHECK: for (int c0 = 0; c0 <= 19999; c0 += 1) {
; CHECK-NEXT: if (c0 % 2 == 0) ; CHECK-NEXT: if (c0 % 2 == 0)
; CHECK-NEXT: Stmt_if_then(c0); ; CHECK-NEXT: Stmt_if_then(c0);
; CHECK-NEXT: Stmt_if_end(c0); ; CHECK-NEXT: Stmt_if_end(c0);
; CHECK-NEXT: if (c0 % 2 == 0) ; CHECK-NEXT: if (c0 % 2 == 0)
; CHECK-NEXT: Stmt_if_then5(c0); ; CHECK-NEXT: Stmt_if_then5(c0);
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/bounded_loop_assumptions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; The assumed context is tricky here as the equality test for the inner loop ; The assumed context is tricky here as the equality test for the inner loop
; allows an "unbounded" loop trip count. We assume that does not happen, thus ; allows an "unbounded" loop trip count. We assume that does not happen, thus
; if N <= 1 the outer loop is not executed and we are done, if N >= 3 the ; if N <= 1 the outer loop is not executed and we are done, if N >= 3 the
; equality test in the inner exit condition will trigger at some point and, ; equality test in the inner exit condition will trigger at some point and,
; finally, if N == 2 we would have an unbounded inner loop. ; finally, if N == 2 we would have an unbounded inner loop.
; ;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/ScopInfo/branch-references-loop-scev-with-unknown-iterations-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-detect -analyze < %s | \ ; RUN: opt %loadPolly -polly-detect -analyze < %s | \
; RUN: FileCheck %s -check-prefix=DETECT ; RUN: FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-scops -analyze < %s | \
; RUN: FileCheck %s -check-prefix=SCOP ; RUN: FileCheck %s -check-prefix=SCOP
; DETECT: Valid Region for Scop: loop => barrier ; DETECT: Valid Region for Scop: loop => barrier
; DETECT-NEXT: Valid Region for Scop: branch => end ; DETECT-NEXT: Valid Region for Scop: branch => end
; SCOP: Statements { ; SCOP: Statements {
; SCOP-NEXT: Stmt_then ; SCOP-NEXT: Stmt_then
Show All 36 Lines

test/ScopInfo/branch-references-loop-scev-with-unknown-iterations-3.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: FileCheck %s -check-prefix=NONAFFINE ; RUN: "-passes=print<polly-function-scops>" < %s -aa-pipeline=basic-aa \
; RUN: 2>&1 | FileCheck %s -check-prefix=NONAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: < %s | FileCheck %s -check-prefix=NONAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-nonaffine-branches=false \
; RUN: "-passes=print<polly-function-scops>" < %s -aa-pipeline=basic-aa 2>&1 | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-allow-nonaffine-branches=false < %s | \ ; RUN: -polly-allow-nonaffine-branches=false < %s | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE ; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
; NONAFFINE: Statements { ; NONAFFINE: Statements {
; NONAFFINE-NEXT: Stmt_loop ; NONAFFINE-NEXT: Stmt_loop
; NONAFFINE-NEXT: Domain := ; NONAFFINE-NEXT: Domain :=
; NONAFFINE-NEXT: [p] -> { Stmt_loop[0] : p = 100 }; ; NONAFFINE-NEXT: [p] -> { Stmt_loop[0] : p = 100 };
; NONAFFINE-NEXT: Schedule := ; NONAFFINE-NEXT: Schedule :=
; NONAFFINE-NEXT: [p] -> { Stmt_loop[i0] -> [0, 0] }; ; NONAFFINE-NEXT: [p] -> { Stmt_loop[i0] -> [0, 0] };
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/ScopInfo/branch-references-loop-scev-with-unknown-iterations.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=NONAFFINE -allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-scops -analyze < %s | \
; RUN: FileCheck %s -check-prefix=NONAFFINE ; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -disable-output -polly-allow-nonaffine-branches=false \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-allow-nonaffine-branches=false < %s | \ ; RUN: -polly-allow-nonaffine-branches=false < %s | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE ; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
; NONAFFINE-NOT: Statements ; NONAFFINE-NOT: Statements
; NO-NONEAFFINE: Statements { ; NO-NONEAFFINE: Statements {
; NO-NONEAFFINE-NEXT: Stmt_then ; NO-NONEAFFINE-NEXT: Stmt_then
Show All 40 Lines

test/ScopInfo/bug_2010_10_22.ll

; RUN: opt %loadPolly "-passes=require<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops < %s ; RUN: opt %loadPolly -polly-scops < %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" 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"
define fastcc void @_Z8wavModelR5Mixer() { define fastcc void @_Z8wavModelR5Mixer() {
entry: entry:
br label %bb230 br label %bb230
Show All 37 Lines

test/ScopInfo/bug_2011_1_5.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; Bug description: Alias Analysis thinks IntToPtrInst aliases with alloca instructions created by IndependentBlocks Pass. ; Bug description: Alias Analysis thinks IntToPtrInst aliases with alloca instructions created by IndependentBlocks Pass.
; This will trigger the assertion when we are verifying the SCoP after IndependentBlocks. ; This will trigger the assertion when we are verifying the SCoP after IndependentBlocks.
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"
%struct.precisionType = type { i16, i16, i16, i8, [1 x i16] } %struct.precisionType = type { i16, i16, i16, i8, [1 x i16] }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/ScopInfo/bug_scev_not_fully_eval.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | not FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | not 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" 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"
@edge.8265 = external global [72 x i32], align 32 ; <[72 x i32]*> [#uses=1] @edge.8265 = external global [72 x i32], align 32 ; <[72 x i32]*> [#uses=1]
define void @compact_unitcell_edges() nounwind { define void @compact_unitcell_edges() nounwind {
bb.nph19: bb.nph19:
br label %bb4 br label %bb4
Show All 26 Lines

test/ScopInfo/cfg_consequences.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; ;
; void consequences(int *A, int bool_cond, int lhs, int rhs) { ; void consequences(int *A, int bool_cond, int lhs, int rhs) {
; ;
; BC: *A = 0; ; BC: *A = 0;
; if (bool_cond) ; if (bool_cond)
; S_BC: *A = 0; ; S_BC: *A = 0;
; M_BC: *A = 0; ; M_BC: *A = 0;
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

test/ScopInfo/complex-branch-structure.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; We build a scop of the following form to check that the domain construction ; We build a scop of the following form to check that the domain construction
; does not take a huge amount of time, but that we instead just bail out. ; does not take a huge amount of time, but that we instead just bail out.
; ;
; loop.header ; loop.header
; / | \ \ ; / | \ \
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

test/ScopInfo/complex-condition.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
; ;
; The IR is a modified version of the following C: ; The IR is a modified version of the following C:
; ;
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

test/ScopInfo/complex-expression.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; ;
; This test case has an SCEVSMax expression with a very high arity. The ; This test case has an SCEVSMax expression with a very high arity. The
; piecewise affine function we would create for it would have a huge amount of ; piecewise affine function we would create for it would have a huge amount of
; conjuncts, thus it would take a lot of time creating and handling it. ; conjuncts, thus it would take a lot of time creating and handling it.
; ;
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

test/ScopInfo/complex-loop-nesting.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body_outer ; CHECK-NEXT: Stmt_for_body_outer
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body_outer[i0] : 0 <= i0 <= 257 }; ; CHECK-NEXT: { Stmt_for_body_outer[i0] : 0 <= i0 <= 257 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_for_body_outer[i0] -> [i0, 0, 0, 0] }; ; CHECK-NEXT: { Stmt_for_body_outer[i0] -> [i0, 0, 0, 0] };
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/ScopInfo/complex-successor-structure-2.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; We build a scop for the region for.body->B13. The CFG is of the following ; We build a scop for the region for.body->B13. The CFG is of the following
; form and the branch conditions are build from "smax" SCEVs. However, in ; form and the branch conditions are build from "smax" SCEVs. However, in
; contrast to complex-success-structure.ll the smax constraints do not grow ; contrast to complex-success-structure.ll the smax constraints do not grow
; anymore after B3. This will keep the condition construction bounded. ; anymore after B3. This will keep the condition construction bounded.
▲ Show 20 Lines • Show All 531 Lines • Show Last 20 Lines

test/ScopInfo/complex-successor-structure-3.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -analyze -polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; Check that propagation of domains from A(X) to A(X+1) will keep the ; Check that propagation of domains from A(X) to A(X+1) will keep the
; domains small and concise. ; domains small and concise.
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [tmp5, tmp, tmp8, tmp11, tmp14, tmp17, tmp20, tmp23, tmp26] -> { : } ; CHECK-NEXT: [tmp5, tmp, tmp8, tmp11, tmp14, tmp17, tmp20, tmp23, tmp26] -> { : }
▲ Show 20 Lines • Show All 358 Lines • Show Last 20 Lines

test/ScopInfo/complex-successor-structure.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; We build a scop from the region for.body->B13. The CFG is of the ; We build a scop from the region for.body->B13. The CFG is of the
; following form. The test checks that the condition construction does not take ; following form. The test checks that the condition construction does not take
; a huge amount of time. While we can propagate the domain constraints from ; a huge amount of time. While we can propagate the domain constraints from
; B(X) to B(X+1) the conditions in B(X+1) will exponentially grow the number ; B(X) to B(X+1) the conditions in B(X+1) will exponentially grow the number
▲ Show 20 Lines • Show All 530 Lines • Show Last 20 Lines

test/ScopInfo/complex_domain_binary_condition.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
; ;
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"
%struct.bc_struct.0.2.4.6.13.20.27.43.44.46.50.52.58.60.81.89.90.99.107.108.109.111.116.118.149 = type { i32, i32, i32, i32, [1024 x i8] } %struct.bc_struct.0.2.4.6.13.20.27.43.44.46.50.52.58.60.81.89.90.99.107.108.109.111.116.118.149 = type { i32, i32, i32, i32, [1024 x i8] }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/ScopInfo/complex_execution_context.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: ; CHECK: Low complexity assumption:
; ;
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 40 Lines

test/ScopInfo/cond_constant_in_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
;void f(long a[], long N, long M) { ;void f(long a[], long N, long M) {
; long i, j, k; ; long i, j, k;
; for (j = 0; j < M; ++j) ; for (j = 0; j < M; ++j)
; if (true) ; if (true)
; a[j] = j; ; a[j] = j;
; else { ; else {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/cond_in_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
;void f(long a[], long N, long M) { ;void f(long a[], long N, long M) {
; long i, j, k; ; long i, j, k;
; for (j = 0; j < M; ++j) ; for (j = 0; j < M; ++j)
; if (N > j) ; if (N > j)
; a[j] = j; ; a[j] = j;
; else { ; else {
Show All 40 Lines

test/ScopInfo/const_srem_sdiv.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s -aa-pipeline=basic-aa 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; See http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf ; See http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf
; ;
; void f(long *A) { ; void f(long *A) {
; for (long i = 0; i < 10; i++) { ; for (long i = 0; i < 10; i++) {
; A[8 / 3] = A[8 % 3]; ; A[8 / 3] = A[8 % 3];
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

test/ScopInfo/constant-non-integer-branch-condition.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s
; ;
; At some point this caused a problem in the domain generation as we ; At some point this caused a problem in the domain generation as we
; assumed any constant branch condition to be valid. However, only constant ; assumed any constant branch condition to be valid. However, only constant
; integers are interesting and can be handled. ; integers are interesting and can be handled.
; ;
; CHECK: Stmt_entry_split__TO__cleanup ; CHECK: Stmt_entry_split__TO__cleanup
; ;
Show All 19 Lines

test/ScopInfo/constant_factor_in_parameter.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-function-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-function-scops < %s | FileCheck %s
; ;
; Check that the constant part of the N * M * 4 expression is not part of the ; Check that the constant part of the N * M * 4 expression is not part of the
; parameter but explicit in the access function. This can avoid existentially ; parameter but explicit in the access function. This can avoid existentially
; quantified variables, e.g., when computing the stride. ; quantified variables, e.g., when computing the stride.
; ;
; CHECK: p1: (%N * %M) ; CHECK: p1: (%N * %M)
; CHECK: [N, p_1] -> { Stmt_for_body[i0] -> MemRef_A[4p_1 + i0] }; ; CHECK: [N, p_1] -> { Stmt_for_body[i0] -> MemRef_A[4p_1 + i0] };
Show All 35 Lines

test/ScopInfo/constant_functions_as_unknowns.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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"
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [__global_id_0] -> { : -9223372036854775808 <= __global_id_0 <= 9223372036854775807 } ; CHECK-NEXT: [__global_id_0] -> { : -9223372036854775808 <= __global_id_0 <= 9223372036854775807 }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/constant_functions_multi_dim.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-detect-full-functions "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-detect-full-functions < %s | FileCheck %s ; RUN: -polly-detect-full-functions < %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"
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_entry_split ; CHECK-NEXT: Stmt_entry_split
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

test/ScopInfo/constant_functions_outside_scop_as_unknown.ll

; RUN: opt %loadPolly -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
; CHECK: Region: %for.cond62---%for.cond ; CHECK: Region: %for.cond62---%for.cond
; CHECK: p0: {0,+,1}<nuw><%for.cond> ; CHECK: p0: {0,+,1}<nuw><%for.cond>
; CHECK-NEXT: p1: %param1 ; CHECK-NEXT: p1: %param1
; CHECK-NEXT: p2: %param2 ; CHECK-NEXT: p2: %param2
Show All 28 Lines

test/ScopInfo/constant_start_integer.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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(float *input) { ; void foo(float *input) {
; for (int j = 0; j < 8; j++) { ; for (int j = 0; j < 8; j++) {
; //SCoP begin ; //SCoP begin
; for (int i = 0; i < 63; i++) { ; for (int i = 0; i < 63; i++) {
; float x = input[j * 64 + i + 1]; ; float x = input[j * 64 + i + 1];
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/delinearize-together-all-data-refs.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s -aa-pipeline=basic-aa \
; RUN: 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; 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;
; A[i][0][k] = 2.0; ; A[i][0][k] = 2.0;
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/ScopInfo/div_by_zero.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; 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 / 0]++; ; A[i / 0]++;
; } ; }
; ;
; CHECK-NOT: Statement ; CHECK-NOT: Statement
Show All 28 Lines

test/ScopInfo/do-not-model-error-block-accesses.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; Check that we do not crash on this input. Earlier this indeed crashed as ; Check that we do not crash on this input. Earlier this indeed crashed as
; we tried to model the access functions in an error block. ; we tried to model the access functions in an error block.
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
Show All 25 Lines

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

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; 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;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/ScopInfo/early_exit_for_complex_domains.ll

; RUN: opt %loadPolly -disable-output "-passes=require<polly-function-scops>" <\
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -disable-output < %s ; RUN: opt %loadPolly -polly-scops -disable-output < %s
; ;
; Check we do not crash. ; Check we do not crash.
; ;
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"
%struct.regnode_charclass_class.2.42.654.690.726.870.978.1770.1806.1842.2166.2274.2382.2598.2814.3030.3064 = type { i8, i8, i16, i32, [32 x i8], [4 x i8] } %struct.regnode_charclass_class.2.42.654.690.726.870.978.1770.1806.1842.2166.2274.2382.2598.2814.3030.3064 = type { i8, i8, i16, i32, [32 x i8], [4 x i8] }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/error-blocks-1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 } ; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 514 } ; CHECK-NEXT: [N] -> { : N >= 514 }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/ScopInfo/error-blocks-2.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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: [N, valid_val] -> { Stmt_for_body[i0] -> MemRef_valid[0] }; ; CHECK-NEXT: [N, valid_val] -> { Stmt_for_body[i0] -> MemRef_valid[0] };
; CHECK-NEXT: Execution Context: [N, valid_val] -> { : N > 0 } ; CHECK-NEXT: Execution Context: [N, valid_val] -> { : N > 0 }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/ScopInfo/error-blocks-3.ll

; RUN: opt %loadPolly -disable-output -polly-detect-keep-going \
; RUN: -polly-allow-nonaffine "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops -polly-detect-keep-going -polly-allow-nonaffine < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops -polly-detect-keep-going -polly-allow-nonaffine < %s | FileCheck %s
; ;
; TODO: FIXME: Investigate why "-polly-detect-keep-going" is needed to detect ; TODO: FIXME: Investigate why "-polly-detect-keep-going" is needed to detect
; this SCoP. That flag should not make a difference. ; this SCoP. That flag should not make a difference.
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 } ; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/escaping_empty_scop.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s -aa-pipeline=basic-aa \
; RUN: 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; void g(); ; void g();
; int f(int *A) { ; int f(int *A) {
; int a0 = 0, a1 = 0, a2 = 0; ; int a0 = 0, a1 = 0, a2 = 0;
; for (int i = 0; i < 1000; i++) { ; for (int i = 0; i < 1000; i++) {
; a0 = 2 * i; ; a0 = 2 * i;
; // split ; // split
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/exit-phi-1.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -passes=polly-codegen < %s \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; Check for correct code generation of exit PHIs, even if the same PHI value ; Check for correct code generation of exit PHIs, even if the same PHI value
; is used again inside the the SCoP. ; is used again inside the the SCoP.
; Note that if.else113 is removed from the SCoP because it is never executed. ; Note that if.else113 is removed from the SCoP because it is never executed.
; ;
; CHECK: Region: %for.body ; CHECK: Region: %for.body
; ;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/exit-phi-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that there is no MK_ExitPHI READ access. ; Check that there is no MK_ExitPHI READ access.
; ;
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 @local_book_besterror() { define void @local_book_besterror() {
entry: entry:
Show All 34 Lines

test/ScopInfo/exit_phi_accesses-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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] : 0 <= i0 <= 100 }; ; CHECK-NEXT: { Stmt_body[i0] : 0 <= i0 <= 100 };
Show All 40 Lines

test/ScopInfo/exit_phi_accesses.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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
; ;
Show All 37 Lines

test/ScopInfo/expensive-boundary-context.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK-NOT: Assumed Context: ; CHECK-NOT: Assumed Context:
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"
%struct.hoge = type { i32, %struct.widget*, %struct.ham*, %struct.ham*, i32, %struct.wombat*, double*, i32, i32, i32**, i32, i32*, [6 x i32], i32, %struct.foo*, i32 } %struct.hoge = type { i32, %struct.widget*, %struct.ham*, %struct.ham*, i32, %struct.wombat*, double*, i32, i32, i32**, i32, i32*, [6 x i32], i32, %struct.foo*, i32 }
%struct.widget = type { i32, i32, %struct.wombat*, i32*, %struct.quux*, i32, %struct.barney*, i32, i32, [3 x i32], i32 } %struct.widget = type { i32, i32, %struct.wombat*, i32*, %struct.quux*, i32, %struct.barney*, i32, i32, [3 x i32], i32 }
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

test/ScopInfo/extract_constant_factor_introduces_new_parameter.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; CHECK: Valid Region for Scop: bb10 => bb16 ; CHECK: Valid Region for Scop: bb10 => bb16
; Verify that -polly-scops does not crash. At some point this piece of ; Verify that -polly-scops does not crash. At some point this piece of
; code crashed as we extracted from the SCEV expression: ; code crashed as we extracted from the SCEV expression:
; ;
; ((8 * ((%a * %b) + %c)) + (-8 * %a))' ; ((8 * ((%a * %b) + %c)) + (-8 * %a))'
Show All 32 Lines

test/ScopInfo/fortran_array_global_malloc_nonvectored.ll

; RUN: opt %loadPolly -disable-output -S -polly-detect-fortran-arrays \
; RUN: -polly-process-unprofitable "-passes=print<polly-function-scops>" < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -S -polly-detect-fortran-arrays \ ; RUN: opt %loadPolly -analyze -S -polly-detect-fortran-arrays \
; RUN: -polly-process-unprofitable -polly-scops < %s | FileCheck %s ; RUN: -polly-process-unprofitable -polly-scops < %s | FileCheck %s
; MODULE src_soil ; MODULE src_soil
; USE data_parameters, ONLY : & ; USE data_parameters, ONLY : &
; wp, & ! KIND-type parameter for real variables ; wp, & ! KIND-type parameter for real variables
; iintegers ! KIND-type parameter for standard integer variables ; iintegers ! KIND-type parameter for standard integer variables
; IMPLICIT NONE ; IMPLICIT NONE
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

test/ScopInfo/fortran_array_global_nonmalloc_nonvectored.ll

; RUN: opt %loadPolly -disable-output -S -polly-detect-fortran-arrays \
; RUN: -polly-process-unprofitable "-passes=print<polly-function-scops>" < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -S -polly-detect-fortran-arrays \ ; RUN: opt %loadPolly -analyze -S -polly-detect-fortran-arrays \
; RUN: -polly-process-unprofitable -polly-scops < %s | FileCheck %s ; RUN: -polly-process-unprofitable -polly-scops < %s | FileCheck %s
; MODULE src_soil ; MODULE src_soil
; USE data_parameters, ONLY : & ; USE data_parameters, ONLY : &
; wp, & ! KIND-type parameter for real variables ; wp, & ! KIND-type parameter for real variables
; iintegers ! KIND-type parameter for standard integer variables ; iintegers ! KIND-type parameter for standard integer variables
; IMPLICIT NONE ; IMPLICIT NONE
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/fortran_array_param_nonmalloc_nonvectored.ll

; RUN: opt %loadPolly -disable-output -polly-detect-fortran-arrays \
; RUN: -polly-allow-nonaffine -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-detect-fortran-arrays \ ; RUN: opt %loadPolly -analyze -polly-detect-fortran-arrays \
; RUN: -polly-scops -polly-allow-nonaffine -polly-invariant-load-hoisting < %s | FileCheck %s ; RUN: -polly-scops -polly-allow-nonaffine -polly-invariant-load-hoisting < %s | FileCheck %s
; This testcase is the corresponding LLVM for testfunc: ; This testcase is the corresponding LLVM for testfunc:
; PROGRAM main ; PROGRAM main
; INTEGER, DIMENSION(1) :: xs ; INTEGER, DIMENSION(1) :: xs
; ;
; CALL testfunc(xs, 10) ; CALL testfunc(xs, 10)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/fortran_array_param_nonmalloc_nonvectored_read_and_write.ll

; RUN: opt %loadPolly -disable-output -polly-detect-fortran-arrays \
; RUN: -polly-allow-nonaffine -polly-ignore-aliasing \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-detect-fortran-arrays \ ; RUN: opt %loadPolly -analyze -polly-detect-fortran-arrays \
; RUN: -polly-scops -polly-allow-nonaffine -polly-ignore-aliasing < %s | FileCheck %s ; RUN: -polly-scops -polly-allow-nonaffine -polly-ignore-aliasing < %s | FileCheck %s
; PROGRAM main ; PROGRAM main
; ... ; ...
; CONTAINS ; CONTAINS
; SUBROUTINE copy(xs, ys, n) ; SUBROUTINE copy(xs, ys, n)
; IMPLICIT NONE ; IMPLICIT NONE
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

test/ScopInfo/full-function.ll

; RUN: opt %loadPolly -disable-output -polly-detect-full-functions \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=FULL
; RUN: opt %loadPolly -polly-scops -analyze -polly-detect-full-functions < %s \ ; RUN: opt %loadPolly -polly-scops -analyze -polly-detect-full-functions < %s \
; RUN: | FileCheck %s -check-prefix=FULL ; RUN: | FileCheck %s -check-prefix=FULL
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=WITHOUT-FULL
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: | FileCheck %s -check-prefix=WITHOUT-FULL ; RUN: | FileCheck %s -check-prefix=WITHOUT-FULL
; FULL: Region: %bb---FunctionExit ; FULL: Region: %bb---FunctionExit
; FULL: Statements { ; FULL: Statements {
; FULL-NEXT: Stmt_loop_1 ; FULL-NEXT: Stmt_loop_1
; FULL-NEXT: Domain := ; FULL-NEXT: Domain :=
; FULL-NEXT: [p] -> { Stmt_loop_1[i0] : p = 42 and 0 <= i0 <= 1025 }; ; FULL-NEXT: [p] -> { Stmt_loop_1[i0] : p = 42 and 0 <= i0 <= 1025 };
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/ScopInfo/i1_params.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that both a signed as well as an unsigned extended i1 parameter ; Check that both a signed as well as an unsigned extended i1 parameter
; is represented correctly. ; is represented correctly.
; ;
; void f(signed i1 p0, unsigned i1 p1, int *A) { ; void f(signed i1 p0, unsigned i1 p1, int *A) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; A[i + p0] = A[i + p1]; ; A[i + p0] = A[i + p1];
Show All 39 Lines

test/ScopInfo/infeasible-rtc.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-detect -analyze < %s \
; RUN: | FileCheck %s -check-prefix=DETECT ; RUN: | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: | FileCheck %s -check-prefix=SCOPS ; RUN: | FileCheck %s -check-prefix=SCOPS
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"
; DETECT: Valid Region for Scop: test1.header => test1.exit ; DETECT: Valid Region for Scop: test1.header => test1.exit
; SCOPS-NOT: Region: %test1.header---%test1.exit ; SCOPS-NOT: Region: %test1.header---%test1.exit
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/infeasible_invalid_context.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-detect -analyze < %s \
; RUN: | FileCheck %s -check-prefix=DETECT ; RUN: | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s -check-prefix=SCOPS \
; RUN: --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: | FileCheck %s -check-prefix=SCOPS ; RUN: | FileCheck %s -check-prefix=SCOPS
; DETECT: Valid Region for Scop: if.end116 => for.inc216 ; DETECT: Valid Region for Scop: if.end116 => for.inc216
; SCOPS-NOT: Statements ; SCOPS-NOT: Statements
; Verify that we detect this scop, but that, due to an infeasible run-time ; Verify that we detect this scop, but that, due to an infeasible run-time
; check, we refuse to model it. ; check, we refuse to model it.
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/int2ptr_ptr2int.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s --check-prefix=IR
; ;
; void f(long *A, long *ptr, long val) { ; void f(long *A, long *ptr, long val) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; long ptrV = ((long)(ptr + 1)) + 1; ; long ptrV = ((long)(ptr + 1)) + 1;
; long valP = (long)(((long *)(val + 1)) + 1); ; long valP = (long)(((long *)(val + 1)) + 1);
; A[ptrV] += A[valP]; ; A[ptrV] += A[valP];
; } ; }
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/ScopInfo/int2ptr_ptr2int_2.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -analyze -polly-scops \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=IR
; RUN: opt %loadPolly -S -polly-codegen \ ; RUN: opt %loadPolly -S -polly-codegen \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; ;
; void f(long *A, long *B, long *ptr, long val) { ; void f(long *A, long *B, long *ptr, long val) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; long ptrV = ((long)(ptr + 1)) + 1; ; long ptrV = ((long)(ptr + 1)) + 1;
; long valP = (long)(((long *)(val + 1)) + 1); ; long valP = (long)(((long *)(val + 1)) + 1);
; A[ptrV] += B[valP]; ; A[ptrV] += B[valP];
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/integers.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; Check that we correctly convert integers to isl values. ; Check that we correctly convert integers to isl values.
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"
; Large positive integer ; Large positive integer
define void @f(i1024* nocapture %a) nounwind { define void @f(i1024* nocapture %a) nounwind {
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

test/ScopInfo/inter-error-bb-dependence.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=print<polly-function-scops>" >/dev/null \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -analyze < %s 2>&1 > /dev/null | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -analyze < %s 2>&1 >/dev/null | FileCheck %s
; ;
; Error statements (%bb33) do not require their uses to be verified. ; Error statements (%bb33) do not require their uses to be verified.
; In this case it uses %tmp32 from %bb31 which is not available because ; In this case it uses %tmp32 from %bb31 which is not available because
; %bb31 is an error statement as well. ; %bb31 is an error statement as well.
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"
declare noalias i8* @widget() declare noalias i8* @widget()
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopInfo/inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops \ ; RUN: opt %loadPolly -basicaa -polly-scops \
; RUN: -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -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;
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-function-scops>" \
; RUN: < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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] : 0 <= i0 <= 100 }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] : 0 <= i0 <= 100 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/intra_and_inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/intra_bb_scalar_dep.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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) {
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/ScopInfo/intrinsics.ll

; RUN: opt %loadPolly -disable-output -polly-print-instructions \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
; ;
; Verify that we remove the ignored intrinsics from the instruction list. ; Verify that we remove the ignored intrinsics from the instruction list.
; ;
; CHECK: Instructions { ; CHECK: Instructions {
; CHECK-NEXT: store i32 %i.0, i32* %arrayidx, align 4 ; CHECK-NEXT: store i32 %i.0, i32* %arrayidx, align 4
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
Show All 38 Lines

test/ScopInfo/invalid_add_rec_after_invariant_load_remapping.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; ;
; This crased at some point as we place %1 and %4 in the same equivalence class ; This crased at some point as we place %1 and %4 in the same equivalence class
; for invariant loads and when we remap SCEVs to use %4 instead of %1 AddRec SCEVs ; for invariant loads and when we remap SCEVs to use %4 instead of %1 AddRec SCEVs
; for the for.body.10 loop caused a crash as their operands were not invariant ; for the for.body.10 loop caused a crash as their operands were not invariant
; in the loop. While we know they are, ScalarEvolution does not. However, we can simply ; in the loop. While we know they are, ScalarEvolution does not. However, we can simply
; rewrite the AddRecs to hoist everything from the "start" out of the AddRec. ; rewrite the AddRecs to hoist everything from the "start" out of the AddRec.
; ;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_L_4 ; CHECK-NEXT: Stmt_L_4
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] : 0 <= i0 < tmp8 and 0 <= i1 < tmp8 and 0 <= i2 < tmp8 }; ; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] : 0 <= i0 < tmp8 and 0 <= i1 < tmp8 and 0 <= i2 < tmp8 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] -> [i0, i1, i2] }; ; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] -> [i0, i1, i2] };
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: { Stmt_bb2[i0] -> MemRef_B[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] };
; ;
; void f(int *restrict A, int *restrict B) { ; void f(int *restrict A, int *restrict B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
Show All 27 Lines

test/ScopInfo/invariant_load_access_classes_different_base_type.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; struct { ; struct {
; int a; ; int a;
; float b; ; float b;
; } S; ; } S;
; ;
; void f(int *A) { ; void f(int *A) {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_access_classes_different_base_type_escaping.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; struct { ; struct {
; int a; ; int a;
; float b; ; float b;
; } S; ; } S;
; ;
; float f(int *A) { ; float f(int *A) {
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -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);
; } ; }
; ;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer_escaping.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -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);
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_addrec_sum.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s
; ;
; CHECK: Region: %entry.split---%if.end ; CHECK: Region: %entry.split---%if.end
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [y, p_1_loaded_from_j] -> { Stmt_for_body[i0] -> MemRef_j[0] }; ; CHECK: [y, p_1_loaded_from_j] -> { Stmt_for_body[i0] -> MemRef_j[0] };
; CHECK: Execution Context: [y, p_1_loaded_from_j] -> { : } ; CHECK: Execution Context: [y, p_1_loaded_from_j] -> { : }
; CHECK: } ; CHECK: }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_base_pointer.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -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: { Stmt_bb2[i0] -> MemRef_BPLoc[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_BPLoc[0] };
; ;
; void f(int **BPLoc) { ; void f(int **BPLoc) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
Show All 27 Lines

test/ScopInfo/invariant_load_base_pointer_conditional.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -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: [N] -> { Stmt_bb5[i0] -> MemRef_BPLoc[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BPLoc[0] };
; ;
; void f(int **BPLoc, int *A, int N) { ; void f(int **BPLoc, int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_base_pointer_in_conditional.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -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: [N] -> { Stmt_bb5[i0] -> MemRef_BP[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BP[0] };
; CHECK-NEXT: Execution Context: [N] -> { : N >= 514 } ; CHECK-NEXT: Execution Context: [N] -> { : N >= 514 }
; ;
; void f(int *BP, int *A, int N) { ; void f(int *BP, int *A, int N) {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_body1[i0] : 0 <= i0 <= 1022 }; ; CHECK-NEXT: { Stmt_body1[i0] : 0 <= i0 <= 1022 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
Show All 38 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_2.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Make sure we choose a canonical element that is not the first invariant load, ; Make sure we choose a canonical element that is not the first invariant load,
; but the first that is an array base pointer. ; but the first that is an array base pointer.
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_3.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that we canonicalize accesses even tough one of the accesses (even ; Verify that we canonicalize accesses even tough one of the accesses (even
; the canonical base) has a partial execution context. This is correct as ; the canonical base) has a partial execution context. This is correct as
; the combined execution context still coveres both accesses. ; the combined execution context still coveres both accesses.
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that a delinearized and a not delinearized access are not ; Verify that a delinearized and a not delinearized access are not
; canonizalized. ; canonizalized.
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4b.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that two arrays delinearized with different sizes are not coalesced. ; Verify that two arrays delinearized with different sizes are not coalesced.
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4c.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that arrays with different element types are not coalesced. ; Verify that arrays with different element types are not coalesced.
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_body1 ; CHECK-NEXT: Stmt_body1
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_canonicalize_array_baseptrs_5.ll

; RUN: opt %loadPolly -disable-output < %s -polly-invariant-load-hoisting \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that nested arrays with invariant base pointers are handled correctly. ; Verify that nested arrays with invariant base pointers are handled correctly.
; Specifically, we currently do not canonicalize arrays where some accesses are ; Specifically, we currently do not canonicalize arrays where some accesses are
; hoisted as invariant loads. If we would, we need to update the access function ; hoisted as invariant loads. If we would, we need to update the access function
; of the invariant loads as well. However, as this is not a very common ; of the invariant loads as well. However, as this is not a very common
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_complex_condition.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -disable-output \
; RUN: -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: <%s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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"
%struct.IP = type { i32****, i32***, %struct.P, %struct.S, %struct.m } %struct.IP = type { i32****, i32***, %struct.P, %struct.S, %struct.m }
%struct.P = type { i32 } %struct.P = type { i32 }
%struct.S = type { i32 } %struct.S = type { i32 }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_condition.ll

; RUN: opt %loadPolly -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -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: { Stmt_bb2[i0] -> MemRef_C[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_C[0] };
; ;
; 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++)
Show All 35 Lines

test/ScopInfo/invariant_load_dereferenceable.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=function(print<polly-detect>,print<polly-function-scops>)" < %s\
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-scops \ ; RUN: opt %loadPolly -polly-detect -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; CHECK-NOT: Function: foo_undereferanceable ; CHECK-NOT: Function: foo_undereferanceable
; CHECK: Function: foo_dereferanceable ; CHECK: Function: foo_dereferanceable
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_distinct_parameter_valuations.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Check that we do not consolidate the invariant loads to smp[order - 1] and ; Check that we do not consolidate the invariant loads to smp[order - 1] and
; smp[order - 2] in the blocks %0 and %16. While they have the same pointer ; smp[order - 2] in the blocks %0 and %16. While they have the same pointer
; operand (SCEV) they do not have the same access relation due to the ; operand (SCEV) they do not have the same access relation due to the
; instantiation of "order" from their domain. ; instantiation of "order" from their domain.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_in_non_affine.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-detect>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-detect -analyze \ ; RUN: opt %loadPolly -polly-detect -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop ; CHECK-NOT: Valid Region for Scop
; ;
; void foo(float A[], float B[], long *p) { ; void foo(float A[], float B[], long *p) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; for (long j = 0; j < 1024; j++) ; for (long j = 0; j < 1024; j++)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_loop_ub.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -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: { Stmt_bb1[i0] -> MemRef_UB[0] }; ; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_UB[0] };
; ;
; void f(int *A, int *UB) { ; void f(int *A, int *UB) {
; for (int i = 0; i < *UB; i++) ; for (int i = 0; i < *UB; i++)
Show All 28 Lines

test/ScopInfo/invariant_load_ptr_ptr_noalias.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true \
; RUN: -polly-ignore-aliasing -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=type-based-aa < %s \
; RUN: 2>&1 | FileCheck %s
; RUN: opt %loadPolly -tbaa -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing \ ; RUN: opt %loadPolly -tbaa -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; Note: The order of the invariant accesses is important because A is the ; Note: The order of the invariant accesses is important because A is the
; base pointer of tmp3 and we will generate code in the same order as ; base pointer of tmp3 and we will generate code in the same order as
; the invariant accesses are listed here. ; the invariant accesses are listed here.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_scalar_dep.ll

; RUN: opt %loadPolly -polly-process-unprofitable \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -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: { Stmt_bb2[i0] -> MemRef_B[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] };
; CHECK-NOT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NOT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: { Stmt_bb2[i0] -> MemRef_tmp[] }; ; CHECK-NOT: { Stmt_bb2[i0] -> MemRef_tmp[] };
; ;
Show All 34 Lines

test/ScopInfo/invariant_load_stmt_domain.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; This test case verifies that the statement domain of the invariant access ; This test case verifies that the statement domain of the invariant access
; is the universe. In earlier versions of Polly, we accidentally computed an ; is the universe. In earlier versions of Polly, we accidentally computed an
; empty access domain which resulted in invariant accesses not being executed ; empty access domain which resulted in invariant accesses not being executed
; and consequently undef values being used. ; and consequently undef values being used.
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_zext_parameter-2.ll

; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -scalar-evolution-max-value-compare-depth=3 -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s
; ;
; Stress test for the code generation of invariant accesses. ; Stress test for the code generation of invariant accesses.
; ;
; void f(int *I0, int *I1, int *I2, int *V, long p0, long p1, long p2, long p3) { ; void f(int *I0, int *I1, int *I2, int *V, long p0, long p1, long p2, long p3) {
; *V = *I1; ; *V = *I1;
; for (int i = 0; i < 1000; i++) { ; for (int i = 0; i < 1000; i++) {
; long n0 = p0 * *I1 + p1 * *I1; ; long n0 = p0 * *I1 + p1 * *I1;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_zext_parameter.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; void f(int *I0, int *I1, int *V) { ; void f(int *I0, int *I1, int *V) {
; for (int i = 0; i < 1000; i++) { ; for (int i = 0; i < 1000; i++) {
; if ((long)(*I0) == 0) ; if ((long)(*I0) == 0)
; V[i] += *I1; ; V[i] += *I1;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopInfo/invariant_load_zextended_in_own_execution_context.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s
; ;
; CHECK: Execution Context: [p_0_loaded_from_currpc] -> { : } ; CHECK: Execution Context: [p_0_loaded_from_currpc] -> { : }
; ;
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"
@currpc = external global i32, align 4 @currpc = external global i32, align 4
@inbuff = external global i8*, align 8 @inbuff = external global i8*, align 8
Show All 22 Lines

test/ScopInfo/invariant_loads_complicated_dependences.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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] };
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/ScopInfo/invariant_loads_cyclic_dependences.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; Negative test. If we assume UB[*V] to be invariant we get a cyclic ; Negative test. If we assume UB[*V] to be invariant we get a cyclic
; dependence in the invariant loads that needs to be resolved by ; dependence in the invariant loads that needs to be resolved by
; ignoring the actual accessed address and focusing on the fact ; ignoring the actual accessed address and focusing on the fact
; that the access happened. However, at the moment we assume UB[*V] ; that the access happened. However, at the moment we assume UB[*V]
; not to be loop invariant, thus reject this region. ; not to be loop invariant, thus reject this region.
; ;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/ScopInfo/invariant_loop_bounds.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: [bounds2, bounds1, bounds0] -> { Stmt_for_cond[i0] -> 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: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_1[i0, i1] -> MemRef_bounds[1] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_1[i0, i1] -> MemRef_bounds[1] };
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

test/ScopInfo/invariant_same_loop_bound_multiple_times-1.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: {
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

test/ScopInfo/invariant_same_loop_bound_multiple_times-2.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

test/ScopInfo/isl_aff_out_of_bounds.ll

; RUN: opt %loadPolly "-passes=require<polly-detect>" -aa-pipeline=basic-aa < \
; RUN: %s 2>&1
; RUN: opt %loadPolly -basicaa -polly-detect < %s ; RUN: opt %loadPolly -basicaa -polly-detect < %s
; Used to fail with: ; Used to fail with:
; ../../isl/isl_aff.c:591: position out of bounds ; ../../isl/isl_aff.c:591: position out of bounds
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"
declare double @frexp(double) declare double @frexp(double)
Show All 31 Lines

test/ScopInfo/isl_trip_count_01.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: [M, N] -> { Stmt_while_body[i0] : i0 > 0 and 4i0 <= -M + N; Stmt_while_body[0] }; ; CHECK: [M, N] -> { Stmt_while_body[i0] : i0 > 0 and 4i0 <= -M + N; Stmt_while_body[0] };
; ;
; void f(int *A, int N, int M) { ; void f(int *A, int N, int M) {
; int i = 0; ; int i = 0;
; while (M <= N) { ; while (M <= N) {
; A[i++] = 1; ; A[i++] = 1;
Show All 30 Lines

test/ScopInfo/isl_trip_count_02.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; TODO: We do not allow unbounded loops at the moment. ; TODO: We do not allow unbounded loops at the moment.
; ;
; CHECK-NOT: Stmt_for_body ; CHECK-NOT: Stmt_for_body
; ;
; void f(int *A, int N, int M) { ; void f(int *A, int N, int M) {
; for (int i = M; i > N; i++) ; for (int i = M; i > N; i++)
Show All 27 Lines

test/ScopInfo/isl_trip_count_03.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-NEXT: [n] -> { : -2147483648 <= n <= 2147483647 } ; CHECK-NEXT: [n] -> { : -2147483648 <= n <= 2147483647 }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

test/ScopInfo/isl_trip_count_multiple_exiting_blocks.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: { Stmt_if_end[i0] : 0 <= i0 <= 1024 }; ; CHECK: { Stmt_if_end[i0] : 0 <= i0 <= 1024 };
; ;
; void f(int *A) { ; void f(int *A) {
; int i = 0; ; int i = 0;
; do { ; do {
Show All 38 Lines

test/ScopInfo/licm_potential_store.ll

; RUN: opt %loadPolly -basicaa -sroa -instcombine -simplifycfg -tailcallopt \ ; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(sroa,instcombine,simplify-cfg,simplify-cfg,reassociate,loop(rotate),instcombine,loop(indvars),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --check-prefix=NOLICM
; RUN: opt %loadPolly -basicaa -sroa -instcombine -simplifycfg \
; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars \ ; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars \
; RUN: -polly-prepare -polly-scops -analyze < %s \ ; RUN: -polly-prepare -polly-scops -analyze < %s \
; RUN: \ ; RUN: \
; RUN: | FileCheck %s --check-prefix=NOLICM ; RUN: | FileCheck %s --check-prefix=NOLICM
; RUN: opt %loadPolly -basicaa -sroa -instcombine -simplifycfg -tailcallopt \ ; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(sroa,instcombine,simplify-cfg,simplify-cfg,reassociate,loop(rotate),instcombine,require<opt-remark-emit>,loop(indvars,licm),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --check-prefix=LICM
; RUN: opt %loadPolly -basicaa -sroa -instcombine -simplifycfg \
; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars -licm \ ; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars -licm \
; RUN: -polly-prepare -polly-scops -analyze < %s \ ; RUN: -polly-prepare -polly-scops -analyze < %s \
; RUN: \ ; RUN: \
; RUN: | FileCheck %s --check-prefix=LICM ; RUN: | FileCheck %s --check-prefix=LICM
; void foo(int n, float A[static const restrict n], float x) { ; void foo(int n, float A[static const restrict n], float x) {
; // (0) ; // (0)
; for (int i = 0; i < 5; i += 1) { ; for (int i = 0; i < 5; i += 1) {
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/ScopInfo/licm_reduction.ll

; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars,licm),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; ;
; XFAIL: * ; XFAIL: *
; ;
; void test(int n, double B[static const restrict n], int j) { ; void test(int n, double B[static const restrict n], int j) {
; for (int i = 0; i < n; i += 1) { ; for (int i = 0; i < n; i += 1) {
; B[j] += i; ; B[j] += i;
; } ; }
Show All 38 Lines

test/ScopInfo/licm_reduction_nested.ll

; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars,licm),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; ;
; XFAIL: * ; XFAIL: *
; ;
; Even ScopDetection fails here after LICM because of PHI in exit node. ; Even ScopDetection fails here after LICM because of PHI in exit node.
; ;
; void foo(unsigned long *restrict A, unsigned long *restrict B, ; void foo(unsigned long *restrict A, unsigned long *restrict B,
; unsigned long j) { ; unsigned long j) {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/licm_store.ll

; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output \
; RUN: "-passes=function(loop(rotate,indvars,licm),polly-prepare,print<polly-function-scops>)"\
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; ;
; XFAIL: * ; XFAIL: *
; ;
; void foo(float *restrict A, float *restrict B, long j) { ; void foo(float *restrict A, float *restrict B, long j) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[j] = B[i]; ; A[j] = B[i];
; } ; }
Show All 36 Lines

test/ScopInfo/long-compile-time-alias-analysis.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %s
; Verify that the compilation of this test case does not take infinite time. ; Verify that the compilation of this test case does not take infinite time.
; At some point Polly tried to model this test case and got stuck in ; At some point Polly tried to model this test case and got stuck in
; computing a lexicographic minima. Today it should gracefully bail out. ; computing a lexicographic minima. Today it should gracefully bail out.
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-android" target triple = "aarch64--linux-android"
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

test/ScopInfo/long-sequence-of-error-blocks-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; 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 execution context of invalid loads in this test case has at some point become very complex and we should bail. ; The execution context of invalid loads in this test case has at some point become very complex and we should bail.
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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 }
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

test/ScopInfo/loop-multiexit-succ-cond.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s --check-prefix=IR
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; ;
; Check that we do not crash and generate valid IR. ; Check that we do not crash and generate valid IR.
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [count1, dobreak, count2] -> { : } ; CHECK-NEXT: [count1, dobreak, count2] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [count1, dobreak, count2] -> { : (count1 > 0 and dobreak > 0) or count1 <= 0 or (count1 > 0 and dobreak <= 0 and count2 > 0) } ; CHECK-NEXT: [count1, dobreak, count2] -> { : (count1 > 0 and dobreak > 0) or count1 <= 0 or (count1 > 0 and dobreak <= 0 and count2 > 0) }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/ScopInfo/loop_affine_bound_0.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; void f(long a[][128], long N, long M) { ; void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = 0; i < (5*N + 2); ++i) ; for (i = 0; i < (5*N + 2); ++i)
; a[j][i] = 0 ; a[j][i] = 0
; } ; }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/ScopInfo/loop_affine_bound_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
;void f(long a[][128], long N, long M) { ;void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = j; i < (5*N + 2); ++i) ; for (i = j; i < (5*N + 2); ++i)
; ... ; ...
;} ;}
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopInfo/loop_affine_bound_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; void f(long a[][128], long N, long M) { ; void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i) ; for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i)
; a[i][j] = 0; ; a[i][j] = 0;
; } ; }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

test/ScopInfo/loop_carry.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze < %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" 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"
;long f(long a[], long n) { ;long f(long a[], long n) {
; long i, k; ; long i, k;
; k = 1; ; k = 1;
; for (i = 1; i < n; ++i) { ; for (i = 1; i < n; ++i) {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/ScopInfo/many-scalar-dependences.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(float a[100][100]) { ; void f(float a[100][100]) {
; float x; ; float x;
; ;
; 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++) {
; for (int k = 0; k < 100; k++) { ; for (int k = 0; k < 100; k++) {
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

test/ScopInfo/max-loop-depth.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void bar(); ; void bar();
; void foo(int *A, int *B, long int N, long int M) { ; void foo(int *A, int *B, long int N, long int M) {
; for (long int j = 0; j < M; ++j) { ; for (long int j = 0; j < M; ++j) {
; bar(); ; bar();
; for (long int i = 0; i < N; ++i) ; for (long int i = 0; i < N; ++i)
; A[i] += 1; ; A[i] += 1;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/ScopInfo/memcpy-raw-source.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: "-aa-pipeline=basic-aa,scoped-noalias-aa,type-based-aa" < %s 2>&1
; RUN: opt %loadPolly -basicaa -scoped-noalias -tbaa -polly-scops -analyze < %s ; RUN: opt %loadPolly -basicaa -scoped-noalias -tbaa -polly-scops -analyze < %s
; ;
; Ensure that ScopInfo's alias analysis llvm.memcpy for, ; Ensure that ScopInfo's alias analysis llvm.memcpy for,
; like the AliasSetTracker, preserves bitcasts. ; like the AliasSetTracker, preserves bitcasts.
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"
@tonemasks = external global [17 x [6 x [56 x float]]], align 16 @tonemasks = external global [17 x [6 x [56 x float]]], align 16
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/ScopInfo/memcpy.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-allow-differing-element-types \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: --check-prefix=IR %s
; RUN: opt %loadPolly -S -basicaa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s ; RUN: opt %loadPolly -S -basicaa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1
; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body3 ; CHECK-NEXT: Stmt_for_body3
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/ScopInfo/memmove.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-allow-differing-element-types \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1 | FileCheck \
; RUN: --check-prefix=IR %s
; RUN: opt %loadPolly -S -basicaa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s ; RUN: opt %loadPolly -S -basicaa -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1
; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_B[*]; // Element size 1
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body3 ; CHECK-NEXT: Stmt_for_body3
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/ScopInfo/memset.ll

; RUN: opt %loadPolly -polly-allow-differing-element-types -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-allow-differing-element-types \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck \
; RUN: --check-prefix=IR %s
; RUN: opt %loadPolly -S -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s ; RUN: opt %loadPolly -S -polly-allow-differing-element-types -polly-codegen < %s | FileCheck --check-prefix=IR %s
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1 ; CHECK-NEXT: i8 MemRef_A[*]; // Element size 1
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body3 ; CHECK-NEXT: Stmt_for_body3
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/memset_null.ll

; RUN: opt %loadPolly -polly-allow-modref-calls -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-modref-calls -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-modref-calls -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-modref-calls -S -passes=polly-codegen < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-allow-modref-calls -S -polly-codegen < %s ; RUN: opt %loadPolly -polly-allow-modref-calls -S -polly-codegen < %s
; ;
; Verify we can handle a memset to "null" and that we do not model it. ; Verify we can handle a memset to "null" and that we do not model it.
; TODO: FIXME: We could use the undefined memset to optimize the code further, ; TODO: FIXME: We could use the undefined memset to optimize the code further,
; see the TODOs in the ScopInfo.cpp. ; see the TODOs in the ScopInfo.cpp.
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_cond5_preheader_us221 ; CHECK-NEXT: Stmt_for_cond5_preheader_us221
Show All 28 Lines

test/ScopInfo/mismatching-array-dimensions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; CHECK-NOT: AssumedContext ; CHECK-NOT: AssumedContext
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/mod_ref_access_pointee_arguments.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-modref-calls "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-modref-calls \
; RUN: -disable-output -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1
;
; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-codegen -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-codegen -polly-allow-modref-calls \
; RUN: -disable-output < %s ; RUN: -disable-output < %s
; ;
; Verify that we model the may-write access of the prefetch intrinsic ; Verify that we model the may-write access of the prefetch intrinsic
; correctly, thus that A is accessed by it but B is not. ; correctly, thus that A is accessed by it but B is not.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/ScopInfo/mod_ref_read_pointee_arguments.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-modref-calls "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
;
; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1
;
; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \ ; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \
; RUN: -polly-allow-modref-calls < %s ; RUN: -polly-allow-modref-calls < %s
; ;
; Verify that we model the read access of the gcread intrinsic ; Verify that we model the read access of the gcread intrinsic
; correctly, thus that A is read by it but B is not. ; correctly, thus that A is read by it but B is not.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/mod_ref_read_pointer.ll

; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-modref-calls \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1
; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \ ; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \
; RUN: -polly-allow-modref-calls < %s ; RUN: -polly-allow-modref-calls < %s
; ;
; Check that we assume the call to func has a read on the whole A array. ; Check that we assume the call to func has a read on the whole A array.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/mod_ref_read_pointers.ll

; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-modref-calls \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -polly-allow-modref-calls \
; RUN: -passes=polly-codegen -aa-pipeline=basic-aa < %s 2>&1
; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \ ; RUN: opt %loadPolly -basicaa -polly-codegen -disable-output \
; RUN: -polly-allow-modref-calls < %s ; RUN: -polly-allow-modref-calls < %s
; ;
; Check that the call to func will "read" not only the A array but also the ; Check that the call to func will "read" not only the A array but also the
; B array. The reason is the readonly annotation of func. ; B array. The reason is the readonly annotation of func.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/ScopInfo/modulo_zext_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : false } ; CHECK-NEXT: [N] -> { : false }
; CHECK-NEXT: p0: %N ; CHECK-NEXT: p0: %N
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/modulo_zext_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : false } ; CHECK-NEXT: [N] -> { : false }
; CHECK-NEXT: p0: %N ; CHECK-NEXT: p0: %N
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/ScopInfo/modulo_zext_3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 4294967297 } ; CHECK-NEXT: [N] -> { : N >= 4294967297 }
; CHECK-NEXT: p0: %N ; CHECK-NEXT: p0: %N
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/multi-scop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -analyze < %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"
; This test case contains two scops. ; This test case contains two scops.
define void @test(i32 %l, double* %a) { define void @test(i32 %l, double* %a) {
entry: entry:
br label %entry.split br label %entry.split
Show All 28 Lines

test/ScopInfo/multidim_2d-diagonal-matrix.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %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, double A[n][n]) { ; void foo(long n, double A[n][n]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[i][i] = 1.0; ; A[i][i] = 1.0;
Show All 32 Lines

test/ScopInfo/multidim_2d_outer_parametric_offset.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/multidim_2d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/ScopInfo/multidim_2d_with_modref_call.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-modref-calls -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine \
; RUN: -disable-output -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-modref-calls "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --check-prefix=NONAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-allow-nonaffine -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-allow-nonaffine -analyze \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-modref-calls < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: -polly-allow-modref-calls < %s | FileCheck %s --check-prefix=NONAFFINE
; TODO: We should delinearize the accesses despite the use in a call to a ; TODO: We should delinearize the accesses despite the use in a call to a
; readonly function. For now we verify we do not delinearize them though. ; readonly function. For now we verify we do not delinearize them though.
; CHECK: Function: ham ; CHECK: Function: ham
; CHECK-NEXT: Region: %bb12---%bb28 ; CHECK-NEXT: Region: %bb12---%bb28
; CHECK-NEXT: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK-NEXT: Invariant Accesses: { ; CHECK-NEXT: Invariant Accesses: {
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

test/ScopInfo/multidim_2d_with_modref_call_2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-modref-calls -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true -polly-allow-modref-calls \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --check-prefix=NONAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-modref-calls -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: -polly-allow-modref-calls -analyze < %s | FileCheck %s --check-prefix=NONAFFINE
; TODO: We should delinearize the accesses despite the use in a call to a ; TODO: We should delinearize the accesses despite the use in a call to a
; readonly function. For now we verify we do not delinearize them though. ; readonly function. For now we verify we do not delinearize them though.
; CHECK: Function: ham ; CHECK: Function: ham
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

test/ScopInfo/multidim_3d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fixedsize_different_dimensionality.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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;
▲ Show 20 Lines • Show All 251 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fixedsize_multi_offset.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fold_constant_dim.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-function-scops>" \
; RUN: < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s
; ;
; struct com { ; struct com {
; double Real; ; double Real;
; double Img; ; double Img;
; }; ; };
; ;
; void foo(long n, struct com A[][n]) { ; void foo(long n, struct com A[][n]) {
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fold_constant_dim_zero.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output -debug -S \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -debug -S < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -debug -S < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; This test case at some point crashed Polly due to a 'division by zero' ; This test case at some point crashed Polly due to a 'division by zero'
; when trying to fold the constant dimension into outer dimension. ; when trying to fold the constant dimension into outer dimension.
; We verify that this scop is detected without crash. We also test the ; We verify that this scop is detected without crash. We also test the
; output to undertand that the scop has been analyzed, but has also been ; output to undertand that the scop has been analyzed, but has also been
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fortran_2d.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; subroutine init_array(ni, nj, pi, pj, a) ; subroutine init_array(ni, nj, pi, pj, a)
; implicit none ; implicit none
; ;
; double precision, dimension(nj, ni) :: a ; double precision, dimension(nj, ni) :: a
; integer*8 :: ni, nj ; integer*8 :: ni, nj
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fortran_2d_params.ll

; RUN: opt %loadPolly -disable-output -polly-precise-fold-accesses \
; RUN: -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-precise-fold-accesses \ ; RUN: -polly-precise-fold-accesses \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; subroutine init_array(ni, nj, pi, pj, a) ; subroutine init_array(ni, nj, pi, pj, a)
; implicit none ; implicit none
; double precision, dimension(nj, ni) :: a ; double precision, dimension(nj, ni) :: a
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fortran_2d_with_modref_call.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-allow-modref-calls -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-allow-modref-calls -polly-invariant-load-hoisting=true \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-allow-nonaffine -analyze \ ;
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine \
; RUN: -disable-output -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-modref-calls "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --check-prefix=NONAFFINE
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops \
; RUN: -polly-allow-nonaffine -analyze -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-modref-calls < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: -polly-allow-modref-calls < %s | FileCheck %s --check-prefix=NONAFFINE
; TODO: We should delinearize the accesses despite the use in a call to a ; TODO: We should delinearize the accesses despite the use in a call to a
; readonly function. For now we verify we do not delinearize them though. ; readonly function. For now we verify we do not delinearize them though.
; CHECK: Function: ham ; CHECK: Function: ham
; CHECK-NEXT: Region: %bb12---%bb28 ; CHECK-NEXT: Region: %bb12---%bb28
; CHECK-NEXT: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK-NEXT: Invariant Accesses: { ; CHECK-NEXT: Invariant Accesses: {
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

test/ScopInfo/multidim_fortran_srem.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_bb188 ; CHECK-NEXT: Stmt_bb188
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] : 0 <= i0 <= -3 + tmp183 }; ; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] : 0 <= i0 <= -3 + tmp183 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

test/ScopInfo/multidim_gep_pointercast.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; The load access to A has a pointer-bitcast to another elements size before the ; The load access to A has a pointer-bitcast to another elements size before the
; GetElementPtr. Verify that we do not the GEP delinearization because it ; GetElementPtr. Verify that we do not the GEP delinearization because it
; mismatches with the size of the loaded element type. ; mismatches with the size of the loaded element type.
; ;
; void f(short A[][4], int N, int P) { ; void f(short A[][4], int N, int P) {
; short(*B)[4] = &A[P][0]; ; short(*B)[4] = &A[P][0];
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/ScopInfo/multidim_gep_pointercast2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verfy that we do not use the GetElementPtr information to delinearize A ; Verfy that we do not use the GetElementPtr information to delinearize A
; because of the cast in-between. Use the single-dimensional modeling instead. ; because of the cast in-between. Use the single-dimensional modeling instead.
; ;
; void f(short A[][2]) { ; void f(short A[][2]) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; *((long *)&A[4 * i][0]) = 0; ; *((long *)&A[4 * i][0]) = 0;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/multidim_ivs_and_integer_offsets_3d.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/ScopInfo/multidim_ivs_and_parameteric_offsets_3d.ll

; RUN: opt %loadPolly -disable-output < %s -polly-precise-fold-accesses \
; RUN: "-passes=print<polly-function-scops>" 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-scops -analyze < %s \
; RUN: -polly-precise-fold-accesses | FileCheck %s ; RUN: -polly-precise-fold-accesses | 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++)
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/multidim_many_references.ll

; RUN: opt %loadPolly -disable-output -polly-ignore-aliasing \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -polly-ignore-aliasing < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-ignore-aliasing < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -polly-ignore-aliasing \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze -polly-ignore-aliasing < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze -polly-ignore-aliasing < %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"
; typedef struct Mat { ; typedef struct Mat {
; float* data; ; float* data;
; long rows; ; long rows;
; long cols; ; long cols;
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines

test/ScopInfo/multidim_nested_start_integer.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %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;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

test/ScopInfo/multidim_nested_start_share_parameter.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %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-13; i++) ; for (long i = 0; i < n-13; i++)
; for (long j = 14; j < m; j++) ; for (long j = 14; j < m; j++)
; for (long k = 0; k < o-17; k++) { ; for (long k = 0; k < o-17; k++) {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/multidim_only_ivs_2d.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/multidim_only_ivs_3d.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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++)
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/ScopInfo/multidim_only_ivs_3d_cast.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %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;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/multidim_only_ivs_3d_reverse.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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.
; ;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/ScopInfo/multidim_param_in_subscript-2.ll

; RUN: opt %loadPolly -disable-output -polly-precise-fold-accesses \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-precise-fold-accesses < %s | FileCheck %s ; RUN: -polly-precise-fold-accesses < %s | FileCheck %s
; ;
; void foo(long n, long m, float A[][n][m]) { ; void foo(long n, long m, float A[][n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < n; j++) ; for (long j = 0; j < n; j++)
; for (long k = 0; k < m; k++) ; for (long k = 0; k < m; k++)
; A[i][j][k] += A[i][n - j - 1][m - k - 1]; ; A[i][j][k] += A[i][n - j - 1][m - k - 1];
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/multidim_param_in_subscript.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; ;
; void foo(long n, float A[][n]) { ; void foo(long n, float A[][n]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < n; j++) ; for (long j = 0; j < n; j++)
; A[i][j] += A[i][n - j - 1]; ; A[i][j] += A[i][n - j - 1];
; } ; }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/ScopInfo/multidim_parameter_addrec_product.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void foo(float *A, long *p) { ; void foo(float *A, long *p) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; A[i * (*p) + j] += i + j; ; A[i * (*p) + j] += i + j;
; } ; }
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

test/ScopInfo/multidim_single_and_multidim_array.ll

; RUN: opt %loadPolly -polly-delinearize=false -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-delinearize=false -polly-allow-nonaffine \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-delinearize=false -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-delinearize=false -polly-allow-nonaffine \
; RUN: -disable-output "-passes=print<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-function-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-function-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN
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"
; void single-and-multi-dimensional-array(long n,float X[n][n]) { ; void single-and-multi-dimensional-array(long n,float X[n][n]) {
; for (long i1 = 0; i1 < n; i1++) ; for (long i1 = 0; i1 < n; i1++)
; X[i1][0] = 1; ; X[i1][0] = 1;
; ;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

test/ScopInfo/multidim_srem.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-function-scops>" \
; RUN: < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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;
; } ; }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

test/ScopInfo/multidim_with_bitcast.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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"
; Verify that we can look through a bitcast when delinearizing multi-dimensional ; Verify that we can look through a bitcast when delinearizing multi-dimensional
; arrays. ; arrays.
; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] ; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/ScopInfo/multiple-binary-or-conditions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output -passes=polly-codegen < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; 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 || i > p) ; if (i < n || i < m || i > p)
; A[i] += i; ; A[i] += i;
; } ; }
; } ; }
Show All 38 Lines

test/ScopInfo/multiple-types-access-offset-not-dividable-by-element-size.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -pass-remarks-analysis=polly-scops \
; RUN: -polly-allow-differing-element-types -disable-output \
; RUN: "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops \
; RUN: -pass-remarks-analysis="polly-scops" \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -analyze < %s 2>&1 | FileCheck %s ; RUN: -analyze < %s 2>&1 | FileCheck %s
; ;
; // For the following accesses the offset expression from the base pointer ; // For the following accesses the offset expression from the base pointer
; // is not always a multiple of the type size. ; // is not always a multiple of the type size.
; void multiple_types(char *Short, char *Float, char *Double) { ; void multiple_types(char *Short, char *Float, char *Double) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; Short[i] = *(short *)&Short[i]; ; Short[i] = *(short *)&Short[i];
; Float[i] = *(float *)&Float[i]; ; Float[i] = *(float *)&Float[i];
; Double[i] = *(double *)&Double[i]; ; Double[i] = *(double *)&Double[i];
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-non-affine-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-codegen -polly-allow-nonaffine -analyze ; RUN: -polly-allow-differing-element-types -polly-allow-nonaffine \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-scops \
; RUN: -polly-allow-nonaffine -analyze < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-allow-nonaffine \
; RUN: -disable-output -passes=polly-codegen -aa-pipeline=basic-aa 2>&1
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-codegen \
; RUN: -polly-allow-nonaffine -analyze
; ;
; // Check that accessing one array with different types works, ; // Check that accessing one array with different types works,
; // even though some accesses are non-affine. ; // even though some accesses are non-affine.
; void multiple_types(char *Short, short *Char, char *Double) { ; void multiple_types(char *Short, short *Char, char *Double) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; Short[i] = *(short *)&Short[i & 8]; ; Short[i] = *(short *)&Short[i & 8];
; Char[i] = *(float *)&Char[i & 8]; ; Char[i] = *(float *)&Char[i & 8];
; Double[i] = *(double *)&Double[i & 8]; ; Double[i] = *(double *)&Double[i & 8];
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-non-affine.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-codegen -polly-allow-nonaffine -analyze ; RUN: -polly-allow-differing-element-types -polly-allow-nonaffine \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-scops \
; RUN: -polly-allow-nonaffine -analyze < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-allow-nonaffine \
; RUN: -disable-output -passes=polly-codegen -aa-pipeline=basic-aa 2>&1
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-allow-differing-element-types -polly-codegen \
; RUN: -polly-allow-nonaffine -analyze
; ;
; // Check that accessing one array with different types works, ; // Check that accessing one array with different types works,
; // even though some accesses are non-affine. ; // even though some accesses are non-affine.
; void multiple_types(char *Short, short *Float, char *Double) { ; void multiple_types(char *Short, short *Float, char *Double) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; Short[i] = *(short *)&Short[i & 8]; ; Short[i] = *(short *)&Short[i & 8];
; Float[i] = *(float *)&Float[i & 8]; ; Float[i] = *(float *)&Float[i & 8];
; Double[i] = *(double *)&Double[i & 8]; ; Double[i] = *(double *)&Double[i & 8];
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-non-power-of-two-2.ll

; RUN: opt %loadPolly -disable-output -polly-allow-differing-element-types \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-allow-differing-element-types < %s | FileCheck %s ; RUN: -polly-allow-differing-element-types < %s | FileCheck %s
; ;
; void multiple_types(i8 *A) { ; void multiple_types(i8 *A) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; A[i] = *(i128 *)&A[16 * i] + ; A[i] = *(i128 *)&A[16 * i] +
; *(i192 *)&A[24 * i]; ; *(i192 *)&A[24 * i];
; } ; }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-non-power-of-two.ll

; RUN: opt %loadPolly -disable-output -polly-allow-differing-element-types \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-allow-differing-element-types < %s | FileCheck %s ; RUN: -polly-allow-differing-element-types < %s | FileCheck %s
; ;
; void multiple_types(i8 *A) { ; void multiple_types(i8 *A) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; A[i] = *(i1 *)&A[1 * i] + ; A[i] = *(i1 *)&A[1 * i] +
; *(i16 *)&A[2 * i] + ; *(i16 *)&A[2 * i] +
; *(i24 *)&A[4 * i] + ; *(i24 *)&A[4 * i] +
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-two-dimensional-2.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-allow-differing-element-types -disable-output < %s 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -analyze < %s 2>&1 | FileCheck %s ; RUN: -analyze < %s 2>&1 | FileCheck %s
; ;
; ;
; void foo(long n, long m, char A[][m]) { ; void foo(long n, long m, char A[][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m / 4; j++) ; for (long j = 0; j < m / 4; j++)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types-two-dimensional.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-allow-differing-element-types -disable-output < %s 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -analyze < %s 2>&1 | FileCheck %s ; RUN: -analyze < %s 2>&1 | FileCheck %s
; ;
; void foo(long n, long m, char A[][m]) { ; void foo(long n, long m, char A[][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m / 4; j++) ; for (long j = 0; j < m / 4; j++)
; A[i][j] = *(float *)&A[i][4 * j]; ; A[i][j] = *(float *)&A[i][4 * j];
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/ScopInfo/multiple-types.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-allow-differing-element-types \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \
; RUN: -polly-allow-differing-element-types < %s | FileCheck %s ; RUN: -polly-allow-differing-element-types < %s | FileCheck %s
; ;
; // Check that accessing one array with different types works. ; // Check that accessing one array with different types works.
; void multiple_types(char *Short, char *Float, char *Double) { ; void multiple_types(char *Short, char *Float, char *Double) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; Short[i] = *(short *)&Short[2 * i]; ; Short[i] = *(short *)&Short[2 * i];
; Float[i] = *(float *)&Float[4 * i]; ; Float[i] = *(float *)&Float[4 * i];
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

test/ScopInfo/multiple_exiting_blocks.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: [N, P, Q] -> { Stmt_if_end[i0] : 0 <= i0 <= 1 + Q and i0 < N and (i0 < P or (P < 0 and i0 >= 2 + P)); Stmt_if_end[0] : N > 0 and ((P <= -2 and Q <= -2) or (P > 0 and Q <= -2) or P = -1) }; ; CHECK: [N, P, Q] -> { Stmt_if_end[i0] : 0 <= i0 <= 1 + Q and i0 < N and (i0 < P or (P < 0 and i0 >= 2 + P)); Stmt_if_end[0] : N > 0 and ((P <= -2 and Q <= -2) or (P > 0 and Q <= -2) or P = -1) };
; ;
; void f(int *A, int N, int P, int Q) { ; void f(int *A, int N, int P, int Q) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i == P) ; if (i == P)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/multiple_exiting_blocks_two_loop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void foo(long n, float A[100]) { ; void foo(long n, float A[100]) {
; for (long j = 0; j < n; j++) { ; for (long j = 0; j < n; j++) {
; for (long i = j; i < n; i++) { ; for (long i = j; i < n; i++) {
; if (i < 0) ; if (i < 0)
; goto end; ; goto end;
; ;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/ScopInfo/multiple_latch_blocks.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: [N, P] -> { Stmt_if_end[i0] : 0 <= i0 < N and (i0 > P or i0 < P) }; ; CHECK: [N, P] -> { Stmt_if_end[i0] : 0 <= i0 < N and (i0 > P or i0 < P) };
; ;
; void f(int *A, int N, int P, int Q) { ; void f(int *A, int N, int P, int Q) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i == P) ; if (i == P)
Show All 39 Lines

test/ScopInfo/nested-loops.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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) nounwind { define void @f(i64* nocapture %a) nounwind {
entry: entry:
br label %for.i br label %for.i
Show All 31 Lines

test/ScopInfo/no-scalar-deps-in-non-affine-subregion.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-scops \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; Check that we do not generate any scalar dependences regarding x. It is ; Check that we do not generate any scalar dependences regarding x. It is
; defined and used on the non-affine subregion only, thus we do not need ; defined and used on the non-affine subregion only, thus we do not need
; to represent the definition and uses in the model. ; to represent the definition and uses in the model.
; ;
; CHECK: Stmt_bb2__TO__bb11 ; CHECK: Stmt_bb2__TO__bb11
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

test/ScopInfo/non-affine-region-phi.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -S < %s | FileCheck %s --check-prefix=CODE ; RUN: opt %loadPolly -polly-allow-nonaffine -S < %s | FileCheck %s --check-prefix=CODE
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify there is a phi in the non-affine region but it is not represented in ; Verify there is a phi in the non-affine region but it is not represented in
; the SCoP as all operands as well as the uses are inside the region too. ; the SCoP as all operands as well as the uses are inside the region too.
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (A[i]) { ; if (A[i]) {
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/ScopInfo/non-affine-region-with-loop-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops \
; RUN: -disable-output -passes=polly-codegen -aa-pipeline=basic-aa 2>&1
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops -polly-codegen -analyze ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-nonaffine-loops -polly-codegen -analyze
; ;
; CHECK: Stmt_loop3 ; CHECK: Stmt_loop3
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: [indvar] -> { Stmt_loop3[0] : indvar >= 101 or indvar <= 99 }; ; CHECK: [indvar] -> { Stmt_loop3[0] : indvar >= 101 or indvar <= 99 };
; CHECK: Schedule := ; CHECK: Schedule :=
; CHECK: [indvar] -> { Stmt_loop3[i0] -> [0, 0] : indvar >= 101 or indvar <= 99 }; ; CHECK: [indvar] -> { Stmt_loop3[i0] -> [0, 0] : indvar >= 101 or indvar <= 99 };
; CHECK: Stmt_loop2__TO__loop ; CHECK: Stmt_loop2__TO__loop
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/non-affine-region-with-loop.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: -passes=polly-codegen 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-codegen -analyze ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-codegen -analyze
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: { Stmt_loop2__TO__loop[] }; ; CHECK-NEXT: { Stmt_loop2__TO__loop[] };
; ;
define void @foo(i64* %A, i64 %p) { define void @foo(i64* %A, i64 %p) {
entry: entry:
br label %loop br label %loop
Show All 32 Lines

test/ScopInfo/non-precise-inv-load-1.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Verify we do hoist the invariant access to I with a execution context ; Verify we do hoist the invariant access to I with a execution context
; as the address computation might wrap in the original but not in our ; as the address computation might wrap in the original but not in our
; optimized version. For an input of c = 127 the original accessed address ; optimized version. For an input of c = 127 the original accessed address
; would be &I[-1] = &GI[128 -1] = &GI[127] but in our optimized version ; would be &I[-1] = &GI[128 -1] = &GI[127] but in our optimized version
; (due to the usage of i64 types) we would access ; (due to the usage of i64 types) we would access
; &I[127 + 1] = &I[128] = &GI[256] which would here also be out-of-bounds. ; &I[127 + 1] = &I[128] = &GI[256] which would here also be out-of-bounds.
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/non-precise-inv-load-2.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: [c] -> { Stmt_for_body[i0] -> MemRef_I[-1 + c] }; ; CHECK-NEXT: [c] -> { Stmt_for_body[i0] -> MemRef_I[-1 + c] };
; CHECK-NEXT: Execution Context: [c] -> { : c > 0 } ; CHECK-NEXT: Execution Context: [c] -> { : c > 0 }
; CHECK-NEXT: } ; CHECK-NEXT: }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/ScopInfo/non-precise-inv-load-3.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -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: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] }; ; CHECK-NEXT: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] };
; CHECK-NEXT: Execution Context: [c] -> { : 0 <= c <= 126 } ; CHECK-NEXT: Execution Context: [c] -> { : 0 <= c <= 126 }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
Show All 40 Lines

test/ScopInfo/non-precise-inv-load-4.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Verify we hoist I[0] without execution context even though it ; Verify we hoist I[0] without execution context even though it
; is executed in a statement with an invalid domain. ; is executed in a statement with an invalid domain.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] }; ; CHECK-NEXT: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] };
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/non-precise-inv-load-5.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Verify we do not hoist I[c] without execution context because it ; Verify we do not hoist I[c] without execution context because it
; is executed in a statement with an invalid domain and it depends ; is executed in a statement with an invalid domain and it depends
; on a parameter that was specialized by the domain. ; on a parameter that was specialized by the domain.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopInfo/non-precise-inv-load-6.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Check that we model the execution context correctly. ; Check that we model the execution context correctly.
; ;
; void f(unsigned *I, unsigned *A, int c) { ; void f(unsigned *I, unsigned *A, int c) {
; for (unsigned i = c; i < 10; i++) ; for (unsigned i = c; i < 10; i++)
; A[i] += *I; ; A[i] += *I;
; } ; }
Show All 33 Lines

test/ScopInfo/non-pure-function-call.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 102 } ; CHECK-NEXT: [N] -> { : N >= 102 }
; ;
; void g(void); ; void g(void);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/non-pure-function-calls-causes-dead-blocks.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Error blocks are skipped during SCoP detection. We skip them during ; Error blocks are skipped during SCoP detection. We skip them during
; SCoP formation too as they might contain instructions we can not handle. ; SCoP formation too as they might contain instructions we can not handle.
; However statements / basic blocks that follow error blocks are modeled. ; However statements / basic blocks that follow error blocks are modeled.
; ;
; void timer_start(void); ; void timer_start(void);
; void timer_stop(void); ; void timer_stop(void);
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

test/ScopInfo/non-pure-function-calls.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Allow the user to define function names that are treated as ; Allow the user to define function names that are treated as
; error functions and assumed not to be executed. ; error functions and assumed not to be executed.
; ;
; void timer_start(void); ; void timer_start(void);
; void timer_stop(void); ; void timer_stop(void);
; void kernel(int *A, int *B, int timeit, int N) { ; void kernel(int *A, int *B, int timeit, int N) {
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

test/ScopInfo/non_affine_access.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
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 *A) { ; void foo(long *A) {
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i * i] = i; ; A[i * i] = i;
; ;
Show All 22 Lines

test/ScopInfo/non_affine_region_1.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify only the incoming scalar x is modeled as a read in the non-affine ; Verify only the incoming scalar x is modeled as a read in the non-affine
; region. ; region.
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; int x; ; int x;
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

test/ScopInfo/non_affine_region_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify the scalar x defined in a non-affine subregion is written as it ; Verify the scalar x defined in a non-affine subregion is written as it
; escapes the region. In this test the two conditionals inside the region ; escapes the region. In this test the two conditionals inside the region
; are expressed as two PHI nodes with two incoming values each. ; are expressed as two PHI nodes with two incoming values each.
; ;
; 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++) {
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/ScopInfo/non_affine_region_3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; ;
; Verify the scalar x defined in a non-affine subregion is written as it ; Verify the scalar x defined in a non-affine subregion is written as it
; escapes the region. In this test the two conditionals inside the region ; escapes the region. In this test the two conditionals inside the region
; are expressed as one PHI nodes with three incoming values. ; are expressed as one PHI nodes with three incoming values.
; ;
; 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++) {
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

test/ScopInfo/non_affine_region_4.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

test/ScopInfo/nonaffine-buildMemoryAccess.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: { Stmt_while_cond_i__TO__while_end_i[] }; ; CHECK-NEXT: { Stmt_while_cond_i__TO__while_end_i[] };
; ;
define i32 @func(i32 %param0, i32 %param1, i64* %param2) #3 { define i32 @func(i32 %param0, i32 %param1, i64* %param2) #3 {
entry: entry:
Show All 37 Lines

test/ScopInfo/not-a-reduction.ll

; RUN: opt %loadPolly -disable-output < %s 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | not \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s 2>&1 | not FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s 2>&1 | not FileCheck %s
;#define TYPE float ;#define TYPE float
;#define NUM 4 ;#define NUM 4
; ;
;TYPE A[NUM]; ;TYPE A[NUM];
;TYPE B[NUM]; ;TYPE B[NUM];
;TYPE C[NUM]; ;TYPE C[NUM];
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

test/ScopInfo/opaque-struct.ll

; RUN: opt %loadPolly -disable-output "-passes=require<polly-function-scops>" <\
; RUN: %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops -disable-output < %s ; RUN: opt %loadPolly -polly-scops -disable-output < %s
; ;
; Check that we do not crash with unsized (opaque) types. ; Check that we do not crash with unsized (opaque) types.
; ;
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"
%struct.s3 = type opaque %struct.s3 = type opaque
%struct.stmt = type opaque %struct.stmt = type opaque
Show All 17 Lines

test/ScopInfo/out-of-scop-use-in-region-entry-phi-node-nonaffine-subregion.ll

; RUN: opt %loadPolly -S -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa \
; RUN: | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
; ;
; Check whether %newval is identified as escaping value, even though it is used ; Check whether %newval is identified as escaping value, even though it is used
; in a phi that is in the region. Non-affine subregion case. ; in a phi that is in the region. Non-affine subregion case.
; ;
; CHECK-LABEL: subregion_entry.region_entering: ; CHECK-LABEL: subregion_entry.region_entering:
; CHECK: %loop_carried.ph = phi float [ %newval.merge, %backedge ], [ undef, %entry ] ; CHECK: %loop_carried.ph = phi float [ %newval.merge, %backedge ], [ undef, %entry ]
; ;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/out-of-scop-use-in-region-entry-phi-node.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0] -> { Stmt_bb3[] -> MemRef_tmp5[] }; ; CHECK-NEXT: [p_0] -> { Stmt_bb3[] -> MemRef_tmp5[] };
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 @hoge() { define void @hoge() {
Show All 27 Lines

test/ScopInfo/parameter-constant-division.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-invariant-load-hoisting=true -disable-output -S \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -analyze -S < %s | FileCheck %s ; RUN: -analyze -S < %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: { Stmt_land_lhs_true563[] -> MemRef_tmp0[809] }; ; CHECK-NEXT: { Stmt_land_lhs_true563[] -> MemRef_tmp0[809] };
; CHECK-NEXT: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_if_then570[] -> MemRef_fs[5] }; ; CHECK-NEXT: { Stmt_if_then570[] -> MemRef_fs[5] };
; CHECK-NEXT: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

test/ScopInfo/parameter_in_dead_statement.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting=true \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=IR
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; ;
; Verify we do not create assumptions based on the parameter p_1 which is the ; Verify we do not create assumptions based on the parameter p_1 which is the
; load %0 and due to error-assumptions not "part of the SCoP". ; load %0 and due to error-assumptions not "part of the SCoP".
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [releaseCount, p_1] -> { : releaseCount > 0 } ; CHECK-NEXT: [releaseCount, p_1] -> { : releaseCount > 0 }
Show All 33 Lines

test/ScopInfo/parameter_product.ll

; RUN: opt %loadPolly -disable-output -S "-passes=print<polly-function-scops>" \
; RUN: < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s
; ;
; int n, m; ; int n, m;
; void foo(char* __restrict a) ; void foo(char* __restrict a)
; { ; {
; for (int i = 0; i < n*m; ++i) ; for (int i = 0; i < n*m; ++i)
; a[i]=2; ; a[i]=2;
; } ; }
Show All 22 Lines

test/ScopInfo/parameter_with_constant_factor_in_add.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that the access function of the store is simple and concise ; Check that the access function of the store is simple and concise
; ;
; CHECK: p0: {0,+,(-1 + (sext i32 (-1 * %smax188) to i64))<nsw>}<%for.cond261.preheader> ; CHECK: p0: {0,+,(-1 + (sext i32 (-1 * %smax188) to i64))<nsw>}<%for.cond261.preheader>
; ;
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [p_0] -> { Stmt_for_body276[i0] -> MemRef_A[p_0] }; ; CHECK-NEXT: [p_0] -> { Stmt_for_body276[i0] -> MemRef_A[p_0] };
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/partially_invariant_load_1.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -S \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s \
; RUN: --check-prefix=IR
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=IR
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, tmp1] -> { Stmt_for_body[i0] -> MemRef_I[0] }; ; CHECK-NEXT: [N, tmp1] -> { Stmt_for_body[i0] -> MemRef_I[0] };
; CHECK-NEXT: Execution Context: [N, tmp1] -> { : N > 0 and (tmp1 >= 43 or tmp1 <= 41) } ; CHECK-NEXT: Execution Context: [N, tmp1] -> { : N > 0 and (tmp1 >= 43 or tmp1 <= 41) }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/partially_invariant_load_2.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s
; ;
; Check that we do not try to preload *I and assume p != 42. ; Check that we do not try to preload *I and assume p != 42.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopInfo/phi-in-non-affine-region.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; Verify that 'tmp' is stored in bb1 and read by bb3, as it is needed as ; Verify that 'tmp' is stored in bb1 and read by bb3, as it is needed as
; incoming value for the tmp11 PHI node. ; incoming value for the tmp11 PHI node.
; CHECK: Stmt_bb1 ; CHECK: Stmt_bb1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_bb1[] }; ; CHECK-NEXT: { Stmt_bb1[] };
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/ScopInfo/phi_condition_modeling_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

test/ScopInfo/phi_condition_modeling_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

test/ScopInfo/phi_conditional_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; ;
; void jd(int *A, int c) { ; void jd(int *A, int c) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (c) ; if (c)
; A[i] = 1; ; A[i] = 1;
; else ; else
; A[i] = 2; ; A[i] = 2;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/ScopInfo/phi_loop_carried_float.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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];
; } ; }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/phi_scalar_simple_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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.
; ;
; 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++)
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

test/ScopInfo/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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;
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

test/ScopInfo/phi_with_invoke_edge.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-detect -analyze < %s ; RUN: opt %loadPolly -polly-detect -analyze < %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" 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"
declare i32 @generic_personality_v0(i32, i64, i8*, i8*) declare i32 @generic_personality_v0(i32, i64, i8*, i8*)
define i16 @v() personality i32 (i32, i64, i8*, i8*)* @generic_personality_v0 { define i16 @v() personality i32 (i32, i64, i8*, i8*)* @generic_personality_v0 {
entry: entry:
br i1 undef, label %bb16, label %invcont12 br i1 undef, label %bb16, label %invcont12
Show All 18 Lines

test/ScopInfo/pointer-comparison-no-nsw.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
; while (A != B) { ; while (A != B) {
; *A = *A + 1; ; *A = *A + 1;
; A++; ; A++;
; } ; }
; } ; }
Show All 31 Lines

test/ScopInfo/pointer-comparison.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; TODO: FIXME: Investigate why we need a InvalidContext here. ; TODO: FIXME: Investigate why we need a InvalidContext here.
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
; while (A != B) { ; while (A != B) {
; *A = *A + 1; ; *A = *A + 1;
; A++; ; A++;
Show All 30 Lines

test/ScopInfo/pointer-type-expressions.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; void f(int a[], int N, float *P) { ; void f(int a[], int N, float *P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (*P != 0) ; if (*P != 0)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 38 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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-NEXT: float MemRef_A[*]; // Element size 4 ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/polly-timeout-parameter-bounds.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_bb9 ; CHECK-NEXT: Stmt_bb9
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp] -> { Stmt_bb9[] }; ; CHECK-NEXT: [tmp] -> { Stmt_bb9[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp] -> { Stmt_bb9[] -> [0] }; ; CHECK-NEXT: [tmp] -> { Stmt_bb9[] -> [0] };
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines

test/ScopInfo/process_added_dimensions.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

test/ScopInfo/ranged_parameter.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that the contstraints on the paramater derived from the ; Check that the contstraints on the paramater derived from the
; range metadata (see bottom of the file) are present: ; range metadata (see bottom of the file) are present:
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp] -> { : 0 <= tmp <= 255 } ; CHECK: [tmp] -> { : 0 <= tmp <= 255 }
; ;
Show All 33 Lines

test/ScopInfo/ranged_parameter_2.ll

; RUN: opt %loadPolly -disable-output -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true < %s -debug 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-scops -analyze -polly-allow-nonaffine -polly-invariant-load-hoisting=true < %s \ ; RUN: opt %loadPolly -polly-scops -analyze -polly-allow-nonaffine -polly-invariant-load-hoisting=true < %s \
; RUN: -debug 2>&1 | FileCheck %s ; RUN: -debug 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK: Region: %bb1---%bb16 ; CHECK: Region: %bb1---%bb16
; CHECK: [n] -> { : false } ; CHECK: [n] -> { : false }
Show All 33 Lines

test/ScopInfo/ranged_parameter_wrap.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that the constraints on the parameter derived from the ; Check that the constraints on the parameter derived from the
; __wrapping__ range metadata (see bottom of the file) are present: ; __wrapping__ range metadata (see bottom of the file) are present:
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp] -> { : -2147483648 <= tmp <= 2147483647 and (tmp >= 256 or tmp < 0) } ; CHECK: [tmp] -> { : -2147483648 <= tmp <= 2147483647 and (tmp >= 256 or tmp < 0) }
; ;
Show All 33 Lines

test/ScopInfo/ranged_parameter_wrap_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that the context is built fast and does not explode due to us ; Check that the context is built fast and does not explode due to us
; combining a large number of non-convex ranges. Instead, after a certain ; combining a large number of non-convex ranges. Instead, after a certain
; time, we store range information with reduced precision. ; time, we store range information with reduced precision.
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp_0, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp_6, tmp_7, tmp_8, ; CHECK: [tmp_0, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp_6, tmp_7, tmp_8,
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; 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];
; ;
Show All 29 Lines

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

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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];
; ;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

test/ScopInfo/read-only-scalars.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-analyze-read-only-scalars=false -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=false -polly-scops \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=false -polly-scops \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-analyze-read-only-scalars=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s -check-prefix=SCALARS
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=true -polly-scops \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=true -polly-scops \
; RUN: -analyze < %s | FileCheck %s \ ; RUN: -analyze < %s | FileCheck %s \
; RUN: -check-prefix=SCALARS ; RUN: -check-prefix=SCALARS
; CHECK-NOT: Memref_scalar ; CHECK-NOT: Memref_scalar
; SCALARS: float MemRef_scalar; // Element size 4 ; SCALARS: float MemRef_scalar; // Element size 4
Show All 29 Lines

test/ScopInfo/read-only-statements.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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] : 0 <= i0 <= 99 }; ; CHECK-NEXT: { Stmt_for_body_2[i0] : 0 <= i0 <= 99 };
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

test/ScopInfo/reduction_alternating_base.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i % 2] += i; ; A[i % 2] += i;
; } ; }
; ;
Show All 31 Lines

test/ScopInfo/reduction_chain_partially_outside_the_scop.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; ;
; int c, d; ; int c, d;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; *sum = c + d; ; *sum = c + d;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

test/ScopInfo/reduction_disabled_multiplicative.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: -polly-disable-multiplicative-reductions \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt -basicaa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-disable-multiplicative-reductions < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-disable-multiplicative-reductions < %s | FileCheck %s
; ;
; CHECK: ReadAccess := [Reduction Type: + ; CHECK: ReadAccess := [Reduction Type: +
; CHECK: { Stmt_for_body[i0] -> MemRef_sum[0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_sum[0] };
; CHECK: MustWriteAccess := [Reduction Type: + ; CHECK: MustWriteAccess := [Reduction Type: +
; CHECK: { Stmt_for_body[i0] -> MemRef_sum[0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_sum[0] };
; CHECK: ReadAccess := [Reduction Type: NONE ; CHECK: ReadAccess := [Reduction Type: NONE
; CHECK: { Stmt_for_body[i0] -> MemRef_prod[0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_prod[0] };
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/reduction_escaping_intermediate.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int N, int * restrict sums, int * restrict escape) { ; void f(int N, int * restrict sums, int * restrict escape) {
; int i, j; ; int i, j;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; for (j = 0; j < 1024; j++) { ; for (j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; escape[N - i + j] = sums[i]; ; escape[N - i + j] = sums[i];
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/ScopInfo/reduction_escaping_intermediate_2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int N, int * restrict sums, int * restrict escape) { ; void f(int N, int * restrict sums, int * restrict escape) {
; int i, j; ; int i, j;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; for (j = 0; j < 1024; j++) { ; for (j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; escape[N-j] = escape[i] + sums[i-1]; ; escape[N-j] = escape[i] + sums[i-1];
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/ScopInfo/reduction_invalid_different_operators.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s --allow-empty
; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; int f() { ; int f() {
; int i, sum = 0, sth = 0; ; int i, sum = 0, sth = 0;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; sum += 5; ; sum += 5;
; sth = sth + sth * sth + sth; ; sth = sth + sth * sth + sth;
; sum *= 5; ; sum *= 5;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopInfo/reduction_invalid_overlapping_accesses.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *sums) { ; void f(int *sums) {
; int i, j; ; int i, j;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; for (j = 0; j < 1024; j++) { ; for (j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; sums[i+10] *= 5; ; sums[i+10] *= 5;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

test/ScopInfo/reduction_multiple_loops_array_sum.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: MemRef_sum ; CHECK: MemRef_sum
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: MemRef_sum ; CHECK: MemRef_sum
; CHECK: Stmt_for_body3 ; CHECK: Stmt_for_body3
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

test/ScopInfo/reduction_multiple_loops_array_sum_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: MemRef_sum_04 ; CHECK: MemRef_sum_04
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: MemRef_sum_12 ; CHECK: MemRef_sum_12
; CHECK: Stmt_for_inc ; CHECK: Stmt_for_inc
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

test/ScopInfo/reduction_multiple_simple_binary.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -disable-output \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa \
; RUN: < %s 2>&1 | FileCheck %s
;
; RUN: opt -basicaa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: ReadAccess := [Reduction Type: NONE ; CHECK: ReadAccess := [Reduction Type: NONE
; CHECK: { Stmt_for_body[i0] -> MemRef_A[1 + i0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_A[1 + i0] };
; CHECK: ReadAccess := [Reduction Type: NONE ; CHECK: ReadAccess := [Reduction Type: NONE
; CHECK: { Stmt_for_body[i0] -> MemRef_A[i0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_A[i0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE ; CHECK: MustWriteAccess := [Reduction Type: NONE
; CHECK: { Stmt_for_body[i0] -> MemRef_first[0] }; ; CHECK: { Stmt_for_body[i0] -> MemRef_first[0] };
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/ScopInfo/reduction_non_overlapping_chains.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; ;
; void f(int *sums) { ; void f(int *sums) {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/reduction_only_reduction_like_access.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; sum[i] = sum[99-i] + i; ; sum[i] = sum[99-i] + i;
; } ; }
Show All 27 Lines

test/ScopInfo/reduction_simple_fp.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Function: f_no_fast_math ; CHECK: Function: f_no_fast_math
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: Function: f_fast_math ; CHECK: Function: f_fast_math
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(float *sum) { ; void f(float *sum) {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

test/ScopInfo/reduction_simple_w_constant.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i <= 100; i++) ; for (int i = 0; i <= 100; i++)
; sum += 3; ; sum += 3;
; } ; }
Show All 18 Lines

test/ScopInfo/reduction_simple_w_iv.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; 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;
; } ; }
Show All 19 Lines

test/ScopInfo/reduction_two_identical_reads.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; ;
; Check that we do not mark these accesses as reduction like. ; Check that we do not mark these accesses as reduction like.
; We do this for the case the loads are modelt with the same LLVM-IR value and ; We do this for the case the loads are modelt with the same LLVM-IR value and
; for the case there are different LLVM-IR values. ; for the case there are different LLVM-IR values.
; ;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

test/ScopInfo/redundant_parameter_constraint.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; The constraint that r2 has to be bigger than r1 is implicitly containted in ; The constraint that r2 has to be bigger than r1 is implicitly containted in
; the domain, hence we do not want to see it explicitly. ; the domain, hence we do not want to see it explicitly.
; ;
; CHECK-NOT: r2 >= 1 + r1 ; CHECK-NOT: r2 >= 1 + r1
; ;
; void wraps(int *A, int p, short q, char r1, char r2) { ; void wraps(int *A, int p, short q, char r1, char r2) {
Show All 35 Lines

test/ScopInfo/remarks.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-invariant-load-hoisting=true -disable-output < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-invariant-load-hoisting=true -disable-output < %s 2>&1 | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -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:9:15: Inbounds assumption: [N, M, Debug] -> { : M <= 100 } ; CHECK: remark: test/ScopInfo/remarks.c:9:15: Inbounds assumption: [N, M, Debug] -> { : M <= 100 }
; CHECK: remark: test/ScopInfo/remarks.c:13:7: No-error restriction: [N, M, Debug] -> { : N > 0 and M >= 0 and (Debug < 0 or Debug > 0) } ; CHECK: remark: test/ScopInfo/remarks.c:13:7: No-error restriction: [N, M, Debug] -> { : N > 0 and M >= 0 and (Debug < 0 or Debug > 0) }
; CHECK: remark: test/ScopInfo/remarks.c:8:5: Finite loop restriction: [N, M, Debug] -> { : N > 0 and M < 0 } ; CHECK: remark: test/ScopInfo/remarks.c:8:5: Finite loop restriction: [N, M, Debug] -> { : N > 0 and M < 0 }
; CHECK: remark: test/ScopInfo/remarks.c:4:7: No-overflows restriction: [N, M, Debug] -> { : M <= -2147483649 - N or M >= 2147483648 - N } ; CHECK: remark: test/ScopInfo/remarks.c:4:7: No-overflows restriction: [N, M, Debug] -> { : M <= -2147483649 - N or M >= 2147483648 - N }
▲ Show 20 Lines • Show All 309 Lines • Show Last 20 Lines

test/ScopInfo/required-invariant-loop-bounds.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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[0] ; CHECK-NEXT: MemRef_bounds[0]
; CHECK-NEXT: Execution Context: [bounds0, bounds1] -> { : } ; CHECK-NEXT: Execution Context: [bounds0, bounds1] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

test/ScopInfo/restriction_in_dead_block.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify we do not generate an empty invalid context only because the wrap ; Verify we do not generate an empty invalid context only because the wrap
; in the second conditional will always happen if the block is executed. ; in the second conditional will always happen if the block is executed.
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [N] -> { : N > 0 } ; CHECK-NEXT: [N] -> { : N > 0 }
; ;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/run-time-check-many-array-disjuncts.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-detect>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-detect -analyze < %s \
; RUN: | FileCheck %s -check-prefix=DETECT ; RUN: | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; DETECT: Valid Region for Scop: bb124 => bb176 ; DETECT: Valid Region for Scop: bb124 => bb176
; ;
; A valid Scop would print the list of it's statements, we check that we do not ; A valid Scop would print the list of it's statements, we check that we do not
; see that list. ; see that list.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

test/ScopInfo/run-time-check-many-parameters.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; A valid Scop would print the list of it's statements, we check that we do not ; A valid Scop would print the list of it's statements, we check that we do not
; see that list. ; see that list.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
; FIXME: Handling this is an open problem, at the moment we just bail out. ; FIXME: Handling this is an open problem, at the moment we just bail out.
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

test/ScopInfo/run-time-check-read-only-arrays.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void foo(float *A, float *B, float *C, long N) { ; void foo(float *A, float *B, float *C, long N) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; C[i] = A[i] + B[i]; ; C[i] = A[i] + B[i];
; } ; }
; ;
; CHECK: Alias Groups (2): ; CHECK: Alias Groups (2):
Show All 25 Lines

test/ScopInfo/same-base-address-scalar-and-array.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify we introduce two ScopArrayInfo objects (or virtual arrays) for the %out variable ; Verify we introduce two ScopArrayInfo objects (or virtual arrays) for the %out variable
; as it is used as a memory base pointer (%0) but also as a scalar (%out.addr.0.lcssa). ; as it is used as a memory base pointer (%0) but also as a scalar (%out.addr.0.lcssa).
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: float* MemRef_out_addr_0_lcssa; // Element size 8 ; CHECK-NEXT: float* MemRef_out_addr_0_lcssa; // Element size 8
; CHECK-NEXT: float MemRef_out[*]; // Element size 4 ; CHECK-NEXT: float MemRef_out[*]; // Element size 4
Show All 21 Lines

test/ScopInfo/scalar.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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-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* %a, i64 %N) { define void @f(i64* %a, i64 %N) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

test/ScopInfo/scalar_dependence_cond_br.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, int c, int d) { ; void f(int *A, int c, int d) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (c < i) ; if (c < i)
; A[i]++; ; A[i]++;
; } ; }
; ;
Show All 39 Lines

test/ScopInfo/scalar_to_array.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
lksbhmUnsubmitted
Not Done
ReplyInline Actions

This is the same RUN line twice. I just noticed this by accident. The polly-scops and polly-function-scops flags map to the same new-pm pass. It might be good to look for similar cases within the other tests.

lksbhm: This is the same RUN line twice. I just noticed this by accident. The `polly-scops` and `polly…
; RUN: opt %loadPolly -basicaa -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-function-scops -analyze < %s | FileCheck %s
; ModuleID = 'scalar_to_array.ll' ; ModuleID = 'scalar_to_array.ll'
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"
@A = common global [1024 x float] zeroinitializer, align 8 @A = common global [1024 x float] zeroinitializer, align 8
; Terminating loops without side-effects will be optimzied away, hence ; Terminating loops without side-effects will be optimzied away, hence
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

test/ScopInfo/scev-div-with-evaluatable-divisor.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; Derived from test-suite/SingleSource/UnitTests/Vector/SSE/sse.stepfft.c ; Derived from test-suite/SingleSource/UnitTests/Vector/SSE/sse.stepfft.c
; The values %mul.i44 is simplified to constant 4 by ScalarEvolution, but ; The values %mul.i44 is simplified to constant 4 by ScalarEvolution, but
; SCEVAffinator used to check whether the sdiv's argument was constant. ; SCEVAffinator used to check whether the sdiv's argument was constant.
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 20 Lines • Show All 52 Lines • Show Last 20 Lines

test/ScopInfo/scev-invalidated.ll

; RUN: opt %loadPolly "-passes=require<polly-function-scops>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-scops < %s ; RUN: opt %loadPolly -polly-scops < %s
; ;
; CHECK: Region: %if.then6---%return ; CHECK: Region: %if.then6---%return
; ;
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 @arc_either() { define void @arc_either() {
entry: entry:
Show All 16 Lines

test/ScopInfo/schedule-const-post-dominator-walk-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; CHECK: Stmt_loopA[i0] -> [0, 0, 0] ; CHECK: Stmt_loopA[i0] -> [0, 0, 0]
; CHECK-DAG: Stmt_loopB[i0] -> [0, 0, 1] ; CHECK-DAG: Stmt_loopB[i0] -> [0, 0, 1]
; CHECK-DAG: Stmt_bbB[] -> [1, 0, 0] ; CHECK-DAG: Stmt_bbB[] -> [1, 0, 0]
; CHECK-DAG: Stmt_bbA[] -> [2, 0, 0] ; CHECK-DAG: Stmt_bbA[] -> [2, 0, 0]
; CHECK-DAG: Stmt_bbMerge[] -> [3, 0, 0] ; CHECK-DAG: Stmt_bbMerge[] -> [3, 0, 0]
Show All 34 Lines

test/ScopInfo/schedule-const-post-dominator-walk.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s
; CHECK: { Stmt_bb3[i0] -> [0, 0] }; ; CHECK: { Stmt_bb3[i0] -> [0, 0] };
; CHECK: { Stmt_bb2[] -> [1, 0] }; ; CHECK: { Stmt_bb2[] -> [1, 0] };
; Verify that we generate the correct schedule. In older versions of Polly, ; Verify that we generate the correct schedule. In older versions of Polly,
; we generated an incorrect schedule: ; we generated an incorrect schedule:
; ;
Show All 26 Lines

test/ScopInfo/schedule-constuction-endless-loop1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that we do not build a SCoP and do not crash. ; Check that we do not build a SCoP and do not crash.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
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 26 Lines

test/ScopInfo/schedule-constuction-endless-loop2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that we do not build a SCoP and do not crash. ; Check that we do not build a SCoP and do not crash.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
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

test/ScopInfo/schedule-incorrectly-contructed-in-case-of-infinite-loop.ll

; RUN: opt %loadPolly -polly-process-unprofitable -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-scops < %s ; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-scops < %s
; ;
; This test contains a infinite loop (bb13) and crashed the domain generation ; This test contains a infinite loop (bb13) and crashed the domain generation
; at some point. Just verify it does not anymore. ; at some point. Just verify it does not anymore.
; ;
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 @hoge() #0 { define void @hoge() #0 {
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

test/ScopInfo/scop-affine-parameter-ordering.ll

; RUN: opt %loadPolly %s -disable-output "-passes=print<polly-function-scops>" \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops %s -analyze | FileCheck %s ; RUN: opt %loadPolly -polly-scops %s -analyze | FileCheck %s
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"
target triple = "aarch64--linux-android" target triple = "aarch64--linux-android"
; Check for SCOP: ; Check for SCOP:
; CHECK: Stmt_for_body8_us_us95_i ; CHECK: Stmt_for_body8_us_us95_i
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p_0] -> { Stmt_for_body8_us_us95_i[i0] : 0 <= i0 <= 4 }; ; CHECK-NEXT: [p_0] -> { Stmt_for_body8_us_us95_i[i0] : 0 <= i0 <= 4 };
Show All 31 Lines

test/ScopInfo/sign_wrapped_set.ll

; RUN: opt %loadPolly -disable-output -polly-allow-nonaffine \
; RUN: -polly-process-unprofitable "-passes=print<polly-function-scops>" < %s \
; RUN: 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-allow-nonaffine -polly-process-unprofitable < %s | FileCheck %s ; RUN: -polly-allow-nonaffine -polly-process-unprofitable < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] : 0 <= i0 <= -3 + srcHeight }; ; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] : 0 <= i0 <= -3 + srcHeight };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> [i0] }; ; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
Show All 34 Lines

test/ScopInfo/simple_loop_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -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;
; } ; }
Show All 35 Lines

test/ScopInfo/simple_loop_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -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;
; } ; }
Show All 35 Lines

test/ScopInfo/simple_loop_unsigned.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; void f(int a[], unsigned N) { ; void f(int a[], unsigned N) {
; unsigned i; ; unsigned i;
; do { ; do {
; a[i] = i; ; a[i] = i;
; } while (++i <= N); ; } while (++i <= N);
; } ; }
Show All 26 Lines

test/ScopInfo/simple_loop_unsigned_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N <= 0 or N >= 1152921504606846976 } ; CHECK-NEXT: [N] -> { : N <= 0 or N >= 1152921504606846976 }
; ;
; CHECK: Domain := ; CHECK: Domain :=
Show All 19 Lines

test/ScopInfo/simple_loop_unsigned_3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: [N] -> { Stmt_bb[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb[0] };
Show All 18 Lines

test/ScopInfo/simple_nonaffine_loop_not.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | not FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | not 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"
@.str = private unnamed_addr constant [17 x i8] c"Random Value: %d\00", align 1 @.str = private unnamed_addr constant [17 x i8] c"Random Value: %d\00", align 1
define i32 @main() nounwind uwtable ssp { define i32 @main() nounwind uwtable ssp {
entry: entry:
%A = alloca [1048576 x i32], align 16 %A = alloca [1048576 x i32], align 16
Show All 31 Lines

test/ScopInfo/smax.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64"
define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) { define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 17 Lines

test/ScopInfo/statistics.ll

; RUN: opt %loadPolly -stats -disable-output < %s 2>&1 \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa | FileCheck \
; RUN: %s
; RUN: opt %loadPolly -polly-scops -stats -analyze < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-scops -stats -analyze < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-LABEL: Statistics Collected
; CHECK-DAG: 4 polly-scops - Maximal number of loops in scops ; CHECK-DAG: 4 polly-scops - Maximal number of loops in scops
; CHECK-DAG: 10 polly-scops - Number of loops in scops ; CHECK-DAG: 10 polly-scops - Number of loops in scops
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 4 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 4
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 1 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 1
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 3 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 3
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 2 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 2
; CHECK-DAG: 4 polly-scops - Number of Scops containing a loop ; CHECK-DAG: 4 polly-scops - Number of Scops containing a loop
; CHECK-DAG: 4 polly-scops - Number of valid Scops ; CHECK-DAG: 4 polly-scops - Number of valid Scops
▲ Show 20 Lines • Show All 230 Lines • Show Last 20 Lines

test/ScopInfo/stmt_split_no_after_split.ll

; RUN: opt %loadPolly -disable-output -polly-print-instructions \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_Stmt ; CHECK-NEXT: Stmt_Stmt
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0] };
Show All 35 Lines

test/ScopInfo/switch-1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; break; ; break;
; case 1: ; case 1:
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

test/ScopInfo/switch-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

test/ScopInfo/switch-3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; case 1: ; case 1:
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

test/ScopInfo/switch-4.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

test/ScopInfo/switch-5.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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]++;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

test/ScopInfo/switch-6.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; switch (i) { ; switch (i) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

test/ScopInfo/switch-7.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-ast>" < %s 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s --check-prefix=AST
; 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 c, int N) { ; void f(int *A, int c, int N) {
; switch (c) { ; switch (c) {
; case -1: { ; case -1: {
; for (int j = N; j > 0; j--) ; for (int j = N; j > 0; j--)
; A[j] += A[j - 1]; ; A[j] += A[j - 1];
; break; ; break;
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

test/ScopInfo/tempscop-printing.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-scops -analyze \ ; RUN: opt %loadPolly -basicaa -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %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;
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

test/ScopInfo/test-wrapping-in-condition.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; #include <stdlib.h> ; #include <stdlib.h>
; #include <stdio.h> ; #include <stdio.h>
; ;
Show All 37 Lines

test/ScopInfo/truncate-1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(char *A, short N) { ; void f(char *A, short N) {
; for (char i = 0; i < (char)N; i++) ; for (char i = 0; i < (char)N; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; FIXME: We should the truncate precisely... or just make it a separate parameter. ; FIXME: We should the truncate precisely... or just make it a separate parameter.
Show All 38 Lines

test/ScopInfo/truncate-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(char *A, short N) { ; void f(char *A, short N) {
; for (short i = 0; i < N; i++) ; for (short i = 0; i < N; i++)
; A[(char)(N)]++; ; A[(char)(N)]++;
; } ; }
; ;
; FIXME: We should the truncate precisely... or just make it a separate parameter. ; FIXME: We should the truncate precisely... or just make it a separate parameter.
Show All 36 Lines

test/ScopInfo/truncate-3.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \
; RUN: -disable-output < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; CHECK: Signed-unsigned restriction: [p] -> { : p <= -129 or p >= 128 } ; CHECK: Signed-unsigned restriction: [p] -> { : p <= -129 or p >= 128 }
; Verify that this test case does not crash when we try to model it. ; Verify that this test case does not crash when we try to model it.
; At some point we tried to insert a restriction: ; At some point we tried to insert a restriction:
; [p] -> { : p <= -129 or p >= 128 } ; [p] -> { : p <= -129 or p >= 128 }
Show All 18 Lines

test/ScopInfo/two-loops-one-infinite.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Verify we do not create a SCoP in the presence of infinite loops. ; Verify we do not create a SCoP in the presence of infinite loops.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
Show All 32 Lines

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

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_loop_1 ; CHECK-NEXT: Stmt_loop_1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] : N <= 100 and 0 <= i0 <= 101 }; ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] : N <= 100 and 0 <= i0 <= 101 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

test/ScopInfo/undef_in_cond.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --allow-empty
; 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-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"
define fastcc void @fix_operands() nounwind { define fastcc void @fix_operands() nounwind {
entry: entry:
br i1 undef, label %bb3, label %bb1 br i1 undef, label %bb3, label %bb1
bb1: ; preds = %bb bb1: ; preds = %bb
Show All 14 Lines

test/ScopInfo/unnamed_nonaffine.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output < %s \
; RUN: -polly-use-llvm-names=true "-passes=print<polly-function-scops>" 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \
; RUN: -polly-use-llvm-names=true | FileCheck %s ; RUN: -polly-use-llvm-names=true | FileCheck %s
; ;
; RUN: opt %loadPolly -polly-allow-nonaffine -disable-output < %s \
; RUN: -polly-use-llvm-names=false "-passes=print<polly-function-scops>" 2>&1 \
; RUN: -aa-pipeline=basic-aa | FileCheck %s -check-prefix=UNNAMED
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \
; RUN: -polly-use-llvm-names=false | FileCheck %s -check-prefix=UNNAMED ; RUN: -polly-use-llvm-names=false | FileCheck %s -check-prefix=UNNAMED
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; int x; ; int x;
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (b > i) ; if (b > i)
; x = 0; ; x = 0;
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

test/ScopInfo/unnamed_stmts.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; This test case verifies that we generate numbered statement names in case ; This test case verifies that we generate numbered statement names in case
; no LLVM-IR names are used in the test case. We also verify, that we ; no LLVM-IR names are used in the test case. We also verify, that we
; distinguish statements named with a number and unnamed statements that happen ; distinguish statements named with a number and unnamed statements that happen
; to have an index identical to a number used in a statement name. ; to have an index identical to a number used in a statement name.
; CHECK: Arrays { ; CHECK: Arrays {
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

test/ScopInfo/unprofitable_scalar-accs.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-scops -analyze < %s | FileCheck %s
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb \
; RUN: -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=true \
; RUN: -disable-output "-passes=print<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa < %s 2>&1 | \
; RUN: FileCheck %s --check-prefix=HEURISTIC -allow-empty
;
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=true -polly-scops -analyze < %s | FileCheck %s --check-prefix=HEURISTIC ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=true -polly-scops -analyze < %s | FileCheck %s --check-prefix=HEURISTIC
; Check the effect of -polly-unprofitable-scalar-accs ; Check the effect of -polly-unprofitable-scalar-accs
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 @func(i32 %n, i32 %m, double* noalias nonnull %A) { define void @func(i32 %n, i32 %m, double* noalias nonnull %A) {
entry: entry:
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

test/ScopInfo/unsigned-condition.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; void f(int a[], int N, unsigned P) { ; void f(int a[], int N, unsigned P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P > 42) ; if (P > 42)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 36 Lines

test/ScopInfo/unsigned-division-1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N / 2; i++) ; for (unsigned i = 0; i < N / 2; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 34 Lines

test/ScopInfo/unsigned-division-2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N / 2 + 3; i++) ; for (unsigned i = 0; i < N / 2 + 3; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 35 Lines

test/ScopInfo/unsigned-division-3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, unsigned char N) { ; void f(int *A, unsigned char N) {
; for (unsigned i = 0; i <= N / -128; i++) ; for (unsigned i = 0; i <= N / -128; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 34 Lines

test/ScopInfo/unsigned-division-4.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, unsigned char N) { ; void f(int *A, unsigned char N) {
; for (unsigned i = 0; i < (N / -128) + 3; i++) ; for (unsigned i = 0; i < (N / -128) + 3; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 35 Lines

test/ScopInfo/unsigned-division-5.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N; i++) ; for (unsigned i = 0; i < N; i++)
; A[i / 3] = A[5 * N / 3]; ; A[i / 3] = A[5 * N / 3];
; } ; }
; ;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

test/ScopInfo/unsigned_wrap_uge.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( 63 >= (unsigned)i ) ; if ( 63 >= (unsigned)i )
; A[i] = 42; ; A[i] = 42;
Show All 38 Lines

test/ScopInfo/unsigned_wrap_ugt.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( 64 > (unsigned)i ) ; if ( 64 > (unsigned)i )
; A[i] = 42; ; A[i] = 42;
Show All 38 Lines

test/ScopInfo/unsigned_wrap_ule.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( (unsigned)i <= 63 ) ; if ( (unsigned)i <= 63 )
; A[i] = 42; ; A[i] = 42;
Show All 38 Lines

test/ScopInfo/unsigned_wrap_ult.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( (unsigned)i < 64 ) ; if ( (unsigned)i < 64 )
; A[i] = 42; ; A[i] = 42;
Show All 38 Lines

test/ScopInfo/user_context.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly "-polly-context=[N] -> {: N = 1024}" -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: 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] -> {: N = 1024}' -analyze < %s | FileCheck %s --check-prefix=CTX
; RUN: opt %loadPolly "-polly-context=[N,M] -> {: 1 = 0}" -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; 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-context=[] -> {: 1 = 0}" -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: 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;
; } ; }
Show All 24 Lines

test/ScopInfo/user_provided_assumptions-in-bb-signed-conditional.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; REMARK: remark: <unknown>:0:0: Use user assumption: [n, b] -> { : n <= 100 or (b = 0 and n >= 101) } ; REMARK: remark: <unknown>:0:0: Use user assumption: [n, b] -> { : n <= 100 or (b = 0 and n >= 101) }
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n, b] -> { : -9223372036854775808 <= n <= 9223372036854775807 and ((n <= 100 and -9223372036854775808 <= b <= 9223372036854775807) or (b = 0 and n >= 101)) } ; CHECK-NEXT: [n, b] -> { : -9223372036854775808 <= n <= 9223372036854775807 and ((n <= 100 and -9223372036854775808 <= b <= 9223372036854775807) or (b = 0 and n >= 101)) }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
; CHECK-NEXT: [n, b] -> { : } ; CHECK-NEXT: [n, b] -> { : }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

test/ScopInfo/user_provided_assumptions-in-bb-signed.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 } ; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 }
; ;
; void foo(float A[][100], long n) { ; void foo(float A[][100], long n) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[42][i] = 42.0; ; A[42][i] = 42.0;
Show All 34 Lines

test/ScopInfo/user_provided_assumptions-in-bb-unsigned.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; REMARK: remark: <unknown>:0:0: SCoP begins here. ; REMARK: remark: <unknown>:0:0: SCoP begins here.
; REMARK-NEXT: remark: <unknown>:0:0: Use user assumption: [n] -> { : n <= 100 } ; REMARK-NEXT: remark: <unknown>:0:0: Use user assumption: [n] -> { : n <= 100 }
; REMARK-NEXT: remark: <unknown>:0:0: Signed-unsigned restriction: [n] -> { : n < 0 } ; REMARK-NEXT: remark: <unknown>:0:0: Signed-unsigned restriction: [n] -> { : n < 0 }
; REMARK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; REMARK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; ;
; CHECK: Context: ; CHECK: Context:
Show All 39 Lines

test/ScopInfo/user_provided_assumptions.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %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 -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; 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] -> { : -2147483648 - M <= N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : -2147483648 - M <= N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and -2147483648 - M <= N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and -2147483648 - M <= N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and 0 < N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and 0 < N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

test/ScopInfo/user_provided_assumptions_2.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %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 -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; 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: { : } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: { : }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; SCOP: Context: ; SCOP: Context:
; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 } ; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

test/ScopInfo/user_provided_assumptions_3.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops -disable-output < %s \
; RUN: 2>&1 "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %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 -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; 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: [N] -> { : N >= 2 } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [N] -> { : N >= 2 }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; SCOP: Context: ; SCOP: Context:
; SCOP-NEXT: [N, M] -> { : 2 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 } ; SCOP-NEXT: [N, M] -> { : 2 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

test/ScopInfo/user_provided_non_dominating_assumptions.ll

; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-precise-inbounds -disable-output < %s 2>&1 \
; RUN: "-passes=require<polly-function-scops>" -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-precise-inbounds -disable-output < %s 2>&1 | FileCheck %s ; RUN: -polly-precise-inbounds -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: Use user assumption: [i, N, M] -> { : N <= i or (N > i and N >= 0) } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [i, N, M] -> { : N <= i or (N > i and N >= 0) }
; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, M] -> { : N <= i or (N > i and M <= 100) } ; CHECK-NEXT: remark: <unknown>:0:0: Inbounds assumption: [i, N, M] -> { : N <= i or (N > i and M <= 100) }
; 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];
; } ; }
; } ; }
; } ; }
; ;
; RUN: opt %loadPolly -pass-remarks-analysis=polly-scops \
; RUN: -polly-precise-inbounds -disable-output < %s 2>&1 \
; RUN: "-pass-remarks-output=%t.yaml" "-passes=require<polly-function-scops>" \
; RUN: -aa-pipeline=basic-aa
; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: -polly-precise-inbounds -disable-output < %s 2>&1 -pass-remarks-output=%t.yaml ; RUN: -polly-precise-inbounds -disable-output < %s 2>&1 -pass-remarks-output=%t.yaml
; RUN: cat "%t.yaml" | FileCheck -check-prefix=YAML %s
; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s ; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
; YAML: --- !Analysis ; YAML: --- !Analysis
; YAML: Pass: polly-scops ; YAML: Pass: polly-scops
; YAML: Name: ScopEntry ; YAML: Name: ScopEntry
; YAML: Function: f ; YAML: Function: f
; YAML: Args: ; YAML: Args:
; YAML: - String: SCoP begins here. ; YAML: - String: SCoP begins here.
; YAML: ... ; YAML: ...
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

test/ScopInfo/variant_base_pointer.ll

; RUN: opt %loadPolly -polly-ignore-aliasing \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s --allow-empty
; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ignore-aliasing \
; RUN: -polly-invariant-load-hoisting=true -disable-output \
; RUN: -passes=polly-codegen < %s 2>&1 -aa-pipeline=basic-aa
; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-codegen -analyze < %s
; ;
; %tmp is added to the list of required hoists by -polly-scops and just ; %tmp is added to the list of required hoists by -polly-scops and just
; assumed to be hoisted. Only -polly-scops recognizes it to be unhoistable ; assumed to be hoisted. Only -polly-scops recognizes it to be unhoistable
; because ir depends on %call which cannot be executed speculatively. ; because ir depends on %call which cannot be executed speculatively.
; ;
; CHECK-NOT: Invariant Accesses: ; CHECK-NOT: Invariant Accesses:
; ;
Show All 29 Lines

test/ScopInfo/variant_load_empty_domain.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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: } ; CHECK-NEXT: }
; ;
; CHECK-NOT: Stmt_if_then ; CHECK-NOT: Stmt_if_then
; ;
; ;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

test/ScopInfo/wraping_signed_expr_0.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int *A, char N, char p) { ; void f(int *A, char N, char p) {
; for (char i = 0; i < N; i++) { ; for (char i = 0; i < N; i++) {
; A[i + 3] = 0; ; A[i + 3] = 0;
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

test/ScopInfo/wraping_signed_expr_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(long *A, long N, long p) { ; void f(long *A, long N, long p) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; A[i + 1] = 0; ; A[i + 1] = 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,
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

test/ScopInfo/wraping_signed_expr_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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,
Show All 36 Lines

test/ScopInfo/wraping_signed_expr_3.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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 + p] = 0; ; A[i + p] = 0;
; } ; }
; ;
; Note: 2147483648 == 2 ^ 31 ; Note: 2147483648 == 2 ^ 31
Show All 29 Lines

test/ScopInfo/wraping_signed_expr_4.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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
Show All 31 Lines

test/ScopInfo/wraping_signed_expr_5.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; 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: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [r1, r2, q, p] -> { : r2 > r1 and (p <= -2147483649 - q or r2 >= 128 + r1 or p >= 2147483648 - q) } ; CHECK-NEXT: [r1, r2, q, p] -> { : r2 > r1 and (p <= -2147483649 - q or r2 >= 128 + r1 or p >= 2147483648 - q) }
; ;
Show All 36 Lines

test/ScopInfo/wraping_signed_expr_6.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; void foo(float *A, long N) { ; void foo(float *A, long N) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; if ((signed char)i < 100) ; if ((signed char)i < 100)
Show All 34 Lines

test/ScopInfo/wraping_signed_expr_7.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; void foo(float *A, long N) { ; void foo(float *A, long N) {
; for (long i = 0; i < N;) ; for (long i = 0; i < N;)
; if ((signed char)i++ < 100) ; if ((signed char)i++ < 100)
Show All 34 Lines

test/ScopInfo/wraping_signed_expr_slow_1.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; This checks that the no-wraps checks will be computed fast as some example ; This checks that the no-wraps checks will be computed fast as some example
; already showed huge slowdowns even though the inbounds and nsw flags were ; already showed huge slowdowns even though the inbounds and nsw flags were
; all in place. ; all in place.
; ;
; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark. ; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark.
; void fast(char *A, char N, char M) { ; void fast(char *A, char N, char M) {
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

test/ScopInfo/wraping_signed_expr_slow_2.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; This checks that the no-wraps checks will be computed fast as some example ; This checks that the no-wraps checks will be computed fast as some example
; already showed huge slowdowns even though the inbounds and nsw flags were ; already showed huge slowdowns even though the inbounds and nsw flags were
; all in place. ; all in place.
; ;
; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark. ; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark.
; void fast(char *A, char N, char M) { ; void fast(char *A, char N, char M) {
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

test/ScopInfo/zero_ext_of_truncate.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(unsigned *restrict I, unsigned *restrict A, unsigned N, unsigned M) { ; void f(unsigned *restrict I, unsigned *restrict A, unsigned N, unsigned M) {
; for (unsigned i = 0; i < N; i++) { ; for (unsigned i = 0; i < N; i++) {
; unsigned char V = *I; ; unsigned char V = *I;
; if (V < M) ; if (V < M)
; A[i]++; ; A[i]++;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/zero_ext_of_truncate_2.ll

; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting=true \
; RUN: "-passes=print<polly-function-scops>" < %s 2>&1 -aa-pipeline=basic-aa | \
; RUN: FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-scops -analyze \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(unsigned long *restrict I, unsigned *restrict A, unsigned N) { ; void f(unsigned long *restrict I, unsigned *restrict A, unsigned N) {
; for (unsigned i = 0; i < N; i++) { ; for (unsigned i = 0; i < N; i++) {
; unsigned V = *I; ; unsigned V = *I;
; if (V < i) ; if (V < i)
; A[i]++; ; A[i]++;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

test/ScopInfo/zero_ext_space_mismatch.ll

; RUN: opt %loadPolly -disable-output "-passes=print<polly-function-scops>" < \
; RUN: %s 2>&1 -aa-pipeline=basic-aa | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [dim] -> { : dim > 0 } ; CHECK-NEXT: [dim] -> { : dim > 0 }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [dim] -> { : dim < 0 } ; CHECK-NEXT: [dim] -> { : dim < 0 }
; ;
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 22 Lines