This is an archive of the discontinued LLVM Phabricator instance.

Differential D7735

ScopDetection: Only detect scops that have at least one read and one write
ClosedPublic

Authored by grosser on Feb 18 2015, 1:12 PM.

Details

Reviewers
sebpop
simbuerg
dpeixott
jdoerfert
Commits
rGd1e33e706112: ScopDetection: Only detect scops that have at least one read and one write
rPLO229820: ScopDetection: Only detect scops that have at least one read and one write
rL229820: ScopDetection: Only detect scops that have at least one read and one write
Summary

Scops that only read seem generally uninteresting and scops that only write are
most likely initializations where there is also little to optimize. To not
waste compile time we bail early.

Diff Detail

Repository
rL LLVM

Event Timeline

grosser updated this revision to Diff 20215.Feb 18 2015, 1:12 PM
grosser retitled this revision from to ScopDetection: Only detect scops that have at least one read and one write.
grosser updated this object.
grosser edited the test plan for this revision. (Show Details)
grosser added reviewers: jdoerfert, sebpop, dpeixott, simbuerg.
grosser added a subscriber: Unknown Object (MLST).
sebpop edited edge metadata.Feb 18 2015, 6:00 PM

Good catch to speed up compile time.
LGTM.

lib/Analysis/ScopDetection.cpp
881 ↗(On Diff #20215)

I always questioned the necessity of double negatives: "not unprofitable" = "profitable".
I find "profitable" easier to read.

Closed by commit rL229820: ScopDetection: Only detect scops that have at least one read and one write (authored by grosser). · Explain WhyFeb 18 2015, 9:33 PM
This revision was automatically updated to reflect the committed changes.
grosser added inline comments.Feb 18 2015, 9:44 PM
lib/Analysis/ScopDetection.cpp
881 ↗(On Diff #20215)

Yes, the alternative would be to call this only-profitable, but then the option would need to be '-polly-detect-only-profitable=false', which seems rather long to me.

For now, I left it as it is. Please feel free to suggest a better option.

jdoerfert edited edge metadata.Feb 19 2015, 6:22 AM

Hey Tobias,

do you kow how much we actually gain by your change? Why shouldn't we
keep (and delete) SCoPs that have no stores (or at least delete the
loads and let the other passes delete the rest)? Why shouldn't we look at
generating memset intrinsics for loops that only write?

Regarding the patch, could you please comment your member variables
(even though it's pretty obvious).

  • Johannes

Revision Contents

PathSize
polly/
trunk/
include/
polly/
6 lines
19 lines
lib/
Analysis/
15 lines
12 lines
test/
CodePreparation/
4 lines
2 lines
2 lines
DeadCodeElimination/
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
Dependences/
4 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
2 lines
2 lines
2 lines
2 lines
4 lines
IndependentBlocks/
8 lines
8 lines
8 lines
4 lines
8 lines
2 lines
Isl/
Ast/
OpenMP/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
10 lines
10 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
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
4 lines
CodeGen/
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
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
LoopParallelMD/
2 lines
2 lines
4 lines
MemAccess/
2 lines
2 lines
2 lines
2 lines
8 lines
8 lines
2 lines
2 lines
4 lines
2 lines
OpenMP/
4 lines
4 lines
6 lines
6 lines
6 lines
2 lines
4 lines
14 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
4 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
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
4 lines
6 lines
4 lines
2 lines
2 lines
ScheduleOptimizer/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
ScopDetect/
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
ScopDetectionDiagnostics/
2 lines
2 lines
2 lines
2 lines
12 lines
2 lines
128 lines
2 lines
ScopInfo/
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
NonAffine/
2 lines
2 lines
2 lines
2 lines
4 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
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
8 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
TempScop/
4 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines

Diff 20258

polly/trunk/include/polly/ScopDetection.h

Show First 20 Lines • Show All 150 Lines • ▼ Show 20 Lines struct DetectionContext {
/// @brief The set of base pointers with non-affine accesses. /// @brief The set of base pointers with non-affine accesses.
/// ///
/// This set contains all base pointers which are used in memory accesses /// This set contains all base pointers which are used in memory accesses
/// that can not be detected as affine accesses. /// that can not be detected as affine accesses.
SetVector<const SCEVUnknown *> NonAffineAccesses; SetVector<const SCEVUnknown *> NonAffineAccesses;
BaseToElSize ElementSize; BaseToElSize ElementSize;
bool hasLoads;
bool hasStores;
DetectionContext(Region &R, AliasAnalysis &AA, bool Verify) DetectionContext(Region &R, AliasAnalysis &AA, bool Verify)
: CurRegion(R), AST(AA), Verifying(Verify), Log(&R) {} : CurRegion(R), AST(AA), Verifying(Verify), Log(&R), hasLoads(false),
hasStores(false) {}
}; };
// Remember the valid regions // Remember the valid regions
RegionSet ValidRegions; RegionSet ValidRegions;
// Remember a list of errors for every region. // Remember a list of errors for every region.
mutable RejectLogsContainer RejectLogs; mutable RejectLogsContainer RejectLogs;
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

polly/trunk/include/polly/ScopDetectionDiagnostic.h

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesenum RejectReasonKind {
// Other // Other
rrkOther, rrkOther,
rrkIntToPtr, rrkIntToPtr,
rrkAlloca, rrkAlloca,
rrkUnknownInst, rrkUnknownInst,
rrkPHIinExit, rrkPHIinExit,
rrkEntry, rrkEntry,
rrkUnprofitable,
rrkLastOther rrkLastOther
}; };
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// @brief Base class of all reject reasons found during Scop detection. /// @brief Base class of all reject reasons found during Scop detection.
/// ///
/// Subclasses of RejectReason should provide means to capture enough /// Subclasses of RejectReason should provide means to capture enough
/// diagnostic information to help clients figure out what and where something /// diagnostic information to help clients figure out what and where something
▲ Show 20 Lines • Show All 703 Lines • ▼ Show 20 Linespublic:
/// @name RejectReason interface /// @name RejectReason interface
//@{ //@{
virtual std::string getMessage() const override; virtual std::string getMessage() const override;
virtual const DebugLoc &getDebugLoc() const override; virtual const DebugLoc &getDebugLoc() const override;
//@} //@}
}; };
//===----------------------------------------------------------------------===//
/// @brief Report regions that seem not profitable to be optimized.
class ReportUnprofitable : public ReportOther {
//===--------------------------------------------------------------------===//
public:
ReportUnprofitable();
/// @name LLVM-RTTI interface
//@{
static bool classof(const RejectReason *RR);
//@}
/// @name RejectReason interface
//@{
virtual std::string getMessage() const override;
//@}
};
} // namespace polly } // namespace polly
#endif // POLLY_SCOP_DETECTION_DIAGNOSTIC_H #endif // POLLY_SCOP_DETECTION_DIAGNOSTIC_H

polly/trunk/lib/Analysis/ScopDetection.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines DetectScopsWithoutLoops("polly-detect-scops-in-functions-without-loops",
cl::cat(PollyCategory)); cl::cat(PollyCategory));
static cl::opt<bool> static cl::opt<bool>
DetectRegionsWithoutLoops("polly-detect-scops-in-regions-without-loops", DetectRegionsWithoutLoops("polly-detect-scops-in-regions-without-loops",
cl::desc("Detect scops in regions without loops"), cl::desc("Detect scops in regions without loops"),
cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::init(false), cl::ZeroOrMore,
cl::cat(PollyCategory)); cl::cat(PollyCategory));
static cl::opt<bool> DetectUnprofitable("polly-detect-unprofitable",
cl::desc("Detect unprofitable scops"),
cl::Hidden, cl::init(false),
cl::ZeroOrMore, cl::cat(PollyCategory));
static cl::opt<std::string> OnlyFunction( static cl::opt<std::string> OnlyFunction(
"polly-only-func", "polly-only-func",
cl::desc("Only run on functions that contain a certain string"), cl::desc("Only run on functions that contain a certain string"),
cl::value_desc("string"), cl::ValueRequired, cl::init(""), cl::value_desc("string"), cl::ValueRequired, cl::init(""),
cl::cat(PollyCategory)); cl::cat(PollyCategory));
static cl::opt<std::string> OnlyRegion( static cl::opt<std::string> OnlyRegion(
"polly-only-region", "polly-only-region",
▲ Show 20 Lines • Show All 523 Lines • ▼ Show 20 Linesbool ScopDetection::isValidInstruction(Instruction &Inst,
if (!Inst.mayWriteToMemory() && !Inst.mayReadFromMemory()) { if (!Inst.mayWriteToMemory() && !Inst.mayReadFromMemory()) {
if (!isa<AllocaInst>(Inst)) if (!isa<AllocaInst>(Inst))
return true; return true;
return invalid<ReportAlloca>(Context, /*Assert=*/true, &Inst); return invalid<ReportAlloca>(Context, /*Assert=*/true, &Inst);
} }
// Check the access function. // Check the access function.
if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst)) if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst)) {
Context.hasStores |= isa<StoreInst>(Inst);
Context.hasLoads |= isa<LoadInst>(Inst);
return isValidMemoryAccess(Inst, Context); return isValidMemoryAccess(Inst, Context);
}
// We do not know this instruction, therefore we assume it is invalid. // We do not know this instruction, therefore we assume it is invalid.
return invalid<ReportUnknownInst>(Context, /*Assert=*/true, &Inst); return invalid<ReportUnknownInst>(Context, /*Assert=*/true, &Inst);
} }
bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const { bool ScopDetection::isValidLoop(Loop *L, DetectionContext &Context) const {
// Is the loop count affine? // Is the loop count affine?
const SCEV *LoopCount = SE->getBackedgeTakenCount(L); const SCEV *LoopCount = SE->getBackedgeTakenCount(L);
▲ Show 20 Lines • Show All 227 Lines • ▼ Show 20 Lines if (R.getEntry() == &(R.getEntry()->getParent()->getEntryBlock()))
return invalid<ReportEntry>(Context, /*Assert=*/true, R.getEntry()); return invalid<ReportEntry>(Context, /*Assert=*/true, R.getEntry());
if (!isValidExit(Context)) if (!isValidExit(Context))
return false; return false;
if (!allBlocksValid(Context)) if (!allBlocksValid(Context))
return false; return false;
// We can probably not do a lot on scops that only write or only read
// data.
if (!DetectUnprofitable && (!Context.hasStores || !Context.hasLoads))
invalid<ReportUnprofitable>(Context, /*Assert=*/true);
DEBUG(dbgs() << "OK\n"); DEBUG(dbgs() << "OK\n");
return true; return true;
} }
void ScopDetection::markFunctionAsInvalid(Function *F) const { void ScopDetection::markFunctionAsInvalid(Function *F) const {
F->addFnAttr(PollySkipFnAttr); F->addFnAttr(PollySkipFnAttr);
} }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp

Show First 20 Lines • Show All 585 Lines • ▼ Show 20 Lines
const DebugLoc &ReportEntry::getDebugLoc() const { const DebugLoc &ReportEntry::getDebugLoc() const {
return BB->getTerminator()->getDebugLoc(); return BB->getTerminator()->getDebugLoc();
} }
bool ReportEntry::classof(const RejectReason *RR) { bool ReportEntry::classof(const RejectReason *RR) {
return RR->getKind() == rrkEntry; return RR->getKind() == rrkEntry;
} }
//===----------------------------------------------------------------------===//
// ReportUnprofitable.
ReportUnprofitable::ReportUnprofitable() : ReportOther(rrkUnprofitable) {}
std::string ReportUnprofitable::getMessage() const {
return "Region can not profitably be optimized!";
}
bool ReportUnprofitable::classof(const RejectReason *RR) {
return RR->getKind() == rrkUnprofitable;
}
} // namespace polly } // namespace polly

polly/trunk/test/CodePreparation/if_condition.ll

; RUN: opt %loadPolly -polly-prepare -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-prepare -S < %s | FileCheck %s
; RUN: opt %loadPolly -polly-prepare -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-prepare -S < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/CodePreparation/multiple_loops_trivial_phis.ll

; RUN: opt %loadPolly -S -polly-prepare < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-prepare < %s | FileCheck %s
; ModuleID = 'multiple_loops_trivial_phis.ll' ; ModuleID = 'multiple_loops_trivial_phis.ll'
; ;
; int f(int * __restrict__ A) { ; int f(int * __restrict__ A) {
; int i, j, sum = 0; ; int i, j, sum = 0;
; for (i = 0; i < 100; i++) { ; for (i = 0; i < 100; i++) {
; sum *= 2; ; sum *= 2;
; for (j = 0; j < 100; j++) { ; for (j = 0; j < 100; j++) {
; sum += A[i+j]; ; sum += A[i+j];
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/trunk/test/CodePreparation/single_loop_trivial_phi.ll

; RUN: opt %loadPolly -S -polly-prepare < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-prepare < %s | FileCheck %s
; ModuleID = 'single_loop_trivial_phi.ll' ; ModuleID = 'single_loop_trivial_phi.ll'
; ;
; int f(int *A, int N) { ; int f(int *A, int N) {
; int i, sum = 0; ; int i, sum = 0;
; for (i = 0; i < N; i++) ; for (i = 0; i < N; i++)
; sum += A[i]; ; sum += A[i];
; return sum; ; return sum;
; } ; }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/chained_iterations.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; ;
; for(i = 0; i < 200; i++ ) ; for(i = 0; i < 200; i++ )
; A[i] = 2; ; A[i] = 2;
; ;
; for (i = 0; i < 200; i++ ) ; for (i = 0; i < 200; i++ )
; A[i] = 5; ; A[i] = 5;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/chained_iterations_2.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; ;
; for(i = 0; i < 200; i++ ) ; for(i = 0; i < 200; i++ )
; A[i] = 2; ; A[i] = 2;
; ;
; for (i = 0; i < 200; i++ ) ; for (i = 0; i < 200; i++ )
; B[i] = A[i]; ; B[i] = A[i];
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/computeout.ll

; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; RUN: opt -S %loadPolly -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dce -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/dead_iteration_elimination.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; ;
; for(i = 0; i < 200; i++ ) ; for(i = 0; i < 200; i++ )
; A[i] = 2; ; A[i] = 2;
; ;
; for (i = 0; i < 50; i++ ) ; for (i = 0; i < 50; i++ )
; A[i] = 5; ; A[i] = 5;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/non-affine-affine-mix.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S1: A[i % 2] = i; ; S1: A[i % 2] = i;
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; S2: A[i2] = i; ; S2: A[i2] = i;
; } ; }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/DeadCodeElimination/non-affine.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-allow-nonaffine -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; ;
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i % 2] = i; ; A[i % 2] = i;
; } ; }
; ;
Show All 25 Lines

polly/trunk/test/DeadCodeElimination/null_schedule.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-DCE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; A[0] = 1; ; A[0] = 1;
; ;
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; A[i+1] = A[i] * 2; ; A[i+1] = A[i] * 2;
; ;
; for (i = 0; i < 200; i++ ) ; for (i = 0; i < 200; i++ )
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/computeout.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/do_pluto_matmult.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based -polly-delinearize < %s | FileCheck %s -check-prefix=MEMORY ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based -polly-delinearize < %s | FileCheck %s -check-prefix=MEMORY
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] } %struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }
%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 } %struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }
@A = common global [36 x [49 x double]] zeroinitializer, align 8 ; <[36 x [49 x double]]*> [#uses=3] @A = common global [36 x [49 x double]] zeroinitializer, align 8 ; <[36 x [49 x double]]*> [#uses=3]
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_complex_location.ll

; RUN: opt -basicaa %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_dependences_equal_non_reduction_dependences.ll

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

polly/trunk/test/Dependences/reduction_mixed_reduction_and_non_reduction_dependences.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0 + i1, o1] : i1 <= 1023 - i0 and i1 >= 0 and i1 <= 1 and i0 >= 0 and o1 <= 511 and o1 >= 1 ; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0 + i1, o1] : i1 <= 1023 - i0 and i1 >= 0 and i1 <= 1 and i0 >= 0 and o1 <= 511 and o1 >= 1
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 511 and i1 >= 2 ; CHECK-DAG: Stmt_for_body3[i0, i1] -> Stmt_for_body3[1 + i0, -1 + i1] : i0 <= 1022 and i0 >= 0 and i1 <= 511 and i1 >= 2
; CHECK-DAG: Stmt_for_body3[i0, 2] -> Stmt_for_body3[2 + i0, 0] : i0 <= 1021 and i0 >= 0 ; CHECK-DAG: Stmt_for_body3[i0, 2] -> Stmt_for_body3[2 + i0, 0] : i0 <= 1021 and i0 >= 0
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_multiple_loops_array_sum.ll

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

polly/trunk/test/Dependences/reduction_multiple_loops_array_sum_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basicaa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze -basicaa < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_multiple_loops_array_sum_3.ll

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

polly/trunk/test/Dependences/reduction_multiple_reductions.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; Verify we do not have dependences between the if and the else clause ; Verify we do not have dependences between the if and the else clause
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_multiple_reductions_2.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0 ; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[i0] : i0 <= 1023 and i0 >= 0 and i1 <= 1023 and i1 >= 0
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 >= 0 and i0 <= 1022 ; CHECK-DAG: Stmt_S3[i0] -> Stmt_S0[1 + i0] : i0 >= 0 and i0 <= 1022
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0 ; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0
; These are the important RAW dependences, as they need to originate/end in only one iteration: ; These are the important RAW dependences, as they need to originate/end in only one iteration:
; CHECK-DAG: Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0 ; CHECK-DAG: Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] : i0 <= 1023 and i0 >= 0 and o1 <= 1023 and o1 >= 0
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0 ; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] : i0 <= 1023 and i0 >= 0 and i1 <= 1022 and i1 >= 0
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_only_reduction_like_access.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; FIXME: Change the comment once we allow different pointers ; FIXME: Change the comment once we allow different pointers
; The statement is "almost" reduction like but should not yield any reduction dependences ; The statement is "almost" reduction like but should not yield any reduction dependences
; ;
; We are limited to binary reductions at the moment and this is not one. ; We are limited to binary reductions at the moment and this is not one.
; There are never at least two iterations which read __and__ write to the same ; There are never at least two iterations which read __and__ write to the same
; location, thus we won't find the RAW and WAW dependences of a reduction, ; location, thus we won't find the RAW and WAW dependences of a reduction,
; thus we should not find Reduction dependences. ; thus we should not find Reduction dependences.
Show All 35 Lines

polly/trunk/test/Dependences/reduction_partially_escaping_intermediate_in_other_stmt.ll

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

polly/trunk/test/Dependences/reduction_privatization_deps.ll

; RUN: opt %loadPolly -basicaa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0 ; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and o0 >= 0 and o0 <= i0
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : i1 <= 1023 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 and i0 <= 1023 and i1 <= 1024 - i0 ; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : i1 <= 1023 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 and i0 <= 1023 and i1 <= 1024 - i0
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK-DAG: Stmt_S2[i0] -> Stmt_S2[1 + i0] : i0 <= 1022 and i0 >= 0 ; CHECK-DAG: Stmt_S2[i0] -> Stmt_S2[1 + i0] : i0 <= 1022 and i0 >= 0
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i1 <= 1023 - i0 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 } ; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i1 <= 1023 - i0 and i1 >= 0 and i1 >= 1 - i0 and i0 >= 0 }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_privatization_deps_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; We have privatization dependences from a textually later statement to a ; We have privatization dependences from a textually later statement to a
; textually earlier one, but the dependences still go forward in time. ; textually earlier one, but the dependences still go forward in time.
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0 ; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : i0 <= 97 and i0 >= 0 and o1 <= 99 and o1 >= 0
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 98 ; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 98
; CHECK: WAR dependences: ; CHECK: WAR dependences:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_privatization_deps_3.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1 ; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S3[o0] : o0 <= 1 and i1 <= 1 - i0 and o0 <= 1 + i0 - i1 and o0 >= 1 - i1
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 ; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, 1 - i0] : i0 <= 1 and i0 >= 0 and o0 >= 1 + i0 and o0 <= 98
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 >= 0 and i0 <= 96 ; CHECK-DAG: Stmt_S1[i0] -> Stmt_S3[2 + i0] : i0 >= 0 and i0 <= 96
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_privatization_deps_4.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98 ; CHECK-DAG: Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i1 >= 1 + i0 and i1 <= 98
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 >= 0 and i0 <= 98 ; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[i0, i0] : i0 >= 0 and i0 <= 98
; CHECK-DAG: Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 98 ; CHECK-DAG: Stmt_S2[i0, i0] -> Stmt_S3[i0] : i0 >= 0 and i0 <= 98
; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98 ; CHECK-DAG: Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and o0 >= 1 + i0 and o0 <= 98
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK-DAG: { } ; CHECK-DAG: { }
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_privatization_deps_5.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 >= 0 and i0 <= 97 ; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 >= 0 and i0 <= 97
; CHECK-DAG: Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 >= 0 and i0 <= 98 ; CHECK-DAG: Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : i0 >= 0 and i0 <= 98
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK-DAG: { } ; CHECK-DAG: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 >= 0 and i0 <= 97 ; CHECK-DAG: Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : i0 >= 0 and i0 <= 97
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_simple_iv.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { } ; CHECK: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK: { } ; CHECK: { }
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
Show All 31 Lines

polly/trunk/test/Dependences/reduction_simple_iv_debug_wrapped_dependences.ll

; RUN: opt %loadPolly -polly-dependences -analyze -debug-only=polly-dependence 2>&1 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze -debug-only=polly-dependence 2>&1 < %s | FileCheck %s
; ;
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 } ; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 }
; CHECK: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 } ; CHECK: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0]] -> MemRef_sum[0] : i0 >= 0 and i0 <= 100 }
; CHECK: Schedule: { ; CHECK: Schedule: {
; CHECK-DAG: [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [i0] : i0 <= 100 and i0 >= 0 ; CHECK-DAG: [Stmt_for_cond[i0] -> MemRef_sum[0]] -> [i0] : i0 <= 100 and i0 >= 0
; CHECK-DAG: Stmt_for_cond[i0] -> [i0] ; CHECK-DAG: Stmt_for_cond[i0] -> [i0]
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_simple_privatization_deps_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0 ; CHECK-DAG: Stmt_S1[i0, i1] -> Stmt_S2[i0] : i0 <= 99 and i0 >= 0 and i1 <= 99 and i1 >= 0
; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0 ; CHECK-DAG: Stmt_S0[i0] -> Stmt_S1[i0, o1] : i0 <= 99 and i0 >= 0 and o1 <= 99 and o1 >= 0
; CHECK-DAG: Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 >= 0 and i0 <= 98 ; CHECK-DAG: Stmt_S2[i0] -> Stmt_S0[1 + i0] : i0 >= 0 and i0 <= 98
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK-DAG: { } ; CHECK-DAG: { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_simple_privatization_deps_w_parameter.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-dependences -analyze < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0 ; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0
; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0 ; CHECK-DAG: Stmt_S1[i0] -> Stmt_S2[] : N >= 11 and i0 <= 1023 and i0 >= 0
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: [N] -> { } ; CHECK: [N] -> { }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0 ; CHECK-DAG: Stmt_S0[] -> Stmt_S1[o0] : N >= 11 and o0 <= 1023 and o0 >= 0
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/Dependences/reduction_two_reductions_different_rloops.ll

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

polly/trunk/test/Dependences/sequential_loops.ll

; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt -S %loadPolly -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
▲ Show 20 Lines • Show All 286 Lines • Show Last 20 Lines

polly/trunk/test/IndependentBlocks/inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = init + 2; ; A[i] = init + 2;
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/trunk/test/IndependentBlocks/intra_and_inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init2 = *init_ptr; ; init2 = *init_ptr;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/trunk/test/IndependentBlocks/intra_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; A[i] = init + 2; ; A[i] = init + 2;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/trunk/test/IndependentBlocks/phi_outside_scop.ll

; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @phi_nodes_outside() { define void @phi_nodes_outside() {
entry: entry:
br label %for.i.1 br label %for.i.1
for.i.1: for.i.1:
Show All 26 Lines

polly/trunk/test/IndependentBlocks/scalar_to_array.ll

; RUN: opt %loadPolly -basicaa -polly-independent < %s -S | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent < %s -S | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent < %s -S | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent < %s -S | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array -S < %s | FileCheck %s -check-prefix=SCALARACCESS
; RUN: opt %loadPolly -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array < %s -S | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-independent -disable-polly-intra-scop-scalar-to-array < %s -S | FileCheck %s -check-prefix=SCALARACCESS
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 8 @A = common global [1024 x float] zeroinitializer, align 8
define i32 @empty() nounwind { define i32 @empty() nounwind {
entry: entry:
▲ Show 20 Lines • Show All 258 Lines • Show Last 20 Lines

polly/trunk/test/IndependentBlocks/scev-invalidated.ll

; RUN: opt %loadPolly -polly-independent < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-independent < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @arc_either() { define void @arc_either() {
entry: entry:
%ang2.2.reg2mem = alloca i64 %ang2.2.reg2mem = alloca i64
br i1 undef, label %return, label %if.then6 br i1 undef, label %return, label %if.then6
Show All 13 Lines

polly/trunk/test/Isl/Ast/OpenMP/multiple_loops_outer_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s
; ;
; void jd(int *A) { ; void jd(int *A) {
; CHECK: #pragma omp parallel for ; CHECK: #pragma omp parallel for
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = 1; ; A[i] = 1;
; CHECK: #pragma omp parallel for ; CHECK: #pragma omp parallel for
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = A[i] * 2; ; A[i] = A[i] * 2;
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/trunk/test/Isl/Ast/OpenMP/nested_loop_both_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; for (j = 0; j < 1024; j++) ; for (j = 0; j < 1024; j++)
; A[i][j] = 1; ; A[i][j] = 1;
@A = common global [1024 x [1024 x i32]] zeroinitializer @A = common global [1024 x [1024 x i32]] zeroinitializer
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/trunk/test/Isl/Ast/OpenMP/nested_loop_both_parallel_parametric.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -polly-parallel-force -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; int A[1024][1024]; ; int A[1024][1024];
; void bar(int n) { ; void bar(int n) {
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; for (j = 0; j < n; j++) ; for (j = 0; j < n; j++)
; A[i][j] = 1; ; A[i][j] = 1;
; } ; }
Show All 40 Lines

polly/trunk/test/Isl/Ast/OpenMP/nested_loop_inner_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -polly-parallel-force -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; for (j = 0; j < n; j++) ; for (j = 0; j < n; j++)
; A[j] = 1; ; A[j] = 1;
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
Show All 38 Lines

polly/trunk/test/Isl/Ast/OpenMP/nested_loop_outer_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; for (j = 0; j < n; j++) ; for (j = 0; j < n; j++)
; A[i] = 1; ; A[i] = 1;
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
Show All 37 Lines

polly/trunk/test/Isl/Ast/OpenMP/single_loop_param_non_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[0] = i; ; A[0] = i;
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
Show All 25 Lines

polly/trunk/test/Isl/Ast/OpenMP/single_loop_param_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -polly-parallel-force -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = 1; ; A[i] = 1;
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
Show All 27 Lines

polly/trunk/test/Isl/Ast/OpenMP/single_loop_param_parallel_computeout.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-dependences-computeout=1 -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-parallel -polly-dependences-computeout=1 -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"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = 1; ; A[i] = 1;
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
; ;
; int A[1024]; ; int A[1024];
; ;
; ;
; void jd(float *B, int N) { ; void jd(float *B, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
; } ; }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
; ;
; int A[1024], B[1024]; ; int A[1024], B[1024];
; ;
; ;
; void jd(int N) { ; void jd(int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
; } ; }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -basicaa < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -tbaa < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -scev-aa < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -polly-no-early-exit -globalsmodref-aa < %s | FileCheck %s --check-prefix=GLOB
; ;
; int A[1024]; ; int A[1024];
; float B[1024]; ; float B[1024];
; ;
; void jd(int N) { ; void jd(int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = B[i]; ; A[i] = B[i];
; } ; }
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
; ;
; void jd(int *Int0, int *Int1, float *Float0, float *Float1) { ; void jd(int *Int0, int *Int1, float *Float0, float *Float1) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; Int0[i] = Int1[i]; ; Int0[i] = Int1[i];
; Float0[i] = Float1[i]; ; Float0[i] = Float1[i];
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c] || &MemRef_B[c + 1] <= &MemRef_A[0])) ; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c] || &MemRef_B[c + 1] <= &MemRef_A[0]))
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
Show All 30 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-ast -analyze < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c >= 15 ? 5 : c - 10] || &MemRef_B[c <= 15 ? 6 : c - 9] <= &MemRef_A[0])) ; CHECK: if (1 && (&MemRef_A[1024] <= &MemRef_B[c >= 15 ? 5 : c - 10] || &MemRef_B[c <= 15 ? 6 : c - 9] <= &MemRef_A[0]))
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
Show All 34 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; CHECK: #pragma minimal dependence distance: 8 ; CHECK: #pragma minimal dependence distance: 8
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + 8] = A[i] + 1; ; A[i + 8] = A[i] + 1;
; } ; }
▲ Show 20 Lines • Show All 43 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 -polly-detect-unprofitable -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; 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
; 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 34 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; void f(int *A, int N, int c) { ; void f(int *A, int N, int c) {
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; CHECK: #pragma minimal dependence distance: c >= 1 ? c : -c ; CHECK: #pragma minimal dependence distance: c >= 1 ? c : -c
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + c] = A[i] + 1; ; A[i + c] = A[i] + 1;
; } ; }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; void f(int *A, int N, int c, int v) { ; void f(int *A, int N, int c, int v) {
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; CHECK: #pragma minimal dependence distance: c + v >= 1 ? c + v : -c - v ; CHECK: #pragma minimal dependence distance: c + v >= 1 ? c + v : -c - v
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + c + v] = A[i] + 1; ; A[i + c + v] = A[i] + 1;
; } ; }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; CHECK: #pragma minimal dependence distance: ((N - 1) % 2) + 1 ; CHECK: #pragma minimal dependence distance: ((N - 1) % 2) + 1
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = A[N - i] + 1; ; A[i] = A[N - i] + 1;
; } ; }
; ;
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
Show All 26 Lines

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

; RUN: opt %loadPolly -polly-canonicalize -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-canonicalize -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; void f(int *restrict A, int *restrict sum) { ; void f(int *restrict A, int *restrict sum) {
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; for (int j = 0; j < 1024; j++) ; for (int j = 0; j < 1024; j++)
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; for (int i = j; i < 1024; i++) ; for (int i = j; i < 1024; i++)
; A[i - 3] = A[j] * 2 + A[j] + 2; ; A[i - 3] = A[j] * 2 + A[j] + 2;
; } ; }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 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 -polly-detect-unprofitable -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; 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
; 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;
; C[i] = C[100 - 4 * i] + 1; ; C[i] = C[100 - 4 * i] + 1;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-delinearize -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-delinearize -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma known-parallel reduction (^ : sum) ; CHECK: #pragma known-parallel reduction (^ : sum)
; void f(int N, int M, int P, int sum[P][M]) { ; void f(int N, int M, int P, int sum[P][M]) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; for (int j = 0; j < P; j++) ; for (int j = 0; j < P; j++)
; CHECK: #pragma simd ; CHECK: #pragma simd
; for (int k = 0; k < M; k++) ; for (int k = 0; k < M; k++)
; sum[j][k] ^= j; ; sum[j][k] ^= j;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma known-parallel reduction (^ : sum) ; CHECK: #pragma known-parallel reduction (^ : sum)
; void f(int N, int M, int *sum) { ; void f(int N, int M, int *sum) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; CHECK: #pragma simd ; CHECK: #pragma simd
; for (int j = 0; j < M; j++) ; for (int j = 0; j < M; j++)
; sum[j] ^= j; ; sum[j] ^= j;
; } ; }
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; This loopnest contains a reduction which imposes the same dependences as the ; This loopnest contains a reduction which imposes the same dependences as the
; accesses to the array A. We need to ensure we do __not__ parallelize anything ; accesses to the array A. We need to ensure we do __not__ parallelize anything
; here. ; here.
; ;
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; CHECK-NOT: pragma ; CHECK-NOT: pragma
; CHECK-NOT: reduction ; CHECK-NOT: reduction
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma simd reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and) ; CHECK: #pragma simd reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
; CHECK: #pragma known-parallel reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and) ; CHECK: #pragma known-parallel reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
; CHECK: for (int c0 = 0; c0 < N; c0 += 1) ; CHECK: for (int c0 = 0; c0 < N; c0 += 1)
; CHECK: Stmt_for_body(c0); ; CHECK: Stmt_for_body(c0);
; ;
; void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod, ; void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod,
; int *restrict and, int *restrict or ) { ; int *restrict and, int *restrict or ) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; Verify that we won't privatize anything in the outer dimension ; Verify that we won't privatize anything in the outer dimension
; ;
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 < 2 * n; c0 += 1) ; CHECK: for (int c0 = 0; c0 < 2 * n; c0 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: Stmt_for_body3(c0, c1); ; CHECK: Stmt_for_body3(c0, c1);
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: #pragma simd{{\s*$}} ; CHECK-NOT: #pragma simd{{\s*$}}
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: Stmt_S0(n - c1) ; CHECK: Stmt_S0(n - c1)
; CHECK: #pragma simd{{\s*$}} ; CHECK: #pragma simd{{\s*$}}
; CHECK: Stmt_S1(n - c1) ; CHECK: Stmt_S1(n - c1)
; ;
; void rlr(int *A, long n) { ; void rlr(int *A, long n) {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: #pragma simd{{\s*$}} ; CHECK-NOT: #pragma simd{{\s*$}}
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: Stmt_S0(2 * n - c1) ; CHECK: Stmt_S0(2 * n - c1)
; CHECK: #pragma simd{{\s*$}} ; CHECK: #pragma simd{{\s*$}}
; CHECK: Stmt_S1 ; CHECK: Stmt_S1
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: Stmt_S0(2 * n - c1) ; CHECK: Stmt_S0(2 * n - c1)
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma known-parallel reduction ; CHECK: #pragma known-parallel reduction
; CHECK: for (int c0 = 0; c0 <= 2; c0 += 1) { ; CHECK: for (int c0 = 0; c0 <= 2; c0 += 1) {
; CHECK: if (c0 == 2) { ; CHECK: if (c0 == 2) {
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c1 = 1; c1 < 2 * n; c1 += 2) ; CHECK: for (int c1 = 1; c1 < 2 * n; c1 += 2)
; CHECK: Stmt_S0(c1); ; CHECK: Stmt_S0(c1);
; CHECK: } else if (c0 == 1) { ; CHECK: } else if (c0 == 1) {
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: #pragma simd{{\s*$}} ; CHECK-NOT: #pragma simd{{\s*$}}
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: Stmt_S0 ; CHECK: Stmt_S0
; CHECK: #pragma simd{{\s*$}} ; CHECK: #pragma simd{{\s*$}}
; CHECK: Stmt_S1 ; CHECK: Stmt_S1
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: Stmt_S0 ; CHECK: Stmt_S0
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 1; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1; c0 += 1)
; CHECK: for (int c1 = c0; c1 < 2 * n; c1 += 2) ; CHECK: for (int c1 = c0; c1 < 2 * n; c1 += 2)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1) ; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
; CHECK: Stmt_for_body3(c1, c3); ; CHECK: Stmt_for_body3(c1, c3);
; ;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; Verify that the outer dimension doesnt't carry reduction dependences ; Verify that the outer dimension doesnt't carry reduction dependences
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1) ; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1) ; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; Verify that the outer dimension doesnt't carry reduction dependences ; Verify that the outer dimension doesnt't carry reduction dependences
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1) ; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1) ; CHECK: for (int c3 = 0; c3 <= 1023; c3 += 1)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; Verify that the outer dimension doesnt't carry reduction dependences ; Verify that the outer dimension doesnt't carry reduction dependences
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1) ; CHECK: for (int c1 = 0; c1 < 2 * n; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c3 = -1022; c3 <= 1023; c3 += 1) { ; CHECK: for (int c3 = -1022; c3 <= 1023; c3 += 1) {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; Verify that only the outer dimension needs privatization ; Verify that only the outer dimension needs privatization
; ;
; CHECK: #pragma known-parallel reduction ; CHECK: #pragma known-parallel reduction
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) { ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) {
; CHECK: if (c1 % 2 == 0) { ; CHECK: if (c1 % 2 == 0) {
; CHECK-NOT: #pragma simd reduction ; CHECK-NOT: #pragma simd reduction
; CHECK: #pragma simd ; CHECK: #pragma simd
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
; CHECK: Stmt_for_body6(c0, c1, c2); ; CHECK: Stmt_for_body6(c0, c1, c2);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
; CHECK: Stmt_for_body6(c0, c1, c2); ; CHECK: Stmt_for_body6(c0, c1, c2);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
; CHECK: Stmt_for_body6(c0, c1, c2); ; CHECK: Stmt_for_body6(c0, c1, c2);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK-NOT:#pragma known-parallel reduction ; CHECK-NOT:#pragma known-parallel reduction
; CHECK: #pragma known-parallel ; CHECK: #pragma known-parallel
; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 2047; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
; CHECK: #pragma simd reduction ; CHECK: #pragma simd reduction
; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 511; c2 += 1)
; CHECK: Stmt_for_body6(c0, c1, c2); ; CHECK: Stmt_for_body6(c0, c1, c2);
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i] = B[i]; ; A[i] = B[i];
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @run-time-condition(i16* noalias %A, i16* noalias %B) { define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-ast -analyze -polly-no-early-exit -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -analyze -polly-no-early-exit -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, int o, double A[n][m], long p, long q) { ; void foo(long n, long m, int o, double A[n][m], long p, long q) {
; ;
; if (o >= 0) ; if (o >= 0)
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop-dir=%S -basicaa -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-VECTOR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop-dir=%S -basicaa -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze -polly-no-early-exit < %s | FileCheck %s -check-prefix=CHECK-VECTOR
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i] = B[i]; ; A[i] = B[i];
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @single_loop_strip_mine(i16* noalias %A, i16* noalias %B) { define void @single_loop_strip_mine(i16* noalias %A, i16* noalias %B) {
Show All 31 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @init_array() nounwind { define void @init_array() nounwind {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.cond1, %entry for.cond: ; preds = %for.cond1, %entry
Show All 10 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | not FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
target triple = "i386-portbld-freebsd8.0" target triple = "i386-portbld-freebsd8.0"
define void @MAIN__() nounwind { define void @MAIN__() nounwind {
entry: entry:
br i1 undef, label %bb6.preheader, label %bb3 br i1 undef, label %bb6.preheader, label %bb3
Show All 33 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @clause_SetSplitField(i32 %Length) nounwind inlinehint { define void @clause_SetSplitField(i32 %Length) nounwind inlinehint {
entry: entry:
br i1 undef, label %bb1, label %bb6 br i1 undef, label %bb1, label %bb6
bb1: ; preds = %entry bb1: ; preds = %entry
Show All 18 Lines

polly/trunk/test/Isl/CodeGen/20100707_2.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@win193 = external global [4 x [36 x double]], align 32 ; <[4 x [36 x double]]*> [#uses=3] @win193 = external global [4 x [36 x double]], align 32 ; <[4 x [36 x double]]*> [#uses=3]
@sb_sample = external global [2 x [2 x [18 x [32 x double]]]], align 32 ; <[2 x [2 x [18 x [32 x double]]]]*> [#uses=2] @sb_sample = external global [2 x [2 x [18 x [32 x double]]]], align 32 ; <[2 x [2 x [18 x [32 x double]]]]*> [#uses=2]
define void @mdct_sub48() nounwind { define void @mdct_sub48() nounwind {
entry: entry:
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define fastcc void @execute() nounwind { define fastcc void @execute() nounwind {
entry: entry:
br i1 undef, label %check_stack.exit456.thread, label %bb.i451.preheader br i1 undef, label %check_stack.exit456.thread, label %bb.i451.preheader
bb.i451.preheader: ; preds = %bb116 bb.i451.preheader: ; preds = %bb116
Show All 9 Lines

polly/trunk/test/Isl/CodeGen/20100708_2.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @init_array() nounwind { define void @init_array() nounwind {
bb: bb:
br label %bb1 br label %bb1
bb1: ; preds = %bb4, %bb bb1: ; preds = %bb4, %bb
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @fft_float(i32 %NumSamples) nounwind { define void @fft_float(i32 %NumSamples) nounwind {
br label %bb18 br label %bb18
bb18: ; preds = %bb17 bb18: ; preds = %bb17
br i1 false, label %bb19, label %bb22 br i1 false, label %bb19, label %bb22
Show All 25 Lines

polly/trunk/test/Isl/CodeGen/20100713_2.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define hidden void @luaD_callhook() nounwind { define hidden void @luaD_callhook() nounwind {
entry: entry:
br i1 undef, label %bb, label %return br i1 undef, label %bb, label %return
bb: ; preds = %entry bb: ; preds = %entry
Show All 25 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -disable-output < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -disable-output < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @matrixTranspose(double** %A) nounwind { define void @matrixTranspose(double** %A) nounwind {
entry: entry:
br label %bb4 br label %bb4
bb: ; preds = %bb4 bb: ; preds = %bb4
Show All 30 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -verify-dom-info -disable-output < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -verify-dom-info -disable-output < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @getNonAffNeighbour() nounwind { define void @getNonAffNeighbour() nounwind {
entry: entry:
br i1 undef, label %bb, label %bb6 br i1 undef, label %bb, label %bb6
bb: ; preds = %entry bb: ; preds = %entry
Show All 26 Lines

polly/trunk/test/Isl/CodeGen/20100718-DomInfo.ll

; RUN: opt %loadPolly -polly-codegen-isl -verify-dom-info -disable-output < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -verify-dom-info -disable-output < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @intrapred_luma_16x16(i32 %predmode) nounwind { define void @intrapred_luma_16x16(i32 %predmode) nounwind {
entry: entry:
switch i32 %predmode, label %bb81 [ switch i32 %predmode, label %bb81 [
i32 0, label %bb25 i32 0, label %bb25
i32 1, label %bb26 i32 1, label %bb26
Show All 19 Lines

polly/trunk/test/Isl/CodeGen/20100720-MultipleConditions.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -analyze < %s
;int bar1(); ;int bar1();
;int bar2(); ;int bar2();
;int bar3(); ;int bar3();
;int k; ;int k;
;#define N 100 ;#define N 100
;int A[N]; ;int A[N];
; ;
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/20100809-IndependentBlock.ll

; RUN: opt %loadPolly -polly-codegen-isl -disable-output < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -disable-output < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @cfft2([2 x float]* %x) nounwind { define void @cfft2([2 x float]* %x) nounwind {
entry: entry:
%d.1.reg2mem = alloca [2 x float]* ; <[2 x float]**> [#uses=3] %d.1.reg2mem = alloca [2 x float]* ; <[2 x float]**> [#uses=3]
br i1 undef, label %bb2, label %bb34 br i1 undef, label %bb2, label %bb34
bb2: ; preds = %bb34, %entry bb2: ; preds = %bb34, %entry
Show All 22 Lines

polly/trunk/test/Isl/CodeGen/20100811-ScalarDependencyBetweenBrAndCnd.ll

; RUN: opt %loadPolly -polly-codegen-isl -disable-output < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -disable-output < %s
target datalayout = target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @main() nounwind { define void @main() nounwind {
entry: entry:
br label %for.cond br label %for.cond
Show All 21 Lines

polly/trunk/test/Isl/CodeGen/20101030-Overflow.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @compdecomp() nounwind { define void @compdecomp() nounwind {
entry: entry:
%max = alloca i64 %max = alloca i64
%i = load i64* undef %i = load i64* undef
br label %bb37 br label %bb37
Show All 13 Lines

polly/trunk/test/Isl/CodeGen/20101103-Overflow3.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @Reflection_coefficients(i16* %r) nounwind { define void @Reflection_coefficients(i16* %r) nounwind {
bb20: bb20:
%indvar3.lcssa20.reload = load i64* undef %indvar3.lcssa20.reload = load i64* undef
%tmp = mul i64 %indvar3.lcssa20.reload, -1 %tmp = mul i64 %indvar3.lcssa20.reload, -1
%tmp5 = add i64 %tmp, 8 %tmp5 = add i64 %tmp, 8
br label %bb22 br label %bb22
Show All 15 Lines

polly/trunk/test/Isl/CodeGen/20101103-signmissmatch.ll

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @CleanNet() nounwind { define void @CleanNet() nounwind {
entry: entry:
%firstVia.0.reg2mem = alloca i64 %firstVia.0.reg2mem = alloca i64
br label %bb7 br label %bb7
Show All 29 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @main() nounwind { define void @main() nounwind {
.split: .split:
br label %0 br label %0
.loopexit.loopexit: ; preds = %.preheader.us .loopexit.loopexit: ; preds = %.preheader.us
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @main() nounwind { define void @main() nounwind {
.split: .split:
br label %0 br label %0
Show All 21 Lines

polly/trunk/test/Isl/CodeGen/20110312-Fail-without-basicaa.ll

; This should be run without alias analysis enabled. ; This should be run without alias analysis enabled.
;RUN: opt %loadPolly -polly-independent < %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-independent < %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
target triple = "i386-pc-linux-gnu" target triple = "i386-pc-linux-gnu"
define i32 @main() nounwind { define i32 @main() nounwind {
entry: entry:
%t.02.reg2mem = alloca float %t.02.reg2mem = alloca float
br label %entry.split br label %entry.split
Show All 17 Lines

polly/trunk/test/Isl/CodeGen/20120316-InvalidCast.ll

; RUN: opt %loadPolly -S -polly-detect-scops-in-functions-without-loops -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -polly-no-early-exit < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-detect-scops-in-functions-without-loops -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -polly-no-early-exit < %s | FileCheck %s
; CHECK: polly.start ; CHECK: polly.start
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
define void @fixup_gotos(i32* %A, i32* %data) nounwind { define void @fixup_gotos(i32* %A, i32* %data) nounwind {
entry: entry:
br label %if br label %if
Show All 12 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
; We just check that this compilation does not crash. ; We just check that this compilation does not crash.
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
target triple = "hexagon-unknown-linux-gnu" target triple = "hexagon-unknown-linux-gnu"
define void @init() nounwind { define void @init() nounwind {
entry: entry:
Show All 18 Lines

polly/trunk/test/Isl/CodeGen/20130211-getNumberOfIterations.ll

; RUN: opt %loadPolly -polly-codegen-isl -polly-vectorizer=polly < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-vectorizer=polly < %s
; RUN: opt %loadPolly -polly-codegen-isl -polly-vectorizer=bb < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-vectorizer=bb < %s
; This test case checks that the polly vectorizer does not crash when ; This test case checks that the polly vectorizer does not crash when
; calculating the number of iterations. ; calculating the number of iterations.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@b = external global [2048 x i64], align 16 @b = external global [2048 x i64], align 16
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -S < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -S < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @list_sequence(i32* %A) { define void @list_sequence(i32* %A) {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 12 Lines

polly/trunk/test/Isl/CodeGen/LoopParallelMD/do_not_mutate_debug_info.ll

; This test checks that we do not accidently mutate the debug info when ; This test checks that we do not accidently mutate the debug info when
; inserting loop parallel metadata. ; inserting loop parallel metadata.
; RUN: opt %loadPolly < %s -S -polly -polly-codegen-isl -polly-ast-detect-parallel | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable < %s -S -polly -polly-codegen-isl -polly-ast-detect-parallel | FileCheck %s
; CHECK-NOT: !7 = !{!7} ; CHECK-NOT: !7 = !{!7}
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global i32* null, align 8 @A = common global i32* null, align 8
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo() { define void @foo() {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/LoopParallelMD/loop_nest_param_parallel.ll

; RUN: opt %loadPolly -polly-codegen-isl -polly-ast-detect-parallel -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-ast-detect-parallel -S < %s | FileCheck %s
; ;
; Check that we mark multiple parallel loops correctly including the memory instructions. ; Check that we mark multiple parallel loops correctly including the memory instructions.
; ;
; CHECK-DAG: %polly.loop_cond[[COuter:[0-9]*]] = icmp sle i64 %polly.indvar{{[0-9]*}}, 1022 ; CHECK-DAG: %polly.loop_cond[[COuter:[0-9]*]] = icmp sle i64 %polly.indvar{{[0-9]*}}, 1022
; CHECK-DAG: br i1 %polly.loop_cond[[COuter]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDOuter:[0-9]*]] ; CHECK-DAG: br i1 %polly.loop_cond[[COuter]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDOuter:[0-9]*]]
; ;
; CHECK-DAG: %polly.loop_cond[[CInner:[0-9]*]] = icmp sle i64 %polly.indvar{{[0-9]*}}, 510 ; CHECK-DAG: %polly.loop_cond[[CInner:[0-9]*]] = icmp sle i64 %polly.indvar{{[0-9]*}}, 510
; CHECK-DAG: br i1 %polly.loop_cond[[CInner]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDInner:[0-9]*]] ; CHECK-DAG: br i1 %polly.loop_cond[[CInner]], label %polly.loop_header{{[0-9]*}}, label %polly.loop_exit{{[0-9]*}}, !llvm.loop ![[IDInner:[0-9]*]]
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/LoopParallelMD/single_loop_param_parallel.ll

; RUN: opt %loadPolly -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=SEQUENTIAL ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=SEQUENTIAL
; RUN: opt %loadPolly -polly-codegen-isl -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-ast-detect-parallel -S < %s | FileCheck %s -check-prefix=PARALLEL
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; This is a trivially parallel loop. We just use it to ensure that we actually ; This is a trivially parallel loop. We just use it to ensure that we actually
; emit the right information. ; emit the right information.
; ;
; for (i = 0; i < n; i++) ; for (i = 0; i < n; i++)
; A[i] = 1; ; A[i] = 1;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -analyze 2>&1 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop -polly-import-jscop-dir=%S -analyze 2>&1 < %s | FileCheck %s
; ;
; Check that we do not allow to access elements not accessed before because the ; Check that we do not allow to access elements not accessed before because the
; alignment information would become invalid. ; alignment information would become invalid.
; ;
; CHECK: JScop file changes the accessed memory ; CHECK: JScop file changes the accessed memory
; ;
; void bad_alignment(int *A) { ; void bad_alignment(int *A) {
; for (int i = 0; i < 1024; i += 2) ; for (int i = 0; i < 1024; i += 2)
Show All 27 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
;int A[100]; ;int A[100];
; ;
;int codegen_constant_offset() { ;int codegen_constant_offset() {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 34 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
;int A[100]; ;int A[100];
; ;
;int codegen_simple () { ;int codegen_simple () {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 34 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -instnamer < %s -S | FileCheck %s
; ;
;float A[100]; ;float A[100];
; ;
;int codegen_simple () { ;int codegen_simple () {
; for (int i = 0; i < 12; i++) ; for (int i = 0; i < 12; i++)
; A[13] = A[i] + A[i-1]; ; A[13] = A[i] + A[i-1];
; ;
; return 0; ; return 0;
Show All 32 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
;int A[1040]; ;int A[1040];
; ;
;int codegen_simple_md() { ;int codegen_simple_md() {
; for (int i = 0; i < 32; ++i) ; for (int i = 0; i < 32; ++i)
; for (int j = 0; j < 32; ++j) ; for (int j = 0; j < 32; ++j)
; A[32*i+j] = 100; ; A[32*i+j] = 100;
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHCONST %s
;RUN: opt %loadPolly -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed+withoutconst -polly-codegen-isl < %s -S | FileCheck -check-prefix=WITHOUTCONST %s
; ;
;float A[1040]; ;float A[1040];
; ;
;int codegen_simple_md() { ;int codegen_simple_md() {
; for (int i = 0; i < 32; ++i) ; for (int i = 0; i < 32; ++i)
; for (int j = 0; j < 32; ++j) ; for (int j = 0; j < 32; ++j)
; A[32*i+j] = 100; ; A[32*i+j] = 100;
;} ;}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-import-jscop -polly-import-jscop-dir=%S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-import-jscop -polly-import-jscop-dir=%S -analyze < %s | FileCheck %s
; ;
; Check that we allow the new access functions even though they access ; Check that we allow the new access functions even though they access
; different locations than the original ones (but the alignment is the ; different locations than the original ones (but the alignment is the
; default, thus there is no problem). ; default, thus there is no problem).
; ;
; CHECK-DAG: New access function '{ Stmt_for_body[i0] -> MemRef_B[0] }'detected in JSCOP file ; CHECK-DAG: New access function '{ Stmt_for_body[i0] -> MemRef_B[0] }'detected in JSCOP file
; CHECK-DAG: New access function '{ Stmt_for_body[i0] -> MemRef_A[i0] }'detected in JSCOP file ; CHECK-DAG: New access function '{ Stmt_for_body[i0] -> MemRef_A[i0] }'detected in JSCOP file
; ;
Show All 32 Lines

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

;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -stats < %s 2>&1 | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -stats < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
;int A[100]; ;int A[100];
;int B[100]; ;int B[100];
; ;
;int simple() ;int simple()
;{ ;{
; int i, j; ; int i, j;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

;RUN: opt %loadPolly -polly-import-jscop -analyze -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed < %s | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop -analyze -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed < %s | FileCheck %s
;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -polly-vectorizer=polly -S < %s | FileCheck %s --check-prefix=JSCOPVEC ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-import-jscop -polly-import-jscop-dir=%S -polly-import-jscop-postfix=transformed -polly-codegen-isl -polly-vectorizer=polly -S < %s | FileCheck %s --check-prefix=JSCOPVEC
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
@A = common global [100 x i32] zeroinitializer, align 4 @A = common global [100 x i32] zeroinitializer, align 4
@B = common global [100 x i32] zeroinitializer, align 4 @B = common global [100 x i32] zeroinitializer, align 4
define i32 @simple() nounwind { define i32 @simple() nounwind {
entry: entry:
br label %for.cond br label %for.cond
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -polly-vectorizer=polly -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -polly-vectorizer=polly -S < %s | FileCheck %s
; ;
; Check that we use the correct __new__ strides: ; Check that we use the correct __new__ strides:
; stride zero for B ; stride zero for B
; stride one for A ; stride one for A
; ;
; CHECK: %polly.access.B = getelementptr i32* %B, i64 0 ; CHECK: %polly.access.B = getelementptr i32* %B, i64 0
; CHECK: %[[BC:[._a-zA-Z0-9]*]] = bitcast i32* %polly.access.B to <1 x i32>* ; CHECK: %[[BC:[._a-zA-Z0-9]*]] = bitcast i32* %polly.access.B to <1 x i32>*
; CHECK: %[[LD:[._a-zA-Z0-9]*]] = load <1 x i32>* %[[BC]], align 8 ; CHECK: %[[LD:[._a-zA-Z0-9]*]] = load <1 x i32>* %[[BC]], align 8
Show All 38 Lines

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

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

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

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; AST: #pragma simd ; AST: #pragma simd
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
; AST: for (int c0 = 0; c0 <= 1023; c0 += 1) ; AST: for (int c0 = 0; c0 <= 1023; c0 += 1)
; AST: Stmt_for_i(c0); ; AST: Stmt_for_i(c0);
; IR: getelementptr inbounds { [1024 x double]* }* %polly.par.userContext, i32 0, i32 0 ; IR: getelementptr inbounds { [1024 x double]* }* %polly.par.userContext, i32 0, i32 0
Show All 22 Lines

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

; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -basicaa -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; The interesting part of this test case is the instruction: ; The interesting part of this test case is the instruction:
; %tmp = bitcast i8* %call to i64** ; %tmp = bitcast i8* %call to i64**
; which is not part of the scop. In the SCEV based code generation not '%tmp', ; which is not part of the scop. In the SCEV based code generation not '%tmp',
; but %call is a parameter of the SCoP and we need to make sure its value is ; but %call is a parameter of the SCoP and we need to make sure its value is
; properly forwarded to the subfunction. ; properly forwarded to the subfunction.
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR
; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction. ; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction.
; ;
; void loop_references_outer_ids(float *A) { ; void loop_references_outer_ids(float *A) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 37 Lines

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

; RUN: opt %loadPolly -polly-parallel -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR
; ;
; float A[100]; ; float A[100];
; ;
; void loop_references_outer_ids(long n) { ; void loop_references_outer_ids(long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; for (long k = 0; k < n + i; k++) ; for (long k = 0; k < n + i; k++)
; A[j] += i + j + k; ; A[j] += i + j + k;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; IR: @foo.polly.subfn ; IR: @foo.polly.subfn
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo(i32 %sendcount, i8* %recvbuf) { define void @foo(i32 %sendcount, i8* %recvbuf) {
entry: entry:
br label %sw.bb3 br label %sw.bb3
Show All 18 Lines

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

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; - Test the case where scalar evolution references a loop that is outside ; - Test the case where scalar evolution references a loop that is outside
; of the scop, but does not contain the scop. ; of the scop, but does not contain the scop.
; - Test the case where two parallel subfunctions are created. ; - Test the case where two parallel subfunctions are created.
; AST: if (symbol >= p_2 + 1) { ; AST: if (symbol >= p_2 + 1) {
; AST-NEXT: #pragma simd ; AST-NEXT: #pragma simd
Show All 37 Lines

polly/trunk/test/Isl/CodeGen/OpenMP/single_loop.ll

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST-STRIDE4 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR-STRIDE4 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR-STRIDE4 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-import-jscop -polly-import-jscop-dir=%S -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=IR-STRIDE4
; This extensive test case tests the creation of the full set of OpenMP calls ; This extensive test case tests the creation of the full set of OpenMP calls
; as well as the subfunction creation using a trivial loop as example. ; as well as the subfunction creation using a trivial loop as example.
; #define N 1024 ; #define N 1024
; float A[N]; ; float A[N];
; ;
; void single_parallel_loop(void) { ; void single_parallel_loop(void) {
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

polly/trunk/test/Isl/CodeGen/OpenMP/single_loop_with_loop_invariant_baseptr.ll

; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -tbaa -polly-parallel -polly-parallel-force -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; #define N 1024 ; #define N 1024
; float A[N]; ; float A[N];
; ;
; void single_parallel_loop(void) { ; void single_parallel_loop(void) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; A[i] = 1; ; A[i] = 1;
; } ; }
Show All 39 Lines

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

; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-parallel -polly-parallel-force -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; This test case verifies that we create correct code even if two OpenMP loops ; This test case verifies that we create correct code even if two OpenMP loops
; share common outer variables. ; share common outer variables.
; AST: if (nj >= p_1 + 3) { ; AST: if (nj >= p_1 + 3) {
; AST: #pragma simd ; AST: #pragma simd
; AST: #pragma omp parallel for ; AST: #pragma omp parallel for
; AST: for (int c0 = 0; c0 < p_0 + nj - 1; c0 += 1) ; AST: for (int c0 = 0; c0 < p_0 + nj - 1; c0 += 1)
Show All 37 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t } %struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t }
%struct.__pthread_list_t = type { %struct.__pthread_list_t*, %struct.__pthread_list_t* } %struct.__pthread_list_t = type { %struct.__pthread_list_t*, %struct.__pthread_list_t* }
%union.pthread_attr_t = type { i64, [12 x i32] } %union.pthread_attr_t = type { i64, [12 x i32] }
%union.pthread_mutex_t = type { %struct..0__pthread_mutex_s } %union.pthread_mutex_t = type { %struct..0__pthread_mutex_s }
%union.pthread_mutexattr_t = type { i32 } %union.pthread_mutexattr_t = type { i32 }
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -S -polly-code-generator=isl -polly-codegen-isl < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-code-generator=isl -polly-codegen-isl < %s | FileCheck %s
; ;
; We have to cast %B to "short *" before we create RTCs. ; We have to cast %B to "short *" before we create RTCs.
; ;
; CHECK: %polly.access.cast.B = bitcast i32* %B to i16* ; CHECK: %polly.access.cast.B = bitcast i32* %B to i16*
; CHECK-NEXT: %polly.access.B = getelementptr i16* %polly.access.cast.B, i64 1024 ; CHECK-NEXT: %polly.access.B = getelementptr i16* %polly.access.cast.B, i64 1024
; ;
; We should never access %B as an i32 pointer: ; We should never access %B as an i32 pointer:
; ;
Show All 34 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s
; ;
; Check that we cast the different pointer types correctly before we compare ; Check that we cast the different pointer types correctly before we compare
; them in the RTC's. We use i8* as max pointer type. ; them in the RTC's. We use i8* as max pointer type.
; ;
; CHECK: entry: ; CHECK: entry:
; CHECK: %polly.access.B = getelementptr float** %B, i64 1024 ; CHECK: %polly.access.B = getelementptr float** %B, i64 1024
; CHECK: %polly.access.A = getelementptr double** %A, i64 0 ; CHECK: %polly.access.A = getelementptr double** %A, i64 0
; CHECK: %[[paBb:[._a-zA-Z0-9]]] = bitcast float** %polly.access.B to i8* ; CHECK: %[[paBb:[._a-zA-Z0-9]]] = bitcast float** %polly.access.B to i8*
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -S -polly-codegen-isl -polly-code-generator=isl -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-codegen-isl -polly-code-generator=isl -polly-delinearize < %s | FileCheck %s
; ;
; Check that we calculate the maximal access into array A correctly. ; Check that we calculate the maximal access into array A correctly.
; ;
; CHECK: %[[TMP0:[._0-9a-zA-Z]*]] = mul i64 99, %m ; CHECK: %[[TMP0:[._0-9a-zA-Z]*]] = mul i64 99, %m
; CHECK: %[[TMP1:[._0-9a-zA-Z]*]] = add i64 %[[TMP0]], 149 ; CHECK: %[[TMP1:[._0-9a-zA-Z]*]] = add i64 %[[TMP0]], 149
; CHECK: %[[TMP2:[._0-9a-zA-Z]*]] = mul i64 %[[TMP1]], %p ; CHECK: %[[TMP2:[._0-9a-zA-Z]*]] = mul i64 %[[TMP1]], %p
; CHECK: %[[TMP3:[._0-9a-zA-Z]*]] = add i64 %[[TMP2]], 150 ; CHECK: %[[TMP3:[._0-9a-zA-Z]*]] = add i64 %[[TMP2]], 150
; CHECK: %polly.access.A{{[0-9]*}} = getelementptr double* %A, i64 %[[TMP3]] ; CHECK: %polly.access.A{{[0-9]*}} = getelementptr double* %A, i64 %[[TMP3]]
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
; CHECK: %[[AMax:[._a-zA-Z0-9]*]] = getelementptr i32* %A, i64 1024 ; CHECK: %[[AMax:[._a-zA-Z0-9]*]] = getelementptr i32* %A, i64 1024
; CHECK: %[[BMin:[._a-zA-Z0-9]*]] = getelementptr i32* %B, i32 %c ; CHECK: %[[BMin:[._a-zA-Z0-9]*]] = getelementptr i32* %B, i32 %c
Show All 36 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
; CHECK: %[[AMax:[._a-zA-Z0-9]*]] = getelementptr i32* %A, i64 1024 ; CHECK: %[[AMax:[._a-zA-Z0-9]*]] = getelementptr i32* %A, i64 1024
; CHECK: %[[m0:[._a-zA-Z0-9]*]] = sext i32 %c to i64 ; CHECK: %[[m0:[._a-zA-Z0-9]*]] = sext i32 %c to i64
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
; ;
; Check that the special alignment information is kept ; Check that the special alignment information is kept
; ;
; CHECK: align 8 ; CHECK: align 8
; CHECK: align 8 ; CHECK: align 8
; ;
; void jd(int *A) { ; void jd(int *A) {
; for (int i = 0; i < 1024; i += 2) ; for (int i = 0; i < 1024; i += 2)
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s --check-prefix=SCOPES ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-codegen-isl -S < %s | FileCheck %s --check-prefix=SCOPES
; RUN: opt %loadPolly -polly-code-generator=isl -polly-codegen-isl -polly-annotate-alias-scopes=false -S < %s | FileCheck %s --check-prefix=NOSCOPES ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-codegen-isl -polly-annotate-alias-scopes=false -S < %s | FileCheck %s --check-prefix=NOSCOPES
; ;
; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way. ; Check that we create alias scopes that indicate the accesses to A, B and C cannot alias in any way.
; ;
; SCOPES-LABEL: polly.stmt.for.body: ; SCOPES-LABEL: polly.stmt.for.body:
; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar ; SCOPES: %[[BIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} i32* %B, i64 %polly.indvar
; SCOPES: load i32* %[[BIdx]], align 4, !alias.scope ![[AliasScopeB:[0-9]*]], !noalias ![[NoAliasB:[0-9]*]] ; SCOPES: load i32* %[[BIdx]], align 4, !alias.scope ![[AliasScopeB:[0-9]*]], !noalias ![[NoAliasB:[0-9]*]]
; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar ; SCOPES: %[[CIdx:[._a-zA-Z0-9]*]] = getelementptr{{.*}} float* %C, i64 %polly.indvar
; SCOPES: load float* %[[CIdx]], align 4, !alias.scope ![[AliasScopeC:[0-9]*]], !noalias ![[NoAliasC:[0-9]*]] ; SCOPES: load float* %[[CIdx]], align 4, !alias.scope ![[AliasScopeC:[0-9]*]], !noalias ![[NoAliasC:[0-9]*]]
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl < %s
; ;
; Regression test for a bug in the runtime check generation. ; Regression test for a bug in the runtime check generation.
; This was extracted from the blas testcase. It crashed in one ; This was extracted from the blas testcase. It crashed in one
; part of the runtime check generation at some point. To be ; part of the runtime check generation at some point. To be
; precise, we couldn't find a suitable block to put the RTC code in. ; precise, we couldn't find a suitable block to put the RTC code in.
; ;
; int sscal(int n, float sa, float *sx) { ; int sscal(int n, float sa, float *sx) {
Show All 35 Lines

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

;RUN: opt %loadPolly -polly-no-early-exit -polly-prepare -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-ast -analyze < %s | FileCheck %s ;RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-prepare -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;int A[1]; ;int A[1];
; ;
;void constant_condition () { ;void constant_condition () {
; int a = 0; ; int a = 0;
; int b = 0; ; int b = 0;
; ;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -verify-loop-info < %s -S | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-codegen-isl -verify-loop-info < %s -S | FileCheck %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
target triple = "hexagon-unknown-linux-gnu" target triple = "hexagon-unknown-linux-gnu"
; This test case used to fail, because we did not add the newly generated basic ; This test case used to fail, because we did not add the newly generated basic
; block %polly.start as a basic block to the surrounding loop. ; block %polly.start as a basic block to the surrounding loop.
define void @foo() nounwind { define void @foo() nounwind {
entry: entry:
Show All 20 Lines

polly/trunk/test/Isl/CodeGen/debug-intrinsics.ll

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(float* %A, i64 %N) #0 { define void @foo(float* %A, i64 %N) #0 {
entry: entry:
br label %entry.split br label %entry.split
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl -S < %s | FileCheck %s
; ;
; Verify that we remove the lifetime markers from the optimized SCoP. ; Verify that we remove the lifetime markers from the optimized SCoP.
; ;
; CHECK: for.body: ; CHECK: for.body:
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; CHECK: for.end: ; CHECK: for.end:
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK-NOT: call void @llvm.lifetime.start ; CHECK-NOT: call void @llvm.lifetime.start
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl -S < %s | FileCheck %s
; ;
; Verify that we remove the misc intrinsics from the optimized SCoP. ; Verify that we remove the misc intrinsics from the optimized SCoP.
; ;
; CHECK: for.body: ; CHECK: for.body:
; CHECK: call {}* @llvm.invariant.start ; CHECK: call {}* @llvm.invariant.start
; CHECK: for.body4: ; CHECK: for.body4:
; CHECK: call void @llvm.assume ; CHECK: call void @llvm.assume
; CHECK: call i1 @llvm.expect.i1 ; CHECK: call i1 @llvm.expect.i1
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition() { ;void loop_with_condition() {
; int i; ; int i;
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

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

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

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition_ineq() { ;void loop_with_condition_ineq() {
; int i; ; int i;
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
;void loop_with_condition() { ;void loop_with_condition() {
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
; ;
; Test case to trigger the hard way of creating a unique entering ; Test case to trigger the hard way of creating a unique entering
; edge for the SCoP. It is triggered because the entering edge ; edge for the SCoP. It is triggered because the entering edge
; here: %while.begin --> %if is __not__ critical. ; here: %while.begin --> %if is __not__ critical.
; ;
; int f(void); ; int f(void);
; void jd(int b, int *A) { ; void jd(int b, int *A) {
; while (f()) { ; while (f()) {
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double A[n][m]) { ; void foo(long n, long m, double A[n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 150; j++) ; for (long j = 0; j < 150; j++)
Show All 36 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -polly-delinearize < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-delinearize < %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK: %polly.access.sext.A = sext i32 %n to i64 ; CHECK: %polly.access.sext.A = sext i32 %n to i64
; CHECK: %polly.access.mul.A = mul i64 %polly.access.sext.A, %0 ; CHECK: %polly.access.mul.A = mul i64 %polly.access.sext.A, %0
; CHECK: %polly.access.add.A = add i64 %polly.access.mul.A, 1 ; CHECK: %polly.access.add.A = add i64 %polly.access.mul.A, 1
; CHECK: %polly.access.A = getelementptr double* %A, i64 %polly.access.add.A ; CHECK: %polly.access.A = getelementptr double* %A, i64 %polly.access.add.A
; CHECK: %polly.access.y = getelementptr double* %y, i64 0 ; CHECK: %polly.access.y = getelementptr double* %y, i64 0
Show All 33 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -S -verify-dom-info < %s | FileCheck %s
; ;
; CHECK-NOT: br i1 true, label %polly.{{.*}}, label %polly.{{.*}} ; CHECK-NOT: br i1 true, label %polly.{{.*}}, label %polly.{{.*}}
; ;
; void jd(int *A) { ; void jd(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = i; ; A[i] = i;
; } ; }
; ;
Show All 24 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -polly-parallel -S < %s | FileCheck %s --check-prefix=AUTO ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-parallel -S < %s | FileCheck %s --check-prefix=AUTO
; RUN: opt %loadPolly -polly-codegen-isl -polly-parallel -polly-num-threads=1 -S < %s | FileCheck %s --check-prefix=ONE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-parallel -polly-num-threads=1 -S < %s | FileCheck %s --check-prefix=ONE
; RUN: opt %loadPolly -polly-codegen-isl -polly-parallel -polly-num-threads=4 -S < %s | FileCheck %s --check-prefix=FOUR ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -polly-parallel -polly-num-threads=4 -S < %s | FileCheck %s --check-prefix=FOUR
; ;
; AUTO: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 0, i64 0, i64 1024, i64 1) ; AUTO: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 0, i64 0, i64 1024, i64 1)
; ONE: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 1, i64 0, i64 1024, i64 1) ; ONE: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 1, i64 0, i64 1024, i64 1)
; FOUR: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 4, i64 0, i64 1024, i64 1) ; FOUR: call void @GOMP_parallel_loop_runtime_start(void (i8*)* @jd.polly.subfn, i8* %polly.par.userContext{{[0-9]*}}, i32 4, i64 0, i64 1024, i64 1)
; ;
; void jd(int *A) { ; void jd(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = 0; j < 1024; j++) ; for (int j = 0; j < 1024; j++)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(i8* %start, i8* %end) { define void @foo(i8* %start, i8* %end) {
entry: entry:
%A = alloca i32 %A = alloca i32
br label %body br label %body
body: body:
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
; void f(int a[], int N, float *P) { ; void f(int a[], int N, float *P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P != 0) ; if (P != 0)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 37 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
; ;
; void f(int a[], int N, float *P, float *Q) { ; void f(int a[], int N, float *P, float *Q) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P != Q) ; if (P != Q)
; a[i] = i; ; a[i] = i;
; } ; }
; ;
Show All 37 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl -S < %s 2>&1 | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl -S < %s 2>&1 | not FileCheck %s
;#include <string.h> ;#include <string.h>
;#include <stdio.h> ;#include <stdio.h>
;#define N 1021 ;#define N 1021
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#include <stdio.h> ;#include <stdio.h>
;#define N 1021 ;#define N 1021
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
; ;
; CHECK: pragma simd reduction ; CHECK: pragma simd reduction
; ;
; int prod; ; int prod;
; void f() { ; void f() {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; prod *= i; ; prod *= i;
; } ; }
Show All 28 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
; CHECK: %1 = zext i32 %n to i64 ; CHECK: %1 = zext i32 %n to i64
; CHECK: %2 = icmp sge i64 %1, 1 ; CHECK: %2 = icmp sge i64 %1, 1
; CHECK: %3 = select i1 %2, i64 1, i64 0 ; CHECK: %3 = select i1 %2, i64 1, i64 0
; CHECK: %4 = icmp ne i64 %3, 0 ; CHECK: %4 = icmp ne i64 %3, 0
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
Show All 18 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -basicaa -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -basicaa -polly-codegen-isl -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @run-time-condition(i16* noalias %A, i16* noalias %B) { define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
entry: entry:
br label %for.cond br label %for.cond
Show All 22 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s
; Test the code generation in the presence of a scalar out-of-scop value being ; Test the code generation in the presence of a scalar out-of-scop value being
; used from within the SCoP. ; used from within the SCoP.
; CHECH-LABEL: @scalar-function-argument ; CHECH-LABEL: @scalar-function-argument
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define fastcc void @f () inlinehint align 2 { define fastcc void @f () inlinehint align 2 {
entry: entry:
%0 = fmul double undef, 1.250000e+00 ; <double> [#uses=1] %0 = fmul double undef, 1.250000e+00 ; <double> [#uses=1]
%1 = fptoui double %0 to i32 ; <i32> [#uses=0] %1 = fptoui double %0 to i32 ; <i32> [#uses=0]
br i1 false, label %bb5.i, label %bb.nph.i br i1 false, label %bb5.i, label %bb.nph.i
Show All 13 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S -polly-delinearize < %s | FileCheck %s
; Verify that we generate the runtime check code after the conditional branch ; Verify that we generate the runtime check code after the conditional branch
; in the SCoP region entering block (here %entry). ; in the SCoP region entering block (here %entry).
; ;
; CHECK: entry: ; CHECK: entry:
; CHECK: zext i32 %n to i64 ; CHECK: zext i32 %n to i64
; CHECK: br i1 false ; CHECK: br i1 false
; ;
Show All 25 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
; ;
;int A[N]; ;int A[N];
; ;
;void sequential_loops() { ;void sequential_loops() {
; int i; ; int i;
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 28 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-detect-scops-in-regions-without-loops -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CHECK-CODE
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true){ ; if (true){
; i = 0; ; i = 0;
; goto next; ; goto next;
; }else{ ; }else{
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s
;#include <stdio.h> ;#include <stdio.h>
;#include <stdlib.h> ;#include <stdlib.h>
;#include <math.h> ;#include <math.h>
; ;
;int main() ;int main()
;{ ;{
; int A[1024*1024]; ; int A[1024*1024];
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
; ;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
; ;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 34 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float** @foo(float) readnone declare float** @foo(float) readnone
Show All 34 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s -check-prefix=CHECK ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s -check-prefix=CHECK
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x double] zeroinitializer, align 16 @B = common global [1024 x double] zeroinitializer, align 16
define void @simple_vec_const() nounwind { define void @simple_vec_const() nounwind {
bb: bb:
Show All 27 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_const(void) { ;void simple_vec_const(void) {
; int i; ; int i;
; ;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
define void @simple_vec_large_width() nounwind { define void @simple_vec_large_width() nounwind {
; <label>:0 ; <label>:0
Show All 31 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float**] zeroinitializer, align 16 @A = common global [1024 x float**] zeroinitializer, align 16
@B = common global [1024 x float**] zeroinitializer, align 16 @B = common global [1024 x float**] zeroinitializer, align 16
declare float @foo(float) readnone declare float @foo(float) readnone
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-codegen-isl %vector-opt -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-codegen-isl %vector-opt -S < %s | FileCheck %s
; ModuleID = 'reverse.c' ; ModuleID = 'reverse.c'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
;int A[100]; ;int A[100];
;void foo() { ;void foo() {
; for (int i=3; i >= 0; i--) ; for (int i=3; i >= 0; i--)
Show All 29 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
;#define N 1024 ;#define N 1024
;float A[N]; ;float A[N];
;float B[N]; ;float B[N];
; ;
;void simple_vec_stride_x(void) { ;void simple_vec_stride_x(void) {
; int i; ; int i;
; ;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-codegen-isl %vector-opt -dce -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 16 @A = common global [1024 x float] zeroinitializer, align 16
@B = common global [1024 x float] zeroinitializer, align 16 @B = common global [1024 x float] zeroinitializer, align 16
@C = common global [1024 x float] zeroinitializer, align 16 @C = common global [1024 x float] zeroinitializer, align 16
define void @simple_vec_stride_one() nounwind { define void @simple_vec_stride_one() nounwind {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;#include <stdio.h> ;#include <stdio.h>
;int A[N]; ;int A[N];
; ;
;void single_do_loop_int_max_iterations() { ;void single_do_loop_int_max_iterations() {
; int i; ; int i;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;define N 20 ;define N 20
;#include "limits.h" ;#include "limits.h"
;int A[N]; ;int A[N];
; ;
;void bar (int n) { ;void bar (int n) {
; int i; ; int i;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl < %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;long long A[N]; ;long long A[N];
; ;
;int main () { ;int main () {
; long long i; ; long long i;
; ;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
;#include <stdio.h> ;#include <stdio.h>
;int A[2 * N]; ;int A[2 * N];
; ;
;void single_do_loop_scev_replace() { ;void single_do_loop_scev_replace() {
; int i; ; int i;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s
;#define N 20 ;#define N 20
;#include "limits.h" ;#include "limits.h"
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze -S < %s | FileCheck %s
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; long long i; ; long long i;
; long long A[N]; ; long long A[N];
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
; A[0] = 0; ; A[0] = 0;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@A = common global [1024 x i32] zeroinitializer, align 16 ; <[1024 x i32]*> [#uses=3] @A = common global [1024 x i32] zeroinitializer, align 16 ; <[1024 x i32]*> [#uses=3]
define void @bar(i64 %n) nounwind { define void @bar(i64 %n) nounwind {
bb: bb:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -analyze -S < %s | FileCheck %s
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
; ;
; A[0] = 0; ; A[0] = 0;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @loop_with_condition() nounwind { define void @loop_with_condition() nounwind {
bb0: bb0:
fence seq_cst fence seq_cst
br label %bb1 br label %bb1
Show All 25 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -verify-region-info -verify-dom-info -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
define void @loop_with_condition() nounwind { define void @loop_with_condition() nounwind {
bb0: bb0:
fence seq_cst fence seq_cst
br label %bb1 br label %bb1
Show All 24 Lines

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

; RUN: opt %loadPolly -S -polly-code-generator=isl -polly-codegen-isl -verify-loop-info < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-code-generator=isl -polly-codegen-isl -verify-loop-info < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/bugs/show_bug.cgi?id=21167 ; Check that we do not crash as described here: http://llvm.org/bugs/show_bug.cgi?id=21167
; ;
; CHECK: polly.split_new_and_old ; CHECK: polly.split_new_and_old
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -S -polly-code-generator=isl -polly-codegen-isl < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -S -polly-code-generator=isl -polly-codegen-isl < %s | FileCheck %s
; ;
; Check that we do not crash as described here: http://llvm.org/PR21167 ; Check that we do not crash as described here: http://llvm.org/PR21167
; ;
; In case the pieceweise affine function used to create an isl_ast_expr ; In case the pieceweise affine function used to create an isl_ast_expr
; had empty cases (e.g., with contradicting constraints on the ; had empty cases (e.g., with contradicting constraints on the
; parameters), it was possible that the condition of the isl_ast_expr ; parameters), it was possible that the condition of the isl_ast_expr
; select was not a comparison but a constant (thus of type i64). ; select was not a comparison but a constant (thus of type i64).
; However, we shouldn't crash in such a case :) ; However, we shouldn't crash in such a case :)
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-ast -analyze -S < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;int bar1(); ;int bar1();
;int bar2(); ;int bar2();
;int bar3(); ;int bar3();
;int k; ;int k;
;#define N 100 ;#define N 100
;int A[N]; ;int A[N];
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -polly-ignore-aliasing < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -polly-ignore-aliasing < %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK: if (1) ; CHECK: if (1)
; CHECK: { ; CHECK: {
; CHECK: for (int c0 = 0; c0 <= -Scalar0.val.loadoutside + 99; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= -Scalar0.val.loadoutside + 99; c0 += 1)
; CHECK: Stmt_for_1(c0); ; CHECK: Stmt_for_1(c0);
; CHECK: if (Scalar0.val.loadoutside >= 100) ; CHECK: if (Scalar0.val.loadoutside >= 100)
Show All 31 Lines

polly/trunk/test/Isl/single_loop_param_less_equal.ll

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
%n_plus_one = add i64 %n, 1 %n_plus_one = add i64 %n, 1
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/trunk/test/Isl/single_loop_param_less_than.ll

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-codegen-isl -S < %s | FileCheck %s -check-prefix=CODEGEN
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/Isl/single_loop_uint_max_iterations.ll

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; unsigned int i; ; unsigned int i;
; unsigned int A[N]; ; unsigned int A[N];
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/Isl/single_loop_ull_max_iterations.ll

; RUN: opt %loadPolly -polly-no-early-exit -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-no-early-exit -polly-ast -S -analyze < %s | FileCheck %s
; XFAIL: * ; XFAIL: *
;#include "limits.h" ;#include "limits.h"
;#define N 20 ;#define N 20
; ;
;int main () { ;int main () {
; unsigned long long i; ; unsigned long long i;
; unsigned long long A[N]; ; unsigned long long A[N];
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/2012-03-16-Empty-Domain.ll

; RUN: opt %loadPolly -polly-opt-isl -S < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-opt-isl -S < %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
target triple = "hexagon-unknown-linux-gnu" target triple = "hexagon-unknown-linux-gnu"
define void @sdbout_label() nounwind { define void @sdbout_label() nounwind {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.cond, %entry for.cond: ; preds = %for.cond, %entry
%0 = phi i32 [ 0, %entry ], [ %1, %for.cond ] %0 = phi i32 [ 0, %entry ], [ %1, %for.cond ]
%1 = add nsw i32 %0, 1 %1 = add nsw i32 %0, 1
%exitcond72 = icmp eq i32 %1, 7 %exitcond72 = icmp eq i32 %1, 7
br i1 %exitcond72, label %sw.epilog66, label %for.cond br i1 %exitcond72, label %sw.epilog66, label %for.cond
sw.epilog66: ; preds = %for.cond sw.epilog66: ; preds = %for.cond
ret void ret void
} }

polly/trunk/test/ScheduleOptimizer/2012-04-16-Trivially-vectorizable-loops.ll

; RUN: opt %loadPolly -basicaa -polly-opt-isl %vector-opt < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-opt-isl %vector-opt < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] } %struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }
%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 } %struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }
@A = common global [1536 x [1536 x float]] zeroinitializer, align 16 @A = common global [1536 x [1536 x float]] zeroinitializer, align 16
@B = common global [1536 x [1536 x float]] zeroinitializer, align 16 @B = common global [1536 x [1536 x float]] zeroinitializer, align 16
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/2012-10-14-Zero-Bands.ll

; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-opt-isl -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1536 x float] zeroinitializer @A = common global [1536 x float] zeroinitializer
define void @read_nres() { define void @read_nres() {
entry: entry:
br label %if.cond br label %if.cond
Show All 18 Lines

polly/trunk/test/ScheduleOptimizer/2013-04-11-Empty-Domain-two.ll

; RUN: opt %loadPolly -polly-opt-isl -S < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-opt-isl -S < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Check that we handle statements with an empty iteration domain correctly. ; Check that we handle statements with an empty iteration domain correctly.
define void @f() { define void @f() {
entry: entry:
%A = alloca double %A = alloca double
Show All 15 Lines

polly/trunk/test/ScheduleOptimizer/computeout.ll

; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit < %s | FileCheck %s
; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-opt-isl -polly-opt-fusion=max -polly-ast -analyze -polly-no-early-exit -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-pc-linux-gnu" target triple = "x86_64-pc-linux-gnu"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
; ;
; for (i = 0; i < 10; i++ ) ; for (i = 0; i < 10; i++ )
; S2: A[i] = 5; ; S2: A[i] = 5;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/line-tiling-2.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=1,64 < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=1,64 < %s
; CHECK: c0 += 1 ; CHECK: c0 += 1
; CHECK: c1 += 64 ; CHECK: c1 += 64
; CHECK: c1 <= c1 + 63 ; CHECK: c1 <= c1 + 63
; ModuleID = 'line-tiling-2.ll' ; ModuleID = 'line-tiling-2.ll'
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @line([512 x i32]* %A) { define void @line([512 x i32]* %A) {
Show All 28 Lines

polly/trunk/test/ScheduleOptimizer/line-tiling.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=64,1 < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=64,1 < %s
; CHECK: c0 += 64 ; CHECK: c0 += 64
; CHECK: c1 += 1 ; CHECK: c1 += 1
; CHECK: c0 <= c0 + 63 ; CHECK: c0 <= c0 + 63
; ModuleID = 'line-tiling.ll' ; ModuleID = 'line-tiling.ll'
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
; Function Attrs: nounwind ; Function Attrs: nounwind
define void @line([512 x i32]* %A) { define void @line([512 x i32]* %A) {
Show All 28 Lines

polly/trunk/test/ScheduleOptimizer/prevectorization.ll

; RUN: opt -S %loadPolly -basicaa -polly-opt-isl -polly-vectorizer=polly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -polly-detect-unprofitable -basicaa -polly-opt-isl -polly-vectorizer=polly -polly-ast -analyze < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@C = common global [1536 x [1536 x float]] zeroinitializer, align 16 @C = common global [1536 x [1536 x float]] zeroinitializer, align 16
@A = common global [1536 x [1536 x float]] zeroinitializer, align 16 @A = common global [1536 x [1536 x float]] zeroinitializer, align 16
@B = common global [1536 x [1536 x float]] zeroinitializer, align 16 @B = common global [1536 x [1536 x float]] zeroinitializer, align 16
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/rectangular-tiling.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=256,16 < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-opt-isl -analyze -polly-no-tiling=0 -polly-ast -polly-tile-sizes=256,16 < %s
; CHECK: c0 += 256 ; CHECK: c0 += 256
; CHECK: c1 += 16 ; CHECK: c1 += 16
; CHECK: c0 <= c0 + 255 ; CHECK: c0 <= c0 + 255
; CHECK: c1 <= c1 + 15 ; CHECK: c1 <= c1 + 15
; ModuleID = 'rectangular-tiling.ll' ; ModuleID = 'rectangular-tiling.ll'
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
; Function Attrs: nounwind ; Function Attrs: nounwind
Show All 29 Lines

polly/trunk/test/ScopDetect/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c]; ; A[i] = B[c];
; } ; }
; ;
Show All 26 Lines

polly/trunk/test/ScopDetect/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B, int c) { ; void jd(int *A, int *B, int c) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[c - 10] + B[5]; ; A[i] = B[c - 10] + B[5];
; } ; }
; ;
Show All 30 Lines

polly/trunk/test/ScopDetect/aliasing_simple_1.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[0]; ; A[i] = B[0];
; } ; }
; ;
Show All 24 Lines

polly/trunk/test/ScopDetect/aliasing_simple_2.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = B[0] + B[1023]; ; A[i] = B[0] + B[1023];
; } ; }
; ;
Show All 27 Lines

polly/trunk/test/ScopDetect/base_pointer.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind { define void @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind {
entry: entry:
fence seq_cst fence seq_cst
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/cross_loop_non_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; else ; else
; for (j = 0; j < N; ++j) ; for (j = 0; j < N; ++j)
Show All 40 Lines

polly/trunk/test/ScopDetect/cross_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; else ; else
; for (j = 0; j < N; ++j) ; for (j = 0; j < N; ++j)
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/dependency_to_phi_node_outside_of_region.ll

; RUN: opt %loadPolly -polly-detect < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f(i64* %A, i64 %N, i64 %M) nounwind { define void @f(i64* %A, i64 %N, i64 %M) nounwind {
entry: entry:
fence seq_cst fence seq_cst
br label %for.i br label %for.i
Show All 25 Lines

polly/trunk/test/ScopDetect/indvars.ll

; RUN: opt %loadPolly -analyze -polly-detect -polly-codegen-isl < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -analyze -polly-detect -polly-codegen-isl < %s | FileCheck %s
; ;
; When a region header is part of a loop, then all entering edges of this region ; When a region header is part of a loop, then all entering edges of this region
; should not come from the loop but outside the region. ; should not come from the loop but outside the region.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @main(i64* %A) nounwind { define void @main(i64* %A) nounwind {
Show All 32 Lines

polly/trunk/test/ScopDetect/intrinsics_1.ll

; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: for.cond => for.end ; CHECK: Valid Region for Scop: for.cond => for.end
; ;
; #include "math.h" ; #include "math.h"
; ;
; void jd(int *restrict A, float *restrict B) { ; void jd(int *restrict A, float *restrict B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; A[i] = pow(ceil(log10(sqrt(i))), floor(log2(i))); ; A[i] = pow(ceil(log10(sqrt(i))), floor(log2(i)));
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/intrinsics_2.ll

; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify that we allow the lifetime markers for the tmp array. ; Verify that we allow the lifetime markers for the tmp array.
; ;
; CHECK: Valid Region for Scop: for.cond => for.end13 ; CHECK: Valid Region for Scop: for.cond => for.end13
; ;
; int A[1024]; ; int A[1024];
; void jd() { ; void jd() {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/intrinsics_3.ll

; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify that we allow the misc intrinsics. ; Verify that we allow the misc intrinsics.
; ;
; CHECK: Valid Region for Scop: for.cond => for.end13 ; CHECK: Valid Region for Scop: for.cond => for.end13
; ;
; int A[1024]; ; int A[1024];
; void jd() { ; void jd() {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/invalidate_scalar_evolution.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s -check-prefix=CHECK ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s -check-prefix=CHECK
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
Show All 34 Lines

polly/trunk/test/ScopDetect/keep_going_expansion.ll

; RUN: opt %loadPolly -basicaa -polly-detect-track-failures -polly-detect-keep-going -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect-track-failures -polly-detect-keep-going -polly-detect -analyze < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 { define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 {
entry: entry:
br label %entry.split br label %entry.split
Show All 37 Lines

polly/trunk/test/ScopDetect/multidim_two_accesses_different_delinearization.ll

; RUN: opt %loadPolly -polly-detect -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double *A) { ; void foo(long n, long m, double *A) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
Show All 36 Lines

polly/trunk/test/ScopDetect/nested_loop_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -polly-codegen-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -polly-codegen-isl -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i, j; ; long i, j;
; if (true) ; if (true)
; for (j = 0; j < N; ++j) ; for (j = 0; j < N; ++j)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 35 Lines

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

; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect-scops-in-regions-without-loops -polly-detect-scops-in-functions-without-loops -polly-detect -analyze < %s | FileCheck %s
; foo(float *A, long n, long k) { ; foo(float *A, long n, long k) {
; if (true) ; if (true)
; A[n * k] = 0; ; A[n * k] = 0;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
Show All 19 Lines

polly/trunk/test/ScopDetect/remove_all_children.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @remove_all_children(i32* %eclass) { define void @remove_all_children(i32* %eclass) {
entry: entry:
br label %while.body br label %while.body
Show All 36 Lines

polly/trunk/test/ScopDetect/report-scop-location.ll

; RUN: opt %loadPolly -polly-detect -polly-report -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -polly-report -disable-output < %s 2>&1 | FileCheck %s
target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128" target datalayout = "e-i64:64-f80:128-s:64-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @foo(float* %A) #0 { define void @foo(float* %A) #0 {
entry: entry:
br label %entry.split br label %entry.split
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/run_time_alias_check.ll

; RUN: opt %loadPolly -polly-detect -polly-code-generator=isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -polly-code-generator=isl -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare float* @getNextBasePtr(float*) readnone nounwind declare float* @getNextBasePtr(float*) readnone nounwind
define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) { define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) {
entry: entry:
Show All 27 Lines

polly/trunk/test/ScopDetect/sequential_loops.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Two sequential loops right after each other. ; Two sequential loops right after each other.
; ;
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/simple_loop.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
Show All 21 Lines

polly/trunk/test/ScopDetect/simple_loop_non_single_entry.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true) ; if (true)
; goto loop; ; goto loop;
; else ; else
; goto loop; ; goto loop;
Show All 36 Lines

polly/trunk/test/ScopDetect/simple_loop_non_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 25 Lines

polly/trunk/test/ScopDetect/simple_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; if (true) ; if (true)
; if (true) ; if (true)
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 26 Lines

polly/trunk/test/ScopDetect/simple_loop_two_phi_nodes.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; long i_non_canonical = 1; ; long i_non_canonical = 1;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = i_non_canonical; ; A[i] = i_non_canonical;
; i_non_canonical += 1; ; i_non_canonical += 1;
; } ; }
Show All 25 Lines

polly/trunk/test/ScopDetect/simple_loop_with_param.ll

; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N, long *init_ptr) { ; void f(long A[], long N, long *init_ptr) {
; long i, j; ; long i, j;
; long i_non_canonical; ; long i_non_canonical;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; i_non_canonical = init; ; i_non_canonical = init;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/simple_loop_with_param_2.ll

; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = init + 2; ; A[i] = init + 2;
Show All 38 Lines

polly/trunk/test/ScopDetect/simple_non_single_entry.ll

; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect-scops-in-regions-without-loops -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-detect-scops-in-regions-without-loops -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect-scops-in-regions-without-loops -polly-detect -analyze < %s | FileCheck %s
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; ;
; if (true){ ; if (true){
; i = 0; ; i = 0;
; goto next; ; goto next;
; }else{ ; }else{
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetect/skip_function_attribute.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; ;
; Verify polly skips this function ; Verify polly skips this function
; ;
; CHECK-NOT: Valid Region for Scop ; CHECK-NOT: Valid Region for Scop
; ;
; void polly_skip_me(int *A, int N) { ; void polly_skip_me(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = A[i] * A[i] + A[i]; ; A[i] = A[i] * A[i] + A[i];
Show All 35 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportAlias-01.ll

; RUN: opt %loadPolly -polly-use-runtime-alias-checks=false -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-use-runtime-alias-checks=false -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
;void f(int A[], int B[]) { ;void f(int A[], int B[]) {
; for (int i=0; i<42; i++) ; for (int i=0; i<42; i++)
; A[i] = B[i]; ; A[i] = B[i];
;} ;}
; CHECK: remark: ReportAlias-01.c:2:8: The following errors keep this region from being a Scop. ; CHECK: remark: ReportAlias-01.c:2:8: The following errors keep this region from being a Scop.
; CHECK: remark: ReportAlias-01.c:3:5: Accesses to the arrays "B", "A" may access the same memory. ; CHECK: remark: ReportAlias-01.c:3:5: Accesses to the arrays "B", "A" may access the same memory.
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportDifferentElementSize.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
; 1 void differenttypes(char *A) ; 1 void differenttypes(char *A)
; 2 { ; 2 {
; 3 for (long i = 0; i < 1024; ++i) ; 3 for (long i = 0; i < 1024; ++i)
; 4 ((float*)A)[i] = ((double*)A)[i]; ; 4 ((float*)A)[i] = ((double*)A)[i];
; 5 } ; 5 }
; CHECK: remark: /tmp/test.c:3:20: The following errors keep this region from being a Scop. ; CHECK: remark: /tmp/test.c:3:20: The following errors keep this region from being a Scop.
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportFuncCall-01.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1 | FileCheck %s
; #define N 1024 ; #define N 1024
; double invalidCall(double A[N]); ; double invalidCall(double A[N]);
; ;
; void a(double A[N], int n) { ; void a(double A[N], int n) {
; for (int i=0; i<n; ++i) { ; for (int i=0; i<n; ++i) {
; A[i] = invalidCall(A); ; A[i] = invalidCall(A);
; } ; }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportLoopBound-01.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
; void f(int A[], int n) { ; void f(int A[], int n) {
; for (int i = 0; i < A[n]; i++) ; for (int i = 0; i < A[n]; i++)
; A[i] = 0; ; A[i] = 0;
; } ; }
; CHECK: remark: ReportLoopBound-01.c:2:8: The following errors keep this region from being a Scop. ; CHECK: remark: ReportLoopBound-01.c:2:8: The following errors keep this region from being a Scop.
; CHECK: remark: ReportLoopBound-01.c:2:8: Failed to derive an affine function from the loop bounds. ; CHECK: remark: ReportLoopBound-01.c:2:8: Failed to derive an affine function from the loop bounds.
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportMultipleNonAffineAccesses.ll

; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=ALL ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=ALL
; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN
; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN-ALL ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN-ALL
; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-allow-nonaffine -analyze < %s 2>&1| FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-allow-nonaffine -analyze < %s 2>&1| FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -polly-allow-nonaffine -analyze < %s 2>&1| FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize -polly-allow-nonaffine -analyze < %s 2>&1| FileCheck %s -check-prefix=NONAFFINE
; 1 void manyaccesses(float A[restrict], long n, float B[restrict][n]) ; 1 void manyaccesses(float A[restrict], long n, float B[restrict][n])
; 2 { ; 2 {
; 3 for (long i = 0; i < 1024; ++i) { ; 3 for (long i = 0; i < 1024; ++i) {
; 4 float a1 = A[2 * i * i]; ; 4 float a1 = A[2 * i * i];
; 5 float a2 = A[2 * i * i + 1]; ; 5 float a2 = A[2 * i * i + 1];
; 6 float b1 = B[0][0]; ; 6 float b1 = B[0][0];
; 7 float b2 = B[i][i]; ; 7 float b2 = B[i][i];
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportNonAffineAccess-01.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
; void f(int A[]) { ; void f(int A[]) {
; for(int i=0; i<42; ++i) ; for(int i=0; i<42; ++i)
; A[i*i] = 0; ; A[i*i] = 0;
; } ; }
; CHECK: remark: ReportNonAffineAccess-01.c:2:7: The following errors keep this region from being a Scop. ; CHECK: remark: ReportNonAffineAccess-01.c:2:7: The following errors keep this region from being a Scop.
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/trunk/test/ScopDetectionDiagnostics/ReportUnprofitable.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
; void onlyWrite(float *A) {
; for (long i = 0; i < 100; i++)
; A[i] = 0;
; }
;
; void onlyRead(float *A) {
; for (long i = 0; i < 100; i++)
; A[i];
; }
; CHECK: remark: /tmp/test.c:2:3: The following errors keep this region from being a Scop.
; CHECK: remark: /tmp/test.c:3:10: Invalid Scop candidate ends here.
; CHECK: remark: /tmp/test.c:7:3: The following errors keep this region from being a Scop.
; CHECK: remark: /tmp/test.c:8:10: Invalid Scop candidate ends here.
; Function Attrs: nounwind uwtable
define void @onlyWrite(float* %A) #0 {
entry:
call void @llvm.dbg.value(metadata float* %A, i64 0, metadata !14, metadata !15), !dbg !16
call void @llvm.dbg.value(metadata i64 0, i64 0, metadata !17, metadata !15), !dbg !20
br label %for.cond, !dbg !21
for.cond: ; preds = %for.inc, %entry
%i.0 = phi i64 [ 0, %entry ], [ %inc, %for.inc ]
%exitcond = icmp ne i64 %i.0, 100, !dbg !22
br i1 %exitcond, label %for.body, label %for.end, !dbg !22
for.body: ; preds = %for.cond
%arrayidx = getelementptr inbounds float* %A, i64 %i.0, !dbg !23
store float 0.000000e+00, float* %arrayidx, align 4, !dbg !25
br label %for.inc, !dbg !23
for.inc: ; preds = %for.body
%inc = add nuw nsw i64 %i.0, 1, !dbg !26
call void @llvm.dbg.value(metadata i64 %inc, i64 0, metadata !17, metadata !15), !dbg !20
br label %for.cond, !dbg !27
for.end: ; preds = %for.cond
ret void, !dbg !28
}
; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: nounwind uwtable
define void @onlyRead(float* %A) #0 {
entry:
call void @llvm.dbg.value(metadata float* %A, i64 0, metadata !29, metadata !15), !dbg !30
call void @llvm.dbg.value(metadata i64 0, i64 0, metadata !31, metadata !15), !dbg !33
br label %for.cond, !dbg !34
for.cond: ; preds = %for.inc, %entry
%i.0 = phi i64 [ 0, %entry ], [ %inc, %for.inc ]
%exitcond = icmp ne i64 %i.0, 100, !dbg !35
br i1 %exitcond, label %for.body, label %for.end, !dbg !35
for.body: ; preds = %for.cond
%arrayidx = getelementptr inbounds float* %A, i64 %i.0, !dbg !36
%val = load float* %arrayidx, align 4, !dbg !38
br label %for.inc, !dbg !36
for.inc: ; preds = %for.body
%inc = add nuw nsw i64 %i.0, 1, !dbg !39
call void @llvm.dbg.value(metadata i64 %inc, i64 0, metadata !31, metadata !15), !dbg !33
br label %for.cond, !dbg !40
for.end: ; preds = %for.cond
ret void, !dbg !41
}
; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #1
attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone }
!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!11, !12}
!llvm.ident = !{!13}
!0 = !{!"0x11\0012\00clang version 3.7.0 (llvm/trunk 229257)\000\00\000\00\001", !1, !2, !2, !3, !2, !2} ; [ DW_TAG_compile_unit ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c] [DW_LANG_C99]
!1 = !{!"/tmp/test.c", !"/home/grosser/Projects/polly/git/tools/polly"}
!2 = !{}
!3 = !{!4, !10}
!4 = !{!"0x2e\00onlyWrite\00onlyWrite\00\001\000\001\000\000\00256\000\001", !1, !5, !6, null, void (float*)* @onlyWrite, null, null, !2} ; [ DW_TAG_subprogram ] [line 1] [def] [onlyWrite]
!5 = !{!"0x29", !1} ; [ DW_TAG_file_type ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c]
!6 = !{!"0x15\00\000\000\000\000\000\000", null, null, null, !7, null, null, null} ; [ DW_TAG_subroutine_type ] [line 0, size 0, align 0, offset 0] [from ]
!7 = !{null, !8}
!8 = !{!"0xf\00\000\0064\0064\000\000", null, null, !9} ; [ DW_TAG_pointer_type ] [line 0, size 64, align 64, offset 0] [from float]
!9 = !{!"0x24\00float\000\0032\0032\000\000\004", null, null} ; [ DW_TAG_base_type ] [float] [line 0, size 32, align 32, offset 0, enc DW_ATE_float]
!10 = !{!"0x2e\00onlyRead\00onlyRead\00\006\000\001\000\000\00256\000\006", !1, !5, !6, null, void (float*)* @onlyRead, null, null, !2} ; [ DW_TAG_subprogram ] [line 6] [def] [onlyRead]
!11 = !{i32 2, !"Dwarf Version", i32 4}
!12 = !{i32 2, !"Debug Info Version", i32 2}
!13 = !{!"clang version 3.7.0 (llvm/trunk 229257)"}
!14 = !{!"0x101\00A\0016777217\000", !4, !5, !8} ; [ DW_TAG_arg_variable ] [A] [line 1]
!15 = !{!"0x102"} ; [ DW_TAG_expression ]
!16 = !MDLocation(line: 1, column: 23, scope: !4)
!17 = !{!"0x100\00i\002\000", !18, !5, !19} ; [ DW_TAG_auto_variable ] [i] [line 2]
!18 = !{!"0xb\002\003\000", !1, !4} ; [ DW_TAG_lexical_block ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c]
!19 = !{!"0x24\00long int\000\0064\0064\000\000\005", null, null} ; [ DW_TAG_base_type ] [long int] [line 0, size 64, align 64, offset 0, enc DW_ATE_signed]
!20 = !MDLocation(line: 2, column: 13, scope: !18)
!21 = !MDLocation(line: 2, column: 8, scope: !18)
!22 = !MDLocation(line: 2, column: 3, scope: !18)
!23 = !MDLocation(line: 3, column: 5, scope: !24)
!24 = !{!"0xb\002\003\001", !1, !18} ; [ DW_TAG_lexical_block ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c]
!25 = !MDLocation(line: 3, column: 10, scope: !24)
!26 = !MDLocation(line: 2, column: 30, scope: !24)
!27 = !MDLocation(line: 2, column: 3, scope: !24)
!28 = !MDLocation(line: 4, column: 1, scope: !4)
!29 = !{!"0x101\00A\0016777222\000", !10, !5, !8} ; [ DW_TAG_arg_variable ] [A] [line 6]
!30 = !MDLocation(line: 6, column: 22, scope: !10)
!31 = !{!"0x100\00i\007\000", !32, !5, !19} ; [ DW_TAG_auto_variable ] [i] [line 7]
!32 = !{!"0xb\007\003\002", !1, !10} ; [ DW_TAG_lexical_block ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c]
!33 = !MDLocation(line: 7, column: 13, scope: !32)
!34 = !MDLocation(line: 7, column: 8, scope: !32)
!35 = !MDLocation(line: 7, column: 3, scope: !32)
!36 = !MDLocation(line: 8, column: 5, scope: !37)
!37 = !{!"0xb\007\003\003", !1, !32} ; [ DW_TAG_lexical_block ] [/home/grosser/Projects/polly/git/tools/polly//tmp/test.c]
!38 = !MDLocation(line: 8, column: 10, scope: !37)
!39 = !MDLocation(line: 7, column: 30, scope: !37)
!40 = !MDLocation(line: 7, column: 3, scope: !37)
!41 = !MDLocation(line: 9, column: 1, scope: !10)

polly/trunk/test/ScopDetectionDiagnostics/ReportVariantBasePtr-01.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s
; struct b { ; struct b {
; double **b; ; double **b;
; }; ; };
; ;
; void a(struct b *A) { ; void a(struct b *A) {
; for (int i=0; i<32; i++) ; for (int i=0; i<32; i++)
; A->b[i] = 0; ; A->b[i] = 0;
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @foo() declare void @foo()
define i32 @main(i8* %A) nounwind uwtable { define i32 @main(i8* %A) nounwind uwtable {
entry: entry:
br label %for.cond br label %for.cond
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
target triple = "hexagon-unknown-linux-gnu" target triple = "hexagon-unknown-linux-gnu"
@array = external global [64 x i8], align 8 @array = external global [64 x i8], align 8
define void @foo(i32* %A) nounwind { define void @foo(i32* %A) nounwind {
entry: entry:
Show All 23 Lines

polly/trunk/test/ScopInfo/Alias-0.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
%0 = tail call i32 (...)* @rnd() nounwind ; <i32> [#uses=1] %0 = tail call i32 (...)* @rnd() nounwind ; <i32> [#uses=1]
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
%0 = tail call i32 (...)* @rnd() nounwind ; <i32> [#uses=1] %0 = tail call i32 (...)* @rnd() nounwind ; <i32> [#uses=1]
Show All 28 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
define void @f(i32** nocapture %ptrs, i64 %p0, i64 %p1, i64 %p2) nounwind { define void @f(i32** nocapture %ptrs, i64 %p0, i64 %p1, i64 %p2) nounwind {
bb.nph: bb.nph:
%0 = getelementptr inbounds i32** %ptrs, i64 %p0 ; <i32**> [#uses=1] %0 = getelementptr inbounds i32** %ptrs, i64 %p0 ; <i32**> [#uses=1]
Show All 26 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
define void @f(i32* nocapture %a, i32* nocapture %b) nounwind { define void @f(i32* nocapture %a, i32* nocapture %b) nounwind {
bb.nph: bb.nph:
br label %bb br label %bb
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=RTA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-analyze-ir -polly-use-runtime-alias-checks=false -analyze < %s -stats 2>&1 | FileCheck %s --check-prefix=NORTA
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
define void @f(i32* noalias nocapture %a, i32* noalias nocapture %b) nounwind { define void @f(i32* noalias nocapture %a, i32* noalias nocapture %b) nounwind {
bb.nph: bb.nph:
br label %bb br label %bb
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : (N >= 0 and 5o0 >= -4 + N + 5i0 and 5o0 <= N + 5i0) or (N <= -1 and 5o0 >= N + 5i0 and 5o0 <= 4 + N + 5i0) }; ; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : (N >= 0 and 5o0 >= -4 + N + 5i0 and 5o0 <= N + 5i0) or (N <= -1 and 5o0 >= N + 5i0 and 5o0 <= 4 + N + 5i0) };
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : (N <= 0 and 5o0 <= -N + 5i0 and 5o0 >= -4 - N + 5i0) or (N >= 1 and 5o0 <= 4 - N + 5i0 and 5o0 >= -N + 5i0) }; ; CHECK: [N] -> { Stmt_for_body[i0] -> MemRef_A[o0] : (N <= 0 and 5o0 <= -N + 5i0 and 5o0 >= -4 - N + 5i0) or (N >= 1 and 5o0 <= 4 - N + 5i0 and 5o0 >= -N + 5i0) };
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
Show All 40 Lines

polly/trunk/test/ScopInfo/aliasing_conditional_alias_groups_1.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that there is no alias group because we either access A or B never both. ; Check that there is no alias group because we either access A or B never both.
; ;
; CHECK: Alias Groups (0): ; CHECK: Alias Groups (0):
; ;
; void jd(int b, int *A, int *B) { ; void jd(int b, int *A, int *B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (b) ; if (b)
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/aliasing_conditional_alias_groups_2.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s
; ;
; Check that we create two alias groups since the mininmal/maximal accesses ; Check that we create two alias groups since the mininmal/maximal accesses
; depend on %b. ; depend on %b.
; ;
; CHECK: Alias Groups (2): ; CHECK: Alias Groups (2):
; ;
; void jd(int b, int *A, int *B) { ; void jd(int b, int *A, int *B) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/aliasing_dead_access.ll

; RUN: opt %loadPolly -polly-code-generator=isl -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -analyze -polly-scops < %s | FileCheck %s
; ;
; Check that RTC generation does not die when accesses are dead. ; Check that RTC generation does not die when accesses are dead.
; ;
; CHECK: Alias Groups (0): ; CHECK: Alias Groups (0):
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; for (int j = i; j < 0; j++) ; for (int j = i; j < 0; j++)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

; RUN: opt %loadPolly -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8
; RUN: opt %loadPolly -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7 ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-code-generator=isl -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7
; ;
; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses. ; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A. ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
; ;
; MAX8: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd': ; MAX8: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
; MAX8-NEXT: Function: jd ; MAX8-NEXT: Function: jd
; MAX7: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd': ; MAX7: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/aliasing_multiple_alias_groups.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-code-generator=isl -polly-scops -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA
; ;
; void jd(int *Int0, int *Int1, float *Float0, float *Float1) { ; void jd(int *Int0, int *Int1, float *Float0, float *Float1) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; Int0[i] = Int1[i]; ; Int0[i] = Int1[i];
; Float0[i] = Float1[i]; ; Float0[i] = Float1[i];
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/assume_gep_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; void foo(float A[][20][30], long n, long m, long p) { ; void foo(float A[][20][30], long n, long m, long p) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < p; k++) ; for (long k = 0; k < p; k++)
; A[i][j][k] = i + j + k; ; A[i][j][k] = i + j + k;
; } ; }
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/assume_gep_bounds_2.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; void foo(float A[restrict][20], float B[restrict][20], long n, long m, ; void foo(float A[restrict][20], float B[restrict][20], long n, long m,
; long p) { ; long p) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; A[i][j] = i + j; ; A[i][j] = i + j;
; for (long i = 0; i < m; i++) ; for (long i = 0; i < m; i++)
; for (long j = 0; j < p; j++) ; for (long j = 0; j < p; j++)
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/bug_2010_10_22.ll

; RUN: opt %loadPolly -polly-analyze-ir < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define fastcc void @_Z8wavModelR5Mixer() { define fastcc void @_Z8wavModelR5Mixer() {
entry: entry:
br label %bb230 br label %bb230
Show All 37 Lines

polly/trunk/test/ScopInfo/bug_2011_1_5.ll

; RUN: opt %loadPolly -polly-analyze-ir -analyze < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir -analyze < %s
; Bug description: Alias Analysis thinks IntToPtrInst aliases with alloca instructions created by IndependentBlocks Pass. ; Bug description: Alias Analysis thinks IntToPtrInst aliases with alloca instructions created by IndependentBlocks Pass.
; This will trigger the assertion when we are verifying the SCoP after IndependentBlocks. ; This will trigger the assertion when we are verifying the SCoP after IndependentBlocks.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.precisionType = type { i16, i16, i16, i8, [1 x i16] } %struct.precisionType = type { i16, i16, i16, i8, [1 x i16] }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/bug_scev_not_fully_eval.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | not FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@edge.8265 = external global [72 x i32], align 32 ; <[72 x i32]*> [#uses=1] @edge.8265 = external global [72 x i32], align 32 ; <[72 x i32]*> [#uses=1]
define void @compact_unitcell_edges() nounwind { define void @compact_unitcell_edges() nounwind {
bb.nph19: bb.nph19:
br label %bb4 br label %bb4
Show All 26 Lines

polly/trunk/test/ScopInfo/cond_constant_in_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
;void f(long a[], long N, long M) { ;void f(long a[], long N, long M) {
; long i, j, k; ; long i, j, k;
; for (j = 0; j < M; ++j) ; for (j = 0; j < M; ++j)
; if (true) ; if (true)
; a[j] = j; ; a[j] = j;
; else { ; else {
; a[j] = M; ; a[j] = M;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/cond_in_loop.ll

; RUN: opt %loadPolly -polly-analyze-ir -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir -analyze < %s | not FileCheck %s
;void f(long a[], long N, long M) { ;void f(long a[], long N, long M) {
; long i, j, k; ; long i, j, k;
; for (j = 0; j < M; ++j) ; for (j = 0; j < M; ++j)
; if (N > j) ; if (N > j)
; a[j] = j; ; a[j] = j;
; else { ; else {
; a[j] = M; ; a[j] = M;
Show All 39 Lines

polly/trunk/test/ScopInfo/constant_start_integer.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(float *input) { ; void foo(float *input) {
; for (int j = 0; j < 8; j++) { ; for (int j = 0; j < 8; j++) {
; //SCoP begin ; //SCoP begin
; for (int i = 0; i < 63; i++) { ; for (int i = 0; i < 63; i++) {
; float x = input[j * 64 + i + 1]; ; float x = input[j * 64 + i + 1];
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %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 68 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/escaping_empty_scop.ll

; RUN: opt %loadPolly -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes -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/independent-blocks-never-stop-on-big-scop.ll

; RUN: opt %loadPolly -polly-independent < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-independent < %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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i32 @main() nounwind uwtable readnone { define i32 @main() nounwind uwtable readnone {
%arr = alloca [100 x i32], align 16 %arr = alloca [100 x i32], align 16
br label %1 br label %1
; <label>:1 ; preds = %1, %0 ; <label>:1 ; preds = %1, %0
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/integers.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; Check that we correctly convert integers to isl values. ; Check that we correctly convert integers to isl values.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Large positive integer ; Large positive integer
define void @f(i1024* nocapture %a) nounwind { define void @f(i1024* nocapture %a) nounwind {
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/isl_aff_out_of_bounds.ll

; RUN: opt %loadPolly -basicaa -polly-detect < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-detect < %s
; Used to fail with: ; Used to fail with:
; ../../isl/isl_aff.c:591: position out of bounds ; ../../isl/isl_aff.c:591: position out of bounds
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare double @frexp(double) declare double @frexp(double)
Show All 31 Lines

polly/trunk/test/ScopInfo/loop_affine_bound_0.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; void f(long a[][128], long N, long M) { ; void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = 0; i < (5*N + 2); ++i) ; for (i = 0; i < (5*N + 2); ++i)
; a[j][i] = 0 ; a[j][i] = 0
; } ; }
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/loop_affine_bound_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
;void f(long a[][128], long N, long M) { ;void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = j; i < (5*N + 2); ++i) ; for (i = j; i < (5*N + 2); ++i)
; ... ; ...
;} ;}
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/loop_affine_bound_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; void f(long a[][128], long N, long M) { ; void f(long a[][128], long N, long M) {
; long i, j; ; long i, j;
; for (j = 0; j < (4*N + 7*M +3); ++j) ; for (j = 0; j < (4*N + 7*M +3); ++j)
; for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i) ; for (i = (7*j + 6*M -9); i < (3*j + 5*N + 2) ; ++i)
; a[i][j] = 0; ; a[i][j] = 0;
; } ; }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/loop_carry.ll

; RUN: opt %loadPolly -basicaa -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-prepare -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"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
;long f(long a[], long n) { ;long f(long a[], long n) {
; long i, k; ; long i, k;
; k = 1; ; k = 1;
; for (i = 1; i < n; ++i) { ; for (i = 1; i < n; ++i) {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/max-loop-depth.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; void bar(); ; void bar();
; void foo(int *A, int *B, long int N, long int M) { ; void foo(int *A, int *B, long int N, long int M) {
; for (long int j = 0; j < M; ++j) { ; for (long int j = 0; j < M; ++j) {
; bar(); ; bar();
; for (long int i = 0; i < N; ++i) ; for (long int i = 0; i < N; ++i)
; A[i] += 1; ; A[i] += 1;
; for (long int i = 0; i < N; ++i) ; for (long int i = 0; i < N; ++i)
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multi-scop.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; This test case contains two scops. ; This test case contains two scops.
define void @test(i32 %l, double* %a) { define void @test(i32 %l, double* %a) {
entry: entry:
br label %entry.split br label %entry.split
Show All 28 Lines

polly/trunk/test/ScopInfo/multidim_2d-diagonal-matrix.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, double A[n][n]) { ; void foo(long n, double A[n][n]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[i][i] = 1.0; ; A[i][i] = 1.0;
Show All 34 Lines

polly/trunk/test/ScopInfo/multidim_2d_outer_parametric_offset.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, long p, double A[n][m]) { ; void foo(long n, long m, long p, double A[n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_2d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double A[n][m]) { ; void foo(long n, long m, double A[n][m]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 150; j++) ; for (long j = 0; j < 150; j++)
Show All 40 Lines

polly/trunk/test/ScopInfo/multidim_3d_parametric_array_static_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 150; j++) ; for (long j = 0; j < 150; j++)
; for (long k = 0; k < 200; k++) ; for (long k = 0; k < 200; k++)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_ivs_and_integer_offsets_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n-3; i++) ; for (long i = 0; i < n-3; i++)
; for (long j = 4; j < m; j++) ; for (long j = 4; j < m; j++)
; for (long k = 0; k < o-7; k++) ; for (long k = 0; k < o-7; k++)
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_ivs_and_parameteric_offsets_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) { ; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_nested_start_integer.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; for (long i = 0; i < n - 3; i++) ; for (long i = 0; i < n - 3; i++)
; for (long j = 4; j < m; j++) ; for (long j = 4; j < m; j++)
; for (long k = 0; k < o - 7; k++) ; for (long k = 0; k < o - 7; k++)
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_nested_start_share_parameter.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n-13; i++) ; for (long i = 0; i < n-13; i++)
; for (long j = 14; j < m; j++) ; for (long j = 14; j < m; j++)
; for (long k = 0; k < o-17; k++) { ; for (long k = 0; k < o-17; k++) {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_2d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Derived from the following code: ; Derived from the following code:
; ;
; void foo(long n, long m, double A[n][m]) { ; void foo(long n, long m, double A[n][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d_cast.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
; void foo(int n, int m, int o, double A[n][m][o]) { ; void foo(int n, int m, int o, double A[n][m][o]) {
; ;
; for (int i = 0; i < n; i++) ; for (int i = 0; i < n; i++)
; for (int j = 0; j < m; j++) ; for (int j = 0; j < m; j++)
; for (int k = 0; k < o; k++) ; for (int k = 0; k < o; k++)
; A[i][j][k] = 1.0; ; A[i][j][k] = 1.0;
; } ; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_only_ivs_3d_reverse.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-delinearize < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-delinearize < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; This test case checks for array access functions where the order in which the ; This test case checks for array access functions where the order in which the
; loop ivs appear in the array subscript does not follow the order of the ; loop ivs appear in the array subscript does not follow the order of the
; the loops in which they are defined. This (very common) case caused problems ; the loops in which they are defined. This (very common) case caused problems
; in the delinearization pass. ; in the delinearization pass.
; ;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/multidim_single_and_multidim_array.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-delinearize -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-delinearize -analyze < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-scops -polly-delinearize -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-delinearize -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; void single-and-multi-dimensional-array(long n,float X[n][n]) { ; void single-and-multi-dimensional-array(long n,float X[n][n]) {
; for (long i1 = 0; i1 < n; i1++) ; for (long i1 = 0; i1 < n; i1++)
; X[i1][0] = 1; ; X[i1][0] = 1;
; ;
; for (long i2 = 0; i2 < n; i2++) ; for (long i2 = 0; i2 < n; i2++)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/non_affine_access.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-delinearize -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-delinearize -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-delinearize -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-delinearize -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.2" target triple = "x86_64-apple-macosx10.7.2"
; void foo(long *A) { ; void foo(long *A) {
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i * i] = i; ; A[i * i] = i;
; ;
Show All 22 Lines

polly/trunk/test/ScopInfo/non_affine_parametric_loop.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze -polly-allow-nonaffine < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze -polly-allow-nonaffine < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; void foo(long n, double A[], int INDEX[]) { ; void foo(long n, double A[], int INDEX[]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[INDEX[i]] = i; ; A[INDEX[i]] = i;
; } ; }
Show All 28 Lines

polly/trunk/test/ScopInfo/parameter_product.ll

; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -S < %s | FileCheck %s
; ;
; int n, m; ; int n, m;
; void foo(char* __restrict a) ; void foo(char* __restrict a)
; { ; {
; for (int i = 0; i < n*m; ++i) ; for (int i = 0; i < n*m; ++i)
; a[i]=2; ; a[i]=2;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
Show All 22 Lines

polly/trunk/test/ScopInfo/phi_condition_modeling_1.ll

; RUN: opt %loadPolly -analyze -polly-scops -polly-model-phi-nodes < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -analyze -polly-scops -polly-model-phi-nodes < %s | FileCheck %s
; ;
; void f(int *A, int c, int N) { ; void f(int *A, int c, int N) {
; int tmp; ; int tmp;
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i > c) ; if (i > c)
; tmp = 3; ; tmp = 3;
; else ; else
; tmp = 5; ; tmp = 5;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_condition_modeling_2.ll

; RUN: opt %loadPolly -analyze -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -analyze -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes < %s | FileCheck %s
; ;
; void f(int *A, int c, int N) { ; void f(int *A, int c, int N) {
; int tmp; ; int tmp;
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i > c) ; if (i > c)
; tmp = 3; ; tmp = 3;
; else ; else
; tmp = 5; ; tmp = 5;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_conditional_simple_1.ll

; RUN: opt %loadPolly -analyze -polly-scops -polly-model-phi-nodes < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -analyze -polly-scops -polly-model-phi-nodes < %s | FileCheck %s
; ;
; void jd(int *A, int c) { ; void jd(int *A, int c) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (c) ; if (c)
; A[i] = 1; ; A[i] = 1;
; else ; else
; A[i] = 2; ; A[i] = 2;
; } ; }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_loop_carried_float.ll

; RUN: opt %loadPolly -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; ;
; float f(float *A, int N) { ; float f(float *A, int N) {
; float tmp = 0; ; float tmp = 0;
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; tmp += A[i]; ; tmp += A[i];
; } ; }
; ;
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_not_grouped_at_top.ll

; RUN: opt %loadPolly -polly-prepare -analyze < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-prepare -analyze < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
declare i32 @funa() align 2 declare i32 @funa() align 2
declare i32 @generic_personality_v0(i32, i64, i8*, i8*) declare i32 @generic_personality_v0(i32, i64, i8*, i8*)
define void @funb() align 2 { define void @funb() align 2 {
Show All 20 Lines

polly/trunk/test/ScopInfo/phi_scalar_simple_1.ll

; RUN: opt %loadPolly -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; ;
; int jd(int *restrict A, int x, int N) { ; int jd(int *restrict A, int x, int N) {
; for (int i = 1; i < N; i++) ; for (int i = 1; i < N; i++)
; for (int j = 3; j < N; j++) ; for (int j = 3; j < N; j++)
; x += A[i]; ; x += A[i];
; return x; ; return x;
; } ; }
; ;
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-model-phi-nodes -disable-polly-intra-scop-scalar-to-array -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 105 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/phi_with_invoke_edge.ll

; RUN: opt %loadPolly -polly-prepare -polly-detect -analyze < %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-prepare -polly-detect -analyze < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu" target triple = "x86_64-linux-gnu"
declare i32 @generic_personality_v0(i32, i64, i8*, i8*) declare i32 @generic_personality_v0(i32, i64, i8*, i8*)
define i16 @v() { define i16 @v() {
entry: entry:
br i1 undef, label %bb16, label %invcont12 br i1 undef, label %bb16, label %invcont12
Show All 18 Lines

polly/trunk/test/ScopInfo/pointer-type-expressions.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; void f(int a[], int N, float *P) { ; void f(int a[], int N, float *P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (*P != 0) ; if (*P != 0)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 40 Lines

polly/trunk/test/ScopInfo/reduction_alternating_base.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; FIXME: We cannot detect this SCoP yet but as soon as we can we should check ; FIXME: We cannot detect this SCoP yet but as soon as we can we should check
; that the reduction is detected! ; that the reduction is detected!
; ;
; CHECK-NOT: Scattering ; CHECK-NOT: Scattering
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
Show All 29 Lines

polly/trunk/test/ScopInfo/reduction_chain_partially_outside_the_scop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; ;
; int c, d; ; int c, d;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; *sum = c + d; ; *sum = c + d;
; } ; }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 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-detect-unprofitable -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.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int N, int * restrict sums, int * restrict escape) { ; void f(int N, int * restrict sums, int * restrict escape) {
; int i, j; ; int i, j;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; for (j = 0; j < 1024; j++) { ; for (j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; escape[N - i + j] = sums[i]; ; escape[N - i + j] = sums[i];
; } ; }
▲ Show 20 Lines • Show All 53 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 -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; void f(int N, int * restrict sums, int * restrict escape) { ; void f(int N, int * restrict sums, int * restrict escape) {
; int i, j; ; int i, j;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; for (j = 0; j < 1024; j++) { ; for (j = 0; j < 1024; j++) {
; sums[i] += 5; ; sums[i] += 5;
; escape[N-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_different_operators.ll

; RUN: opt %loadPolly -basicaa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-scops -analyze < %s | FileCheck %s
; ;
; int f() { ; int f() {
; int i, sum = 0, sth = 0; ; int i, sum = 0, sth = 0;
; for (i = 0; i < 1024; i++) { ; for (i = 0; i < 1024; i++) {
; sum += 5; ; sum += 5;
; sth = sth + sth * sth + sth; ; sth = sth + sth * sth + sth;
; sum *= 5; ; sum *= 5;
; } ; }
▲ Show 20 Lines • Show All 41 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-detect-unprofitable -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_loops_array_sum.ll

; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: MemRef_sum ; CHECK: MemRef_sum
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: MemRef_sum ; CHECK: MemRef_sum
; CHECK: Stmt_for_body3 ; CHECK: Stmt_for_body3
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_multiple_loops_array_sum_1.ll

; RUN: opt -basicaa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basicaa %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: MemRef_sum_04 ; CHECK: MemRef_sum_04
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: MemRef_sum_12 ; CHECK: MemRef_sum_12
; CHECK: Stmt_for_inc ; CHECK: Stmt_for_inc
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
▲ Show 20 Lines • Show All 63 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-detect-unprofitable -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/reduction_non_overlapping_chains.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; CHECK: Reduction Type: * ; CHECK: Reduction Type: *
; ;
; void f(int *sums) { ; void f(int *sums) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_only_reduction_like_access.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; sum[i] = sum[99-i] + i; ; sum[i] = sum[99-i] + i;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
Show All 26 Lines

polly/trunk/test/ScopInfo/reduction_simple_fp.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Function: f_no_fast_math ; CHECK: Function: f_no_fast_math
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; CHECK: Function: f_fast_math ; CHECK: Function: f_fast_math
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(float *sum) { ; void f(float *sum) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/reduction_simple_w_constant.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(int *sum) { ; void f(int *sum) {
; for (int i = 0; i <= 100; i++) ; for (int i = 0; i <= 100; i++)
; sum += 3; ; sum += 3;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
Show All 17 Lines

polly/trunk/test/ScopInfo/reduction_simple_w_iv.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: + ; CHECK: Reduction Type: +
; ;
; void f(int* sum) { ; void f(int* sum) {
; for (int i = 0; i <= 100; i++) ; for (int i = 0; i <= 100; i++)
; sum += i * 3; ; sum += i * 3;
; } ; }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"
Show All 18 Lines

polly/trunk/test/ScopInfo/reduction_two_identical_reads.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; ;
; CHECK: Reduction Type: NONE ; CHECK: Reduction Type: NONE
; ;
; Check that we do not mark these accesses as reduction like. ; Check that we do not mark these accesses as reduction like.
; We do this for the case the loads are modelt with the same LLVM-IR value and ; We do this for the case the loads are modelt with the same LLVM-IR value and
; for the case there are different LLVM-IR values. ; for the case there are different LLVM-IR values.
; ;
; void f(int *A) { ; void f(int *A) {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/run-time-check-many-parameters.ll

; RUN: opt %loadPolly -polly-scops -polly-code-generator=isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -polly-code-generator=isl -analyze < %s | FileCheck %s
; ;
; A valid Scop would print the list of it's statements, we check that we do not ; A valid Scop would print the list of it's statements, we check that we do not
; see that list. ; see that list.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
; FIXME: Handling this is an open problem, at the moment we just bail out. ; FIXME: Handling this is an open problem, at the moment we just bail out.
; ;
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/run-time-check-read-only-arrays.ll

; RUN: opt %loadPolly -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-code-generator=isl -polly-scops -analyze < %s | FileCheck %s
; ;
; void foo(float *A, float *B, float *C, long N) { ; void foo(float *A, float *B, float *C, long N) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; C[i] = A[i] + B[i]; ; C[i] = A[i] + B[i];
; } ; }
; ;
; CHECK: Alias Groups (2): ; CHECK: Alias Groups (2):
; ;
Show All 24 Lines

polly/trunk/test/ScopInfo/scalar.ll

; RUN: opt %loadPolly -polly-scops -analyze -disable-polly-intra-scop-scalar-to-array < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -disable-polly-intra-scop-scalar-to-array < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f(i64* %a, i64 %N) { define void @f(i64* %a, i64 %N) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/scalar_dependence_cond_br.ll

; RUN: opt %loadPolly -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -disable-polly-intra-scop-scalar-to-array -polly-model-phi-nodes -analyze < %s | FileCheck %s
; ;
; void f(int *A, int c, int d) { ; void f(int *A, int c, int d) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (c < i) ; if (c < i)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Stmt_for_cond ; CHECK: Stmt_for_cond
Show All 38 Lines

polly/trunk/test/ScopInfo/simple_loop_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
; void f(int a[], int N) { ; void f(int a[], int N) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; a[i] = i; ; a[i] = i;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
Show All 28 Lines

polly/trunk/test/ScopInfo/simple_nonaffine_loop_not.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | not FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.2" target triple = "x86_64-apple-macosx10.7.2"
@.str = private unnamed_addr constant [17 x i8] c"Random Value: %d\00", align 1 @.str = private unnamed_addr constant [17 x i8] c"Random Value: %d\00", align 1
define i32 @main() nounwind uwtable ssp { define i32 @main() nounwind uwtable ssp {
entry: entry:
%A = alloca [1048576 x i32], align 16 %A = alloca [1048576 x i32], align 16
Show All 31 Lines

polly/trunk/test/ScopInfo/smax.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64"
target triple = "thumbv7-none-linux-gnueabi" target triple = "thumbv7-none-linux-gnueabi"
define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) { define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
Show All 17 Lines

polly/trunk/test/ScopInfo/undef_in_cond.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define fastcc void @fix_operands() nounwind { define fastcc void @fix_operands() nounwind {
entry: entry:
br i1 undef, label %bb3, label %bb1 br i1 undef, label %bb3, label %bb1
bb1: ; preds = %bb bb1: ; preds = %bb
Show All 14 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze -polly-allow-unsigned < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze -polly-allow-unsigned < %s | FileCheck %s
; void f(int a[], int N, unsigned P) { ; void f(int a[], int N, unsigned P) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; if (P > 42) ; if (P > 42)
; a[i] = i; ; a[i] = i;
; } ; }
Show All 38 Lines

polly/trunk/test/TempScop/inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = init + 2; ; A[i] = init + 2;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/trunk/test/TempScop/intra_and_inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init2 = *init_ptr; ; init2 = *init_ptr;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/trunk/test/TempScop/intra_bb_scalar_dep.ll

; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; A[i] = init + 2; ; A[i] = init + 2;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -analyze < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @f(i64* nocapture %a) nounwind { define void @f(i64* nocapture %a) nounwind {
entry: entry:
br label %for.i br label %for.i
Show All 24 Lines

polly/trunk/test/TempScop/not-a-reduction.ll

; RUN: opt %loadPolly -polly-analyze-ir -analyze < %s 2>&1 | not FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-analyze-ir -analyze < %s 2>&1 | not FileCheck %s
;#define TYPE float ;#define TYPE float
;#define NUM 4 ;#define NUM 4
; ;
;TYPE A[NUM]; ;TYPE A[NUM];
;TYPE B[NUM]; ;TYPE B[NUM];
;TYPE C[NUM]; ;TYPE C[NUM];
; ;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/trunk/test/TempScop/scalar_to_array.ll

; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -disable-polly-intra-scop-scalar-to-array -analyze < %s | FileCheck %s
; ModuleID = 'scalar_to_array.ll' ; ModuleID = 'scalar_to_array.ll'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = common global [1024 x float] zeroinitializer, align 8 @A = common global [1024 x float] zeroinitializer, align 8
; CHECK: empty ; CHECK: empty
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basicaa -polly-analyze-ir -analyze -disable-polly-intra-scop-scalar-to-array < %s | FileCheck %s -check-prefix=SCALARACCESS ; RUN: opt %loadPolly -polly-detect-unprofitable -basicaa -polly-analyze-ir -analyze -disable-polly-intra-scop-scalar-to-array < %s | FileCheck %s -check-prefix=SCALARACCESS
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; A[i] = init + 2; ; A[i] = init + 2;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/trunk/test/polly.ll

; RUN: opt %loadPolly -polly-scops -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-detect-unprofitable -polly-scops -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define void @foo() nounwind { define void @foo() nounwind {
start: start:
br label %end br label %end
end: end:
ret void ret void
} }
; CHECK: foo ; CHECK: foo