This is an archive of the discontinued LLVM Phabricator instance.

Differential D42151

[Polly][ScopBuilder] Make -polly-stmt-granularity=scalar-indep the default.
ClosedPublic

Authored by Meinersbur on Jan 16 2018, 5:01 PM.

Details

Reviewers
grosser
bollu
Commits
rGa43ba2d84f23: [ScopBuilder] Make -polly-stmt-granularity=scalar-indep the default.
rPLO324169: [ScopBuilder] Make -polly-stmt-granularity=scalar-indep the default.
rL324169: [ScopBuilder] Make -polly-stmt-granularity=scalar-indep the default.
Summary

Splitting basic blocks into multiple statements if there are now additional scalar dependencies gives more freedom to the scheduler, but more statements also means higher compile-time complexity. Switch to finer statement granularity, the additional compile time should be limited by the number of operations quota.

Diff Detail

Repository
rL LLVM

Event Timeline

Meinersbur created this revision.Jan 16 2018, 5:01 PM
Meinersbur added parent revisions: D42136: [Polly][ScopBuilder] Revise statement naming when there are multiple statements per BB., D42147: [Polly][ScopBuilder] Prefer PHI Write accesses in the statement the incoming value is defined..
grosser accepted this revision.Jan 16 2018, 11:10 PM

LGTM

This revision is now accepted and ready to land.Jan 16 2018, 11:10 PM
Meinersbur updated this revision to Diff 132726.Feb 2 2018, 9:49 PM

Instead of adding -polly-stmt-granulairy=bb globally, only add the flag to the tests that need it.

This avoids additional discrepancy between Polly's default settings and neew regression tests.

Many differences stem from statements for cmp instructions being created, but then simplified-away because such statments contain no write.

Harbormaster completed remote builds in B14588: Diff 132726.Feb 2 2018, 9:50 PM
Meinersbur added a comment.Feb 2 2018, 10:00 PM

Waiting for confirmation this is ok before committing

grosser added a comment.Feb 2 2018, 10:13 PM

LGTM.

Closed by commit rL324169: [ScopBuilder] Make -polly-stmt-granularity=scalar-indep the default. (authored by Meinersbur). · Explain WhyFeb 2 2018, 11:01 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
polly/
trunk/
lib/
Analysis/
2 lines
test/
DeLICM/
2 lines
2 lines
2 lines
4 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
6 lines
2 lines
2 lines
2 lines
4 lines
DependenceInfo/
6 lines
2 lines
2 lines
ForwardOpTree/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Isl/
Ast/
4 lines
4 lines
CodeGen/
MemAccess/
4 lines
4 lines
2 lines
OpenMP/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
JSONExporter/
ImportArrays/
2 lines
MaximalStaticExpansion/
4 lines
2 lines
2 lines
4 lines
PruneUnprofitable/
2 lines
ScopInfo/
4 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
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 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
2 lines
2 lines
2 lines
4 lines
Simplify/
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

Diff 132732

polly/trunk/lib/Analysis/ScopBuilder.cpp

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Linesstatic cl::opt<GranularityChoice> StmtGranularity(
cl::desc( cl::desc(
"Algorithm to use for splitting basic blocks into multiple statements"), "Algorithm to use for splitting basic blocks into multiple statements"),
cl::values(clEnumValN(GranularityChoice::BasicBlocks, "bb", cl::values(clEnumValN(GranularityChoice::BasicBlocks, "bb",
"One statement per basic block"), "One statement per basic block"),
clEnumValN(GranularityChoice::ScalarIndependence, "scalar-indep", clEnumValN(GranularityChoice::ScalarIndependence, "scalar-indep",
"Scalar independence heuristic"), "Scalar independence heuristic"),
clEnumValN(GranularityChoice::Stores, "store", clEnumValN(GranularityChoice::Stores, "store",
"Store-level granularity")), "Store-level granularity")),
cl::init(GranularityChoice::BasicBlocks), cl::cat(PollyCategory)); cl::init(GranularityChoice::ScalarIndependence), cl::cat(PollyCategory));
void ScopBuilder::buildPHIAccesses(ScopStmt *PHIStmt, PHINode *PHI, void ScopBuilder::buildPHIAccesses(ScopStmt *PHIStmt, PHINode *PHI,
Region *NonAffineSubRegion, Region *NonAffineSubRegion,
bool IsExitBlock) { bool IsExitBlock) {
// PHI nodes that are in the exit block of the region, hence if IsExitBlock is // PHI nodes that are in the exit block of the region, hence if IsExitBlock is
// true, are not modeled as ordinary PHI nodes as they are not part of the // true, are not modeled as ordinary PHI nodes as they are not part of the
// region. However, we model the operands in the predecessor blocks that are // region. However, we model the operands in the predecessor blocks that are
// part of the region as regular scalar accesses. // part of the region as regular scalar accesses.
▲ Show 20 Lines • Show All 1,454 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/map_memset_zero.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck -match-full-lines %s
; ;
; Check that PHI mapping works even in presence of a memset whose' ; Check that PHI mapping works even in presence of a memset whose'
; zero value is used. ; zero value is used.
; ;
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1)
define void @func(i8* noalias nonnull %A) { define void @func(i8* noalias nonnull %A) {
entry: entry:
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/nomap_occupied.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; dummy = A[j]; ; dummy = A[j];
; A[j] = phi; ; A[j] = phi;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction.ll

; RUN: opt %loadPolly -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck -match-full-lines %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_gvnpre.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-partial-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck -check-prefix=PARTIAL %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-partial-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck -check-prefix=PARTIAL %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 116 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_gvnpre_cond1.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Load (but not store) of A[j] hoisted, reduction only over some iterations. ; Load (but not store) of A[j] hoisted, reduction only over some iterations.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
; if (i != 2) ; if (i != 2)
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_gvnpre_cond2.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Load (but not store) of A[j] hoisted, reduction not written in all iterations. ; Load (but not store) of A[j] hoisted, reduction not written in all iterations.
; FIXME: %join is not mapped because the MemoryKind::Value mapping does not ; FIXME: %join is not mapped because the MemoryKind::Value mapping does not
; encompass all iterations (last iteration is unused) ; encompass all iterations (last iteration is unused)
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_gvnpre_nopreheader.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Hosted reduction load (but not the store) without preheader. ; Hosted reduction load (but not the store) without preheader.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
; phi += 4.2; ; phi += 4.2;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_hoisted.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-invariant-load-hoisting -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(int *A, int* StartPtr) { ; void func(int *A, int* StartPtr) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; int Start = *Startptr; ; int Start = *Startptr;
; int phi = Start; ; int phi = Start;
; for (int i = Start; i < 4; i += 1) /* reduction */ ; for (int i = Start; i < 4; i += 1) /* reduction */
; phi += 42; ; phi += 42;
; A[j] = phi; ; A[j] = phi;
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_licm.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = A[j]; ; double phi = A[j];
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_licm2.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm -analyze < %s | FileCheck %s
; ;
; Use %phi instead of the normal %add; that is, the last last iteration will ; Use %phi instead of the normal %add; that is, the last last iteration will
; be ignored such the %phi cannot be written to A[3] in %body. ; be ignored such the %phi cannot be written to A[3] in %body.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi; ; double phi;
; double incoming = A[j]; ; double incoming = A[j];
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_licm_double_write.ll

; RUN: opt %loadPolly -polly-flatten-schedule \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule \
; RUN: -polly-delicm-overapproximate-writes=true \ ; RUN: -polly-delicm-overapproximate-writes=true \
; RUN: -polly-delicm-compute-known=true -polly-delicm \ ; RUN: -polly-delicm-compute-known=true -polly-delicm \
; RUN: -analyze < %s | FileCheck %s ; RUN: -analyze < %s | FileCheck %s
; ;
; Make sure delicm works even in case two stores that store the same value. ; Make sure delicm works even in case two stores that store the same value.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_licm_nopreheader.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s
; ;
; Register-promoted reduction but without preheader. ; Register-promoted reduction but without preheader.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = A[j]; ; double phi = A[j];
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_load.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(int *A, double* StartPtr) { ; void func(int *A, double* StartPtr) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; int phi = *StartPtr; ; int phi = *StartPtr;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_loopguard_gvnpre.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Reduction over parametric number of elements and a loopguard if the ; Reduction over parametric number of elements and a loopguard if the
; reduction loop is not executed at all. Load hoisted before loop. ; reduction loop is not executed at all. Load hoisted before loop.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < n; i += 1) { /* reduction */ ; for (int i = 0; i < n; i += 1) { /* reduction */
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_loopguard_licm1.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Reduction over parametric number of elements and a loopguard if the ; Reduction over parametric number of elements and a loopguard if the
; reduction loop is not executed at all. ; reduction loop is not executed at all.
; Reduction variable promoted to register. ; Reduction variable promoted to register.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = A[j]; ; double phi = A[j];
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_loopguard_licm2.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Reduction over parametric number of elements and a loopguard if the ; Reduction over parametric number of elements and a loopguard if the
; reduction loop is not executed at all, such that A[j] is also not written to. ; reduction loop is not executed at all, such that A[j] is also not written to.
; Reduction variable promoted to register. ; Reduction variable promoted to register.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = A[j]; ; double phi = A[j];
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_loopguard_licm3.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze < %s | FileCheck %s -match-full-lines
; ;
; Reduction over parametric number of elements and a loopguard if the ; Reduction over parametric number of elements and a loopguard if the
; reduction loop is not executed at all, such that A[j] is also not accessed. ; reduction loop is not executed at all, such that A[j] is also not accessed.
; Reduction variable promoted to register. ; Reduction variable promoted to register.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; if (i > 0) { ; if (i > 0) {
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_readonly.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(double *A, double Start) { ; void func(double *A, double Start) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = Start; ; double phi = Start;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_synthesizable.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(int *A) { ; void func(int *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; int phi = j; ; int phi = j;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 42; ; phi += 42;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_looprotate_undef.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s
; ;
; void func(int *A) { ; void func(int *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; int phi; ; int phi;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 42; ; phi += 42;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_overapproximate.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-overapproximate-writes=true -polly-delicm-partial-writes=false -polly-delicm -analyze < %s | FileCheck %s --check-prefix=APPROX ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-overapproximate-writes=true -polly-delicm-partial-writes=false -polly-delicm -analyze < %s | FileCheck %s --check-prefix=APPROX
; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-overapproximate-writes=false -polly-delicm-partial-writes=false -polly-delicm -analyze < %s | FileCheck %s --check-prefix=EXACT ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-overapproximate-writes=false -polly-delicm-partial-writes=false -polly-delicm -analyze < %s | FileCheck %s --check-prefix=EXACT
; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck %s --check-prefix=PARTIAL ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-flatten-schedule -polly-delicm-compute-known=true -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck %s --check-prefix=PARTIAL
; ;
; void func(double *A { ; void func(double *A {
; for (int j = -1; j < 3; j += 1) { /* outer */ ; for (int j = -1; j < 3; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; if (0 < j) ; if (0 < j)
; for (int i = 0; i < j; i += 1) /* reduction */ ; for (int i = 0; i < j; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
▲ Show 20 Lines • Show All 147 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reduction_unrelatedunusual.ll

; RUN: opt %loadPolly -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm-partial-writes=true -polly-delicm -analyze < %s | FileCheck -match-full-lines %s
; ;
; Map %add and %phi to A[j]. ; Map %add and %phi to A[j].
; The non-analyzable store to C[0] is unrelated and can be ignored. ; The non-analyzable store to C[0] is unrelated and can be ignored.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reject_loadafterstore.ll

; RUN: opt %loadPolly -polly-delicm -analyze -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; (void)A[j]; ; (void)A[j];
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reject_storeafterstore.ll

; RUN: opt %loadPolly -polly-delicm -analyze -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = 0.0; ; A[j] = 0.0;
; A[j] = phi; ; A[j] = phi;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/DeLICM/reject_unusualstore.ll

; RUN: opt %loadPolly -polly-delicm -analyze< %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -analyze< %s | FileCheck %s
; RUN: opt %loadPolly -polly-delicm -disable-output -stats < %s 2>&1 | FileCheck %s --check-prefix=STATS ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-delicm -disable-output -stats < %s 2>&1 | FileCheck %s --check-prefix=STATS
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; A[j] = 21.0; ; A[j] = 21.0;
; A[j] = 42.0; ; A[j] = 42.0;
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/fine_grain_dep_0.ll

; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s --check-prefix=REF ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s --check-prefix=REF
; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s --check-prefix=ACC ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s --check-prefix=ACC
; RUN: opt %loadPolly -polly-function-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s --check-prefix=ACC ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-function-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s --check-prefix=ACC
; ;
; REF: RAW dependences: ; REF: RAW dependences:
; REF-NEXT: [N] -> { Stmt_for_body[i0] -> Stmt_for_body[6 + i0] : 0 <= i0 <= -13 + N; Stmt_for_body[i0] -> Stmt_for_body[4 + i0] : 0 <= i0 <= -11 + N; [Stmt_for_body[i0] -> MemRef_a[]] -> [Stmt_for_body[4 + i0] -> MemRef_a[]] : 0 <= i0 <= -11 + N; [Stmt_for_body[i0] -> MemRef_b[]] -> [Stmt_for_body[6 + i0] -> MemRef_b[]] : 0 <= i0 <= -13 + N } ; REF-NEXT: [N] -> { Stmt_for_body[i0] -> Stmt_for_body[6 + i0] : 0 <= i0 <= -13 + N; Stmt_for_body[i0] -> Stmt_for_body[4 + i0] : 0 <= i0 <= -11 + N; [Stmt_for_body[i0] -> MemRef_a[]] -> [Stmt_for_body[4 + i0] -> MemRef_a[]] : 0 <= i0 <= -11 + N; [Stmt_for_body[i0] -> MemRef_b[]] -> [Stmt_for_body[6 + i0] -> MemRef_b[]] : 0 <= i0 <= -13 + N }
; REF-NEXT: WAR dependences: ; REF-NEXT: WAR dependences:
; REF-NEXT: { } ; REF-NEXT: { }
; REF-NEXT: WAW dependences: ; REF-NEXT: WAW dependences:
; REF-NEXT: { } ; REF-NEXT: { }
; REF-NEXT: Reduction dependences: ; REF-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_dependences_equal_non_reduction_dependences.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-dependences -analyze < %s | FileCheck %s
; ;
; This loopnest contains a reduction which imposes the same dependences as the ; This loopnest contains a reduction which imposes the same dependences as the
; accesses to the array A. We need to ensure we keep the dependences of A. ; accesses to the array A. We need to ensure we keep the dependences of A.
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : 0 <= i0 <= 1022 } ; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : 0 <= i0 <= 1022 }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : 0 <= i0 <= 1022 } ; CHECK-NEXT: { Stmt_for_body[i0] -> Stmt_for_body[1 + i0] : 0 <= i0 <= 1022 }
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/trunk/test/DependenceInfo/reduction_two_reductions_different_rloops.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/atax.ll

; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines
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 internal fastcc void @kernel_atax([2100 x double]* nocapture readonly %A, double* nocapture readonly %x, double* nocapture %y, double* nocapture %tmp) unnamed_addr #0 { define internal fastcc void @kernel_atax([2100 x double]* nocapture readonly %A, double* nocapture readonly %x, double* nocapture %y, double* nocapture %tmp) unnamed_addr #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/forward_load_differentarray.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree -analyze < %s | FileCheck %s -match-full-lines
; ;
; To forward %val, B[j] cannot be reused in bodyC because it is overwritten ; To forward %val, B[j] cannot be reused in bodyC because it is overwritten
; between. Verify that instead the alternative C[j] is used. ; between. Verify that instead the alternative C[j] is used.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/forward_load_double_write.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree -analyze < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load even in case two writes of identical values are in ; Rematerialize a load even in case two writes of identical values are in
; one scop statement. ; one scop statement.
; ;
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/forward_load_fromloop.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree -analyze < %s | FileCheck %s -match-full-lines
; ;
; Forward a the LoadInst %val into %bodyB. %val is executed multiple times, ; Forward a the LoadInst %val into %bodyB. %val is executed multiple times,
; we must get the last loaded values. ; we must get the last loaded values.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double val; ; double val;
; for (int i = 0; i < n; i += 1) { ; for (int i = 0; i < n; i += 1) {
; bodyA: ; bodyA:
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/forward_load_tripleuse.ll

; RUN: opt %loadPolly -polly-optree -polly-codegen -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree -polly-codegen -analyze < %s | FileCheck %s -match-full-lines
; ;
; %val1 is used three times: Twice by its own operand tree of %val2 and once ; %val1 is used three times: Twice by its own operand tree of %val2 and once
; more by the store in %bodyB. ; more by the store in %bodyB.
; Verify that we can handle multiple uses by the same instruction and uses ; Verify that we can handle multiple uses by the same instruction and uses
; in multiple statements as well. ; in multiple statements as well.
; The result processing may depend on the order in which the values are used, ; The result processing may depend on the order in which the values are used,
; hence we check both orderings. ; hence we check both orderings.
; ;
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines

polly/trunk/test/ForwardOpTree/jacobi-1d.ll

; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines
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 internal fastcc void @kernel_jacobi_1d(double* noalias nocapture %A, double* noalias nocapture %B) unnamed_addr #0 { define internal fastcc void @kernel_jacobi_1d(double* noalias nocapture %A, double* noalias nocapture %B) unnamed_addr #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/trunk/test/Isl/Ast/dependence_distance_multiple_constant.ll

; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO
; ;
; void f(int *restrict A, int *restrict B, int N) { ; void f(int *restrict A, int *restrict B, int N) {
; CHECK: #pragma minimal dependence distance: 5 ; CHECK: #pragma minimal dependence distance: 5
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; A[i + 7] = A[i] + 1; ; A[i + 7] = A[i] + 1;
; B[i + 5] = B[i] + 1; ; B[i + 5] = B[i] + 1;
; } ; }
Show All 35 Lines

polly/trunk/test/Isl/Ast/dependence_distance_varying_multiple.ll

; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO
; ;
; void f(int *restrict A, int *restrict B, int *restrict C, int *restrict D, ; void f(int *restrict A, int *restrict B, int *restrict C, int *restrict D,
; int *restrict E, int N) { ; int *restrict E, int N) {
; CHECK: #pragma minimal dependence distance: N >= 35 ? 1 : N >= 17 && N <= 34 ? 2 : 5 ; CHECK: #pragma minimal dependence distance: N >= 35 ? 1 : N >= 17 && N <= 34 ? 2 : 5
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; A[i] = A[100 - 2 * i] + 1; ; A[i] = A[100 - 2 * i] + 1;
; B[i] = B[100 - 3 * i] + 1; ; B[i] = B[100 - 3 * i] + 1;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/MemAccess/create_arrays_heap.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; #define Ni 1056 ; #define Ni 1056
; #define Nj 1056 ; #define Nj 1056
; #define Nk 1024 ; #define Nk 1024
; ;
; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) { ; void create_arrays_heap(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
; int i,j,k; ; int i,j,k;
; ;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/MemAccess/map_scalar_access.ll

; RUN: opt %loadPolly -polly-import-jscop-postfix=transformed -polly-import-jscop -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-import-jscop -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop-postfix=transformed -polly-import-jscop -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop-postfix=transformed -polly-import-jscop -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
define void @map_scalar_access(double* noalias nonnull %A) { define void @map_scalar_access(double* noalias nonnull %A) {
entry: entry:
br label %outer.for br label %outer.for
outer.for: outer.for:
%j = phi i32 [0, %entry], [%j.inc, %outer.inc] %j = phi i32 [0, %entry], [%j.inc, %outer.inc]
%j.cmp = icmp slt i32 %j, 1 %j.cmp = icmp slt i32 %j, 1
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/MemAccess/multiple_types.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -polly-codegen -S < %s | FileCheck %s ; RUN: -polly-codegen -S < %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 62 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/OpenMP/mapped-phi-access.ll

; RUN: opt %loadPolly -polly-parallel -polly-delicm -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-parallel -polly-delicm -polly-codegen -S < %s | FileCheck %s
; ;
; Verify that -polly-parallel can handle mapped scalar MemoryAccesses. ; Verify that -polly-parallel can handle mapped scalar MemoryAccesses.
; ;
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 @main() local_unnamed_addr #0 { define void @main() local_unnamed_addr #0 {
entry: entry:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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]]
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 35 Lines

polly/trunk/test/Isl/CodeGen/partial_write_impossible_restriction.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s
; ;
; The isl scheduler isolates %cond.false into two instances. ; The isl scheduler isolates %cond.false into two instances.
; A partial write access in one of the instances was never executed, ; A partial write access in one of the instances was never executed,
; which caused problems when querying for its index expression, which ; which caused problems when querying for its index expression, which
; is not available in that case. ; is not available in that case.
; ;
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"
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/partial_write_mapped_scalar.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s | FileCheck %s
; ;
; Partial write of a (mapped) scalar. ; Partial write of a (mapped) scalar.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
;body: ;body:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
; if (j >= 5) ; if (j >= 5)
;user: ;user:
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/partial_write_mapped_vector.ll

; RUN: opt %loadPolly -basicaa -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-vectorizer=polly -polly-opt-isl -polly-ast -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -basicaa -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-vectorizer=polly -polly-opt-isl -polly-ast -polly-codegen -S < %s | FileCheck %s
; ;
; Polly's vectorizer does not support partial accesses. ; Polly's vectorizer does not support partial accesses.
; ;
; for (int j = 0; j < 4; j += 1) { ; for (int j = 0; j < 4; j += 1) {
;body: ;body:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
; if (j > 1) ; if (j > 1)
;user: ;user:
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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-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 50 Lines • Show Last 20 Lines

polly/trunk/test/JSONExporter/ImportArrays/ImportArrays-Negative-size.ll

; RUN: not opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: not opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s
; ;
; #define Ni 1056 ; #define Ni 1056
; #define Nj 1056 ; #define Nj 1056
; #define Nk 1024 ; #define Nk 1024
; ;
; void ImportArray_Negative_size(double beta, double A[Ni][Nk], double B[Ni][Nj]) { ; void ImportArray_Negative_size(double beta, double A[Ni][Nk], double B[Ni][Nj]) {
; int i,j,k; ; int i,j,k;
; ;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/trunk/test/MaximalStaticExpansion/load_after_store_same_statement.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1| FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1| FileCheck %s --check-prefix=MSE
; ;
; Verify that the expansion of an array with load after store in a same statement is not done. ; Verify that the expansion of an array with load after store in a same statement is not done.
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/MaximalStaticExpansion/working_expansion_multiple_dependences_per_statement.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -analyze < %s | FileCheck %s
; ;
; Verify that the accesses are correctly expanded ; Verify that the accesses are correctly expanded
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

polly/trunk/test/MaximalStaticExpansion/working_expansion_multiple_instruction_per_statement.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -analyze < %s | FileCheck %s
; ;
; Verify that the accesses are correctly expanded ; Verify that the accesses are correctly expanded
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/trunk/test/MaximalStaticExpansion/working_phi_two_scalars.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1 | FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1 | FileCheck %s --check-prefix=MSE
; ;
; Verify that the accesses are correctly expanded for MemoryKind::PHI ; Verify that the accesses are correctly expanded for MemoryKind::PHI
; tmp_05 and tmp2_06 are not expanded because they need copy-in. ; tmp_05 and tmp2_06 are not expanded because they need copy-in.
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 10000 ; #define Ni 10000
; #define Nj 10000 ; #define Nj 10000
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

polly/trunk/test/PruneUnprofitable/prune_only_scalardeps.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-prune-unprofitable -disable-output -stats < %s 2>&1 | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-prune-unprofitable -disable-output -stats < %s 2>&1 | FileCheck -match-full-lines %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; Skip this SCoP for having scalar dependencies between all statements, ; Skip this SCoP for having scalar dependencies between all statements,
; but only after ScopInfo (because optimization passes using ScopInfo such ; but only after ScopInfo (because optimization passes using ScopInfo such
; as DeLICM might remove these scalar dependencies). ; as DeLICM might remove these scalar dependencies).
; ;
; double x = 0; ; double x = 0;
; for (int i = 0; i < n; i += 1) ; for (int i = 0; i < n; i += 1)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | \
; RUN: FileCheck %s -check-prefix=NONAFFINE ; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -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 :=
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/condition-after-error-block-2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; Verify that we do not allow PHI nodes such as %phi, if they reference an error ; Verify that we do not allow PHI nodes such as %phi, if they reference an error
; block and are used by anything else than a terminator instruction. ; block and are used by anything else than a terminator instruction.
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_loop ; CHECK-NEXT: Stmt_loop
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p] -> { Stmt_loop[i0] : p >= 13 and 0 <= i0 <= 1025 }; ; CHECK-NEXT: [p] -> { Stmt_loop[i0] : p >= 13 and 0 <= i0 <= 1025 };
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/condtion-after-error-block.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; Verify that we allow scops containing uniform branch conditions, where all ; Verify that we allow scops containing uniform branch conditions, where all
; but one incoming block comes from an error condition. ; but one incoming block comes from an error condition.
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_A ; CHECK-NEXT: Stmt_A
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p] -> { Stmt_A[] }; ; CHECK-NEXT: [p] -> { Stmt_A[] };
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/const_srem_sdiv.ll

; RUN: opt %loadPolly -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];
; A[8 / -3] = A[8 % -3]; ; A[8 / -3] = A[8 % -3];
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/constant_functions_multi_dim.ll

; RUN: opt %loadPolly -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 :=
; CHECK-NEXT: [N, __global_id_0, __global_id_1] -> { Stmt_entry_split[] }; ; CHECK-NEXT: [N, __global_id_0, __global_id_1] -> { Stmt_entry_split[] };
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/escaping_empty_scop.ll

; RUN: opt %loadPolly -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
; A[0] = i; ; A[0] = i;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/exit-phi-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -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
; ;
; CHECK: Arrays { ; CHECK: Arrays {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/exit-phi-2.ll

; RUN: opt %loadPolly -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:
%0 = load i64, i64* undef, align 8 %0 = load i64, i64* undef, align 8
Show All 33 Lines

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

; RUN: opt %loadPolly -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 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
Show All 39 Lines

polly/trunk/test/ScopInfo/invariant_load_complex_condition.ll

; RUN: opt %loadPolly -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 }
%struct.D = type { i32 } %struct.D = type { i32 }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/loop_carry.ll

; RUN: opt %loadPolly -basicaa -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) {
; a[i] = k * a[i - 1]; ; a[i] = k * a[i - 1];
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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++) {
; if (k == 0) ; if (k == 0)
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/mod_ref_access_pointee_arguments.ll

; RUN: opt %loadPolly -basicaa -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 -basicaa -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 };
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/mod_ref_read_pointee_arguments.ll

; RUN: opt %loadPolly -basicaa -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 -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
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_2d_with_modref_call.ll

; RUN: opt %loadPolly -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-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
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_2d_with_modref_call_2.ll

; RUN: opt %loadPolly -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-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
; CHECK-NEXT: Region: %bb12---%bb28 ; CHECK-NEXT: Region: %bb12---%bb28
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_fixedsize_multi_offset.ll

; RUN: opt %loadPolly -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: { : 1 = 0 } ; CHECK-NEXT: { : 1 = 0 }
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_fold_constant_dim_zero.ll

; RUN: opt %loadPolly -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
; invalidated due to the zero size dimension. ; invalidated due to the zero size dimension.
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_fortran_2d_with_modref_call.ll

; RUN: opt %loadPolly -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-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
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_fortran_srem.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-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 :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> [i0, 0, 0, 0] }; ; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> [i0, 0, 0, 0] };
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_nested_start_share_parameter.ll

; RUN: opt %loadPolly -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++) {
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_with_bitcast.ll

; RUN: opt %loadPolly -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]
; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] ; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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
; ;
; // 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];
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; 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-allow-differing-element-types -polly-codegen -polly-allow-nonaffine -analyze ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-codegen -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

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

; RUN: opt %loadPolly -polly-allow-differing-element-types -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; 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-allow-differing-element-types -polly-codegen -polly-allow-nonaffine -analyze ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-allow-differing-element-types -polly-codegen -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

polly/trunk/test/ScopInfo/multiple-types.ll

; RUN: opt %loadPolly -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];
; Double[i] = *(double *)&Double[8 * i]; ; Double[i] = *(double *)&Double[8 * i];
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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-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
; CHECK: Domain := ; CHECK: Domain :=
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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() {
bb: bb:
Show All 26 Lines

polly/trunk/test/ScopInfo/parameter-constant-division.ll

; RUN: opt %loadPolly -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]
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_after_error_block.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s
declare void @bar() declare void @bar()
define void @foo(float* %A, i64 %p) { define void @foo(float* %A, i64 %p) {
start: start:
br label %next br label %next
next: next:
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -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 134 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-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
; CHECK-NEXT: float* MemRef_x__phi; // Element size 8 ; CHECK-NEXT: float* MemRef_x__phi; // Element size 8
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/process_added_dimensions.ll

; RUN: opt %loadPolly -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: { : 1 = 0 } ; CHECK-NEXT: { : 1 = 0 }
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -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-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
; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
Show All 28 Lines

polly/trunk/test/ScopInfo/reduction_disabled_multiplicative.ll

; RUN: opt -basicaa %loadPolly -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] };
; CHECK: MustWriteAccess := [Reduction Type: NONE ; CHECK: MustWriteAccess := [Reduction Type: NONE
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_escaping_intermediate_2.ll

; RUN: opt %loadPolly -basicaa -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 63 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_invalid_overlapping_accesses.ll

; RUN: opt %loadPolly -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 50 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_multiple_simple_binary.ll

; RUN: opt -basicaa %loadPolly -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] };
; CHECK: ReadAccess := [Reduction Type: + ; CHECK: ReadAccess := [Reduction Type: +
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/stmt_split_phi_in_stmt.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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, 0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/stmt_split_scalar_dependence.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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, 0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/stmt_split_within_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -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, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 512 }; ; CHECK-NEXT: { Stmt_Stmt[i0, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 512 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Stmt[i0, i1] -> [i0, i1, 0] }; ; CHECK-NEXT: { Stmt_Stmt[i0, i1] -> [i0, i1, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/unpredictable_nonscop_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s -match-full-lines
; Derived from test-suite/MultiSource/Applications/sgefa/blas.c ; Derived from test-suite/MultiSource/Applications/sgefa/blas.c
; ;
; The exit value of %i.0320 in land.rhs is not computable. ; The exit value of %i.0320 in land.rhs is not computable.
; It is still synthesizable in %if.end13---%for.end170 because ; It is still synthesizable in %if.end13---%for.end170 because
; %i.0320 is fixed within the SCoP and therefore just another parameter. ; %i.0320 is fixed within the SCoP and therefore just another parameter.
; ;
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

polly/trunk/test/ScopInfo/unprofitable_scalar-accs.ll

; RUN: opt %loadPolly -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-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:
br label %outer.for br label %outer.for
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/coalesce_3partials.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Combine 3 partial accesses into one. ; Combine 3 partial accesses into one.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; A[0] = 42.0; ; A[0] = 42.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
Show All 39 Lines

polly/trunk/test/Simplify/coalesce_disjointelements.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Combine four partial stores into two. ; Combine four partial stores into two.
; The stores write to the same array, but never the same element. ; The stores write to the same array, but never the same element.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 21.0; ; A[0] = 21.0;
; A[1] = 42.0; ; A[1] = 42.0;
; A[0] = 21.0; ; A[0] = 21.0;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/coalesce_overlapping.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Combine two partial stores (with overlapping domains) into one. ; Combine two partial stores (with overlapping domains) into one.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
; ;
Show All 37 Lines

polly/trunk/test/Simplify/coalesce_partial.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Combine two partial stores (with disjoint domains) into one. ; Combine two partial stores (with disjoint domains) into one.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
; ;
Show All 37 Lines

polly/trunk/test/Simplify/dead_access_load.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
; ;
; Remove a dead load-instruction ; Remove a dead load-instruction
; (an load whose result is not used anywhere) ; (an load whose result is not used anywhere)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double val = A[0]; ; double val = A[0];
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
Show All 37 Lines

polly/trunk/test/Simplify/dead_access_phi.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
; ;
; Remove a dead PHI write/read pair ; Remove a dead PHI write/read pair
; (accesses that are effectively not used) ; (accesses that are effectively not used)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; double phi = 42; ; double phi = 42;
; ;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/dead_access_value.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
; ;
; Remove a dead value write/read pair ; Remove a dead value write/read pair
; (accesses that are effectively not used) ; (accesses that are effectively not used)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; double val = 12.5 + 12.5; ; double val = 12.5 + 12.5;
; ;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/dead_instruction.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
; ;
; Remove a dead instruction ; Remove a dead instruction
; (an instruction whose result is not used anywhere) ; (an instruction whose result is not used anywhere)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double val = 21.0 + 21.0; ; double val = 21.0 + 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
Show All 30 Lines

polly/trunk/test/Simplify/nocoalesce_differentvalues.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Do not combine stores that write different values. ; Do not combine stores that write different values.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 21.0; ; A[0] = 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
; ;
Show All 32 Lines

polly/trunk/test/Simplify/nocoalesce_elementmismatch.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Do not combine stores that do not write to different elements in the ; Do not combine stores that do not write to different elements in the
; same instance. ; same instance.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 21.0; ; A[0] = 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
Show All 30 Lines

polly/trunk/test/Simplify/nocoalesce_readbetween.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Do not combine stores if there is a read between them. ; Do not combine stores if there is a read between them.
; Note: The read between is unused, so will be removed by markAndSweep. ; Note: The read between is unused, so will be removed by markAndSweep.
; However, searches for coalesces takes place before. ; However, searches for coalesces takes place before.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; tmp = A[0]; ; tmp = A[0];
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/nocoalesce_writebetween.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Do not combine stores if there is a write between them. ; Do not combine stores if there is a write between them.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; A[0] = 21.0; ; A[0] = 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
Show All 29 Lines

polly/trunk/test/Simplify/notredundant_synthesizable_unknownit.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines
; ;
; Do not remove the scalar value write of %i.trunc in inner.for. ; Do not remove the scalar value write of %i.trunc in inner.for.
; It is used by body. ; It is used by body.
; %i.trunc is synthesizable in inner.for, so some code might think it is ; %i.trunc is synthesizable in inner.for, so some code might think it is
; synthesizable everywhere such that no scalar write would be needed. ; synthesizable everywhere such that no scalar write would be needed.
; ;
; Note that -polly-simplify rightfully removes %inner.cond. It should ; Note that -polly-simplify rightfully removes %inner.cond. It should
; not have been added to the instruction list in the first place. ; not have been added to the instruction list in the first place.
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/trunk/test/Simplify/out-of-scop-use-in-region-entry-phi-node.ll

; RUN: opt %loadPolly -polly-scops -polly-simplify -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -polly-simplify -analyze < %s | FileCheck %s
; ;
; %tmp5 must keep the Value WRITE MemoryAccess, because as an incoming value of ; %tmp5 must keep the Value WRITE MemoryAccess, because as an incoming value of
; %tmp4, it is an "external use". ; %tmp4, it is an "external use".
; ;
; A common mistake is to assume that %tmp5 is used by %tmp4 in bb3, when ; A common mistake is to assume that %tmp5 is used by %tmp4 in bb3, when
; practially it's the incoming block %bb9 which is the user. ; practially it's the incoming block %bb9 which is the user.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 35 Lines

polly/trunk/test/Simplify/overwritten.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Remove a store that is overwritten by another store in the same statement. ; Remove a store that is overwritten by another store in the same statement.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 21.0; ; A[0] = 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
; ;
Show All 35 Lines

polly/trunk/test/Simplify/overwritten_3store.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck -match-full-lines %s
; ;
; Remove a store that is overwritten by another store in the same statement. ; Remove a store that is overwritten by another store in the same statement.
; Check that even multiple stores are removed. ; Check that even multiple stores are removed.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 10.5; ; A[0] = 10.5;
; A[0] = 21.0; ; A[0] = 21.0;
; A[0] = 42.0; ; A[0] = 42.0;
Show All 38 Lines