This is an archive of the discontinued LLVM Phabricator instance.

Differential D120782

[polly] Introduce -polly-print-* passes to replace -analyze.
ClosedPublic

Authored by Meinersbur on Mar 1 2022, 3:43 PM.

Details

Reviewers
aeubanks
bollu
Commits
rG5c0280813185: [polly] Introduce -polly-print-* passes to replace -analyze.
Summary

The opt -analyze option only works with the legacy pass manager and might be removed in the future, as explained in llvm.org/PR53733. This patch introduced -polly-print-* passes that print what the pass would print with the -analyze option and replaces all uses of -analyze in the regression tests.

There are two exceptions: CodeGen\single_loop_param_less_equal.ll and CodeGen\loop_with_condition_nested.ll use -analyze on the -loops` pass which is not part of Polly.

Diff Detail

Event Timeline

Meinersbur created this revision.Mar 1 2022, 3:43 PM
Herald added a reviewer: bollu. · View Herald TranscriptMar 1 2022, 3:43 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: bmahjour, asbirlea, arphaman, zzheng. · View Herald Transcript
Meinersbur requested review of this revision.Mar 1 2022, 3:43 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 1 2022, 3:43 PM
Meinersbur retitled this revision from [polly] Introduce -polly-print-* passes to replace -analyze to [polly] Introduce -polly-print-* passes to replace -analyze..Mar 1 2022, 3:44 PM
Harbormaster completed remote builds in B152072: Diff 412275.Mar 1 2022, 4:22 PM
aeubanks added a comment.Mar 2 2022, 11:38 AM

for the remaining -analyze -loops tests, do the polly passes in those tests have new PM equivalents?
-passes='print<loops>' should be a suitable replacement for -loops -analyze

aeubanks accepted this revision.Mar 2 2022, 11:38 AM
This revision is now accepted and ready to land.Mar 2 2022, 11:38 AM
Meinersbur added a comment.Mar 2 2022, 1:58 PM
In D120782#3355237, @aeubanks wrote:

for the remaining -analyze -loops tests, do the polly passes in those tests have new PM equivalents?
-passes='print<loops>' should be a suitable replacement for -loops -analyze

CodeGen/single_loop_param_less_equal.ll
; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
CodeGen\loop_with_condition_nested.ll
; RUN: opt %loadPolly -basic-aa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS

-polly-codegen does not emit anything with -analyze. It is testing which loops after -polly-codegen. Therefore, this could be equivalent using the NPM:

; RUN: opt %loadPolly -passes="function(scop(polly-codegen),print<loops>)" -disable-output < %s 2>&1 | FileCheck %s -check-prefix=LOOPS

However, it is failing due to how differently the NPM works.

aeubanks added a comment.Mar 9 2022, 12:08 AM
In D120782#3355541, @Meinersbur wrote:
In D120782#3355237, @aeubanks wrote:

for the remaining -analyze -loops tests, do the polly passes in those tests have new PM equivalents?
-passes='print<loops>' should be a suitable replacement for -loops -analyze

CodeGen/single_loop_param_less_equal.ll
; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
CodeGen\loop_with_condition_nested.ll
; RUN: opt %loadPolly -basic-aa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS

-polly-codegen does not emit anything with -analyze. It is testing which loops after -polly-codegen. Therefore, this could be equivalent using the NPM:

; RUN: opt %loadPolly -passes="function(scop(polly-codegen),print<loops>)" -disable-output < %s 2>&1 | FileCheck %s -check-prefix=LOOPS

However, it is failing due to how differently the NPM works.

based on local testing even something like opt %loadPolly -basic-aa -polly-codegen < %s | opt -enable-new-pm=0 -loops -analyze fails the same way. even opt %loadPolly -basic-aa -polly-codegen -barrier -loops -analyze does the same thing, so it seems like some sort of interaction between the scheduling of Region passes and the loop printing
-debug-pass=Structure doesn't show anything suspicious though

Pass Arguments:  -targetlibinfo -tti -assumption-cache-tracker -profile-summary-info -domtree -basic-aa -loops -postdomtree -domfrontier -regions -scalar-evolution -lazy-branch-prob -lazy-block-freq -opt-remark-emitter -aa -polly-detect -polly-scops -polly-dependences -polly-ast -polly-codegen -verify
Target Library Information
Target Transform Information
Assumption Cache Tracker
Profile summary info
  ModulePass Manager
    FunctionPass Manager
      Dominator Tree Construction
      Basic Alias Analysis (stateless AA impl)
      FunctionPass Printer: Basic Alias Analysis (stateless AA impl)
      Natural Loop Information
      Post-Dominator Tree Construction
      Dominance Frontier Construction
      Detect single entry single exit regions
      Scalar Evolution Analysis
      Lazy Branch Probability Analysis
      Lazy Block Frequency Analysis
      Optimization Remark Emitter
      Function Alias Analysis Results
      Polly - Detect static control parts (SCoPs)
      Region Pass Manager
        Polly - Create polyhedral description of Scops
        Polly - Calculate dependences
        Polly - Generate an AST from the SCoP (isl)
        Polly - Create LLVM-IR from SCoPs
        RegionPass Printer: Polly - Create LLVM-IR from SCoPs
      FunctionPass Printer: Natural Loop Information
      Module Verifier

and verifying the loop info doesn't show any issues

This revision was landed with ongoing or failed builds.Mar 14 2022, 8:28 AM
Closed by commit rG5c0280813185: [polly] Introduce -polly-print-* passes to replace -analyze. (authored by Meinersbur). · Explain Why
This revision was automatically updated to reflect the committed changes.
Meinersbur added a commit: rG5c0280813185: [polly] Introduce -polly-print-* passes to replace -analyze..
Meinersbur added a comment.Mar 15 2022, 9:20 PM
In D120782#3369286, @aeubanks wrote:

based on local testing even something like opt %loadPolly -basic-aa -polly-codegen < %s | opt -enable-new-pm=0 -loops -analyze fails the same way. even opt %loadPolly -basic-aa -polly-codegen -barrier -loops -analyze does the same thing

LoopInfo just prints the blocks it contains as they appear in the LoopBase::Blocks vector. The order is different between the depth-first order when LoopInfo is constructed from scratch, versus when preserved by adding/removing elements from the list. LoopBase::verifyLoop allows Blocks to be in a different order.

aeubanks mentioned this in D122195: [polly] Remove last instances of -analyze.Mar 21 2022, 5:42 PM
aeubanks mentioned this in rGcaf6af2ed77b: [polly] Remove last instances of -analyze.Mar 24 2022, 9:48 AM

Revision Contents

PathSize
llvm/
tools/
opt/
8 lines
polly/
include/
polly/
CodeGen/
8 lines
2 lines
11 lines
3 lines
8 lines
10 lines
50 lines
3 lines
4 lines
11 lines
16 lines
2 lines
lib/
Analysis/
99 lines
49 lines
47 lines
101 lines
CodeGen/
46 lines
Exchange/
46 lines
Support/
13 lines
Transform/
42 lines
45 lines
42 lines
50 lines
46 lines
test/
CodeGen/
4 lines
2 lines
MemAccess/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
OpenMP/
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
7 lines
6 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
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
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
8 lines
2 lines
DeLICM/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
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
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
DeadCodeElimination/
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
DependenceInfo/
8 lines
8 lines
8 lines
6 lines
2 lines
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
FlattenSchedule/
2 lines
ForwardOpTree/
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
2 lines
2 lines
2 lines
2 lines
2 lines
GPGPU/
2 lines
2 lines
2 lines
4 lines
3 lines
3 lines
3 lines
3 lines
2 lines
6 lines
4 lines
8 lines
2 lines
3 lines
3 lines
3 lines
2 lines
2 lines
4 lines
3 lines
2 lines
IstAstInfo/
OpenMP/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
10 lines
12 lines
10 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 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
3 lines
4 lines
7 lines
2 lines
2 lines
JSONExporter/
ImportAccesses/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ImportArrays/
2 lines
2 lines
2 lines
2 lines
2 lines
ImportContext/
2 lines
2 lines
2 lines
2 lines
ImportSchedule/
2 lines
2 lines
2 lines
2 lines
MaximalStaticExpansion/
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
ScheduleOptimizer/
2 lines
GreedyFuse/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
ManualOptimization/
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
27 lines
2 lines
4 lines
8 lines
2 lines
4 lines
3 lines
2 lines
6 lines
2 lines
4 lines
9 lines
7 lines
8 lines
14 lines
8 lines
8 lines
8 lines
8 lines
8 lines
10 lines
4 lines
14 lines
28 lines
2 lines
2 lines
ScopDetect/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
3 lines
2 lines
3 lines
3 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
12 lines
2 lines
2 lines
2 lines
6 lines
9 lines
2 lines
2 lines
2 lines
2 lines
4 lines
3 lines
3 lines
11 lines
13 lines
13 lines
24 lines
3 lines
3 lines
3 lines
8 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
7 lines
3 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
3 lines
ScopDetectionDiagnostics/
2 lines
4 lines
2 lines
4 lines
4 lines
6 lines
4 lines
12 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
ScopInfo/
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
BoundChecks/
4 lines
4 lines
NonAffine/
2 lines
2 lines
3 lines
2 lines
2 lines
10 lines
13 lines
12 lines
2 lines
2 lines
3 lines
3 lines
8 lines
12 lines
3 lines
18 lines
10 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
6 lines
2 lines
6 lines
2 lines
6 lines
2 lines
6 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
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
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
4 lines
4 lines
2 lines
2 lines
4 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
6 lines
4 lines
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
2 lines
6 lines
6 lines
6 lines
6 lines
2 lines
2 lines
2 lines
3 lines
4 lines
2 lines
2 lines
12 lines
12 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
12 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
16 lines
2 lines
2 lines
4 lines
6 lines
4 lines
4 lines
3 lines
3 lines
4 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
3 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
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
3 lines
3 lines
7 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
3 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
3 lines
4 lines
2 lines
2 lines
2 lines
3 lines
2 lines
7 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
3 lines
2 lines
2 lines
2 lines
2 lines
8 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
3 lines
3 lines
2 lines
ScopInliner/
2 lines
2 lines
2 lines
Simplify/
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
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

Diff 415100

llvm/tools/opt/opt.cpp

Show First 20 Lines • Show All 492 Lines • ▼ Show 20 Lines std::vector<StringRef> PassNameExact = {
"atomic-expand", "expandvp", "atomic-expand", "expandvp",
"hardware-loops", "type-promotion", "hardware-loops", "type-promotion",
"mve-tail-predication", "interleaved-access", "mve-tail-predication", "interleaved-access",
"global-merge", "pre-isel-intrinsic-lowering", "global-merge", "pre-isel-intrinsic-lowering",
"expand-reductions", "indirectbr-expand", "expand-reductions", "indirectbr-expand",
"generic-to-nvvm", "expandmemcmp", "generic-to-nvvm", "expandmemcmp",
"loop-reduce", "lower-amx-type", "loop-reduce", "lower-amx-type",
"pre-amx-config", "lower-amx-intrinsics", "pre-amx-config", "lower-amx-intrinsics",
"polyhedral-info", "replace-with-veclib", "polyhedral-info", "print-polyhedral-info",
"jmc-instrument", "dot-regions", "replace-with-veclib", "jmc-instrument",
"dot-regions-only", "view-regions", "dot-regions", "dot-regions-only",
"view-regions-only"}; "view-regions", "view-regions-only"};
for (const auto &P : PassNamePrefix) for (const auto &P : PassNamePrefix)
if (Pass.startswith(P)) if (Pass.startswith(P))
return true; return true;
for (const auto &P : PassNameContain) for (const auto &P : PassNameContain)
if (Pass.contains(P)) if (Pass.contains(P))
return true; return true;
return llvm::is_contained(PassNameExact, Pass); return llvm::is_contained(PassNameExact, Pass);
} }
▲ Show 20 Lines • Show All 582 Lines • Show Last 20 Lines

polly/include/polly/CodeGen/IslAst.h

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Linespublic:
/// Release the internal memory. /// Release the internal memory.
void releaseMemory() override; void releaseMemory() override;
/// Print a source code representation of the program. /// Print a source code representation of the program.
void printScop(raw_ostream &OS, Scop &S) const override; void printScop(raw_ostream &OS, Scop &S) const override;
}; };
llvm::Pass *createIslAstInfoWrapperPassPass();
llvm::Pass *createIslAstInfoPrinterLegacyPass(llvm::raw_ostream &OS);
struct IslAstPrinterPass : public PassInfoMixin<IslAstPrinterPass> { struct IslAstPrinterPass : public PassInfoMixin<IslAstPrinterPass> {
IslAstPrinterPass(raw_ostream &OS) : OS(OS) {} IslAstPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM, PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &, SPMUpdater &U); ScopStandardAnalysisResults &, SPMUpdater &U);
raw_ostream &OS; raw_ostream &OS;
}; };
} // namespace polly } // namespace polly
namespace llvm {
void initializeIslAstInfoWrapperPassPass(llvm::PassRegistry &);
void initializeIslAstInfoPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm
#endif // POLLY_ISLAST_H #endif // POLLY_ISLAST_H

polly/include/polly/DeLICM.h

Show All 23 Lines
class PassRegistry; class PassRegistry;
class Pass; class Pass;
class raw_ostream; class raw_ostream;
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
/// Create a new DeLICM pass instance. /// Create a new DeLICM pass instance.
llvm::Pass *createDeLICMWrapperPass(); llvm::Pass *createDeLICMWrapperPass();
llvm::Pass *createDeLICMPrinterLegacyPass(llvm::raw_ostream &OS);
struct DeLICMPass : llvm::PassInfoMixin<DeLICMPass> { struct DeLICMPass : llvm::PassInfoMixin<DeLICMPass> {
DeLICMPass() {} DeLICMPass() {}
llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM, llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, SPMUpdater &U); ScopStandardAnalysisResults &SAR, SPMUpdater &U);
}; };
Show All 17 Linesbool isConflicting(isl::union_set ExistingOccupied,
isl::union_set ProposedUnused, isl::union_map ProposedKnown, isl::union_set ProposedUnused, isl::union_map ProposedKnown,
isl::union_map ProposedWrites, isl::union_map ProposedWrites,
llvm::raw_ostream *OS = nullptr, unsigned Indent = 0); llvm::raw_ostream *OS = nullptr, unsigned Indent = 0);
} // namespace polly } // namespace polly
namespace llvm { namespace llvm {
void initializeDeLICMWrapperPassPass(llvm::PassRegistry &); void initializeDeLICMWrapperPassPass(llvm::PassRegistry &);
void initializeDeLICMPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif /* POLLY_DELICM_H */ #endif /* POLLY_DELICM_H */

polly/include/polly/DependenceInfo.h

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines
private: private:
Scop *S; Scop *S;
/// Dependences struct for the current SCoP. /// Dependences struct for the current SCoP.
std::unique_ptr<Dependences> D[Dependences::NumAnalysisLevels]; std::unique_ptr<Dependences> D[Dependences::NumAnalysisLevels];
}; };
llvm::Pass *createDependenceInfoPass();
llvm::Pass *createDependenceInfoPrinterLegacyPass(llvm::raw_ostream &OS);
/// Construct a new DependenceInfoWrapper pass. /// Construct a new DependenceInfoWrapper pass.
class DependenceInfoWrapperPass : public FunctionPass { class DependenceInfoWrapperPass : public FunctionPass {
public: public:
static char ID; static char ID;
/// Construct a new DependenceInfoWrapper pass. /// Construct a new DependenceInfoWrapper pass.
DependenceInfoWrapperPass() : FunctionPass(ID) {} DependenceInfoWrapperPass() : FunctionPass(ID) {}
Show All 23 Linespublic:
void getAnalysisUsage(AnalysisUsage &AU) const override; void getAnalysisUsage(AnalysisUsage &AU) const override;
private: private:
using ScopToDepsMapTy = DenseMap<Scop *, std::unique_ptr<Dependences>>; using ScopToDepsMapTy = DenseMap<Scop *, std::unique_ptr<Dependences>>;
/// Scop to Dependence map for the current function. /// Scop to Dependence map for the current function.
ScopToDepsMapTy ScopToDepsMap; ScopToDepsMapTy ScopToDepsMap;
}; };
llvm::Pass *createDependenceInfoWrapperPassPass();
llvm::Pass *
createDependenceInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS);
} // namespace polly } // namespace polly
namespace llvm { namespace llvm {
void initializeDependenceInfoPass(llvm::PassRegistry &); void initializeDependenceInfoPass(llvm::PassRegistry &);
void initializeDependenceInfoPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeDependenceInfoWrapperPassPass(llvm::PassRegistry &); void initializeDependenceInfoWrapperPassPass(llvm::PassRegistry &);
void initializeDependenceInfoPrinterLegacyFunctionPassPass(
llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif #endif

polly/include/polly/FlattenSchedule.h

Show All 12 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef POLLY_FLATTENSCHEDULE_H #ifndef POLLY_FLATTENSCHEDULE_H
#define POLLY_FLATTENSCHEDULE_H #define POLLY_FLATTENSCHEDULE_H
namespace llvm { namespace llvm {
class PassRegistry; class PassRegistry;
class Pass; class Pass;
class raw_ostream;
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
llvm::Pass *createFlattenSchedulePass(); llvm::Pass *createFlattenSchedulePass();
llvm::Pass *createFlattenSchedulePrinterLegacyPass(llvm::raw_ostream &OS);
} // namespace polly } // namespace polly
namespace llvm { namespace llvm {
void initializeFlattenSchedulePass(llvm::PassRegistry &); void initializeFlattenSchedulePass(llvm::PassRegistry &);
void initializeFlattenSchedulePrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif /* POLLY_FLATTENSCHEDULE_H */ #endif /* POLLY_FLATTENSCHEDULE_H */

polly/include/polly/ForwardOpTree.h

Show All 11 Lines
#ifndef POLLY_FORWARDOPTREE_H #ifndef POLLY_FORWARDOPTREE_H
#define POLLY_FORWARDOPTREE_H #define POLLY_FORWARDOPTREE_H
#include "polly/ScopPass.h" #include "polly/ScopPass.h"
namespace llvm { namespace llvm {
class PassRegistry; class PassRegistry;
void initializeForwardOpTreeWrapperPassPass(PassRegistry &);
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
llvm::Pass *createForwardOpTreeWrapperPass(); llvm::Pass *createForwardOpTreeWrapperPass();
llvm::Pass *createForwardOpTreePrinterLegacyPass(llvm::raw_ostream &OS);
struct ForwardOpTreePass : llvm::PassInfoMixin<ForwardOpTreePass> { struct ForwardOpTreePass : llvm::PassInfoMixin<ForwardOpTreePass> {
ForwardOpTreePass() {} ForwardOpTreePass() {}
llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM, llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, SPMUpdater &U); ScopStandardAnalysisResults &SAR, SPMUpdater &U);
}; };
struct ForwardOpTreePrinterPass struct ForwardOpTreePrinterPass
: llvm::PassInfoMixin<ForwardOpTreePrinterPass> { : llvm::PassInfoMixin<ForwardOpTreePrinterPass> {
ForwardOpTreePrinterPass(raw_ostream &OS) : OS(OS) {} ForwardOpTreePrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Scop &S, ScopAnalysisManager &, PreservedAnalyses run(Scop &S, ScopAnalysisManager &,
ScopStandardAnalysisResults &SAR, SPMUpdater &); ScopStandardAnalysisResults &SAR, SPMUpdater &);
private: private:
llvm::raw_ostream &OS; llvm::raw_ostream &OS;
}; };
} // namespace polly } // namespace polly
namespace llvm {
void initializeForwardOpTreeWrapperPassPass(PassRegistry &);
void initializeForwardOpTreePrinterLegacyPassPass(PassRegistry &);
} // namespace llvm
#endif // POLLY_FORWARDOPTREE_H #endif // POLLY_FORWARDOPTREE_H

polly/include/polly/JSONExporter.h

//===- polly/JSONExporter.h - Import/Export to/from jscop files.-*- C++ -*-===// //===- polly/JSONExporter.h - Import/Export to/from jscop files.-*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef POLLY_JSONEXPORTER_H #ifndef POLLY_JSONEXPORTER_H
#define POLLY_JSONEXPORTER_H #define POLLY_JSONEXPORTER_H
#include "polly/ScopPass.h" #include "polly/ScopPass.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
namespace polly { namespace polly {
llvm::Pass *createJSONExporterPass();
llvm::Pass *createJSONImporterPass();
llvm::Pass *createJSONImporterPrinterLegacyPass(llvm::raw_ostream &OS);
/// This pass exports a scop to a jscop file. The filename is generated from the /// This pass exports a scop to a jscop file. The filename is generated from the
/// concatenation of the function and scop name. /// concatenation of the function and scop name.
struct JSONExportPass : public llvm::PassInfoMixin<JSONExportPass> { struct JSONExportPass : public llvm::PassInfoMixin<JSONExportPass> {
llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &, llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &,
ScopStandardAnalysisResults &, SPMUpdater &); ScopStandardAnalysisResults &, SPMUpdater &);
}; };
/// This pass imports a scop from a jscop file. The filename is deduced from the /// This pass imports a scop from a jscop file. The filename is deduced from the
/// concatenation of the function and scop name. /// concatenation of the function and scop name.
struct JSONImportPass : public llvm::PassInfoMixin<JSONExportPass> { struct JSONImportPass : public llvm::PassInfoMixin<JSONExportPass> {
llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &, llvm::PreservedAnalyses run(Scop &, ScopAnalysisManager &,
ScopStandardAnalysisResults &, SPMUpdater &); ScopStandardAnalysisResults &, SPMUpdater &);
}; };
} // namespace polly } // namespace polly
namespace llvm {
void initializeJSONExporterPass(llvm::PassRegistry &);
void initializeJSONImporterPass(llvm::PassRegistry &);
void initializeJSONImporterPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm
#endif /* POLLY_JSONEXPORTER_H */ #endif /* POLLY_JSONEXPORTER_H */

polly/include/polly/LinkAllPasses.h

Show All 25 Lines
class PassRegistry; class PassRegistry;
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
llvm::Pass *createCodePreparationPass(); llvm::Pass *createCodePreparationPass();
llvm::Pass *createScopInlinerPass(); llvm::Pass *createScopInlinerPass();
llvm::Pass *createDeadCodeElimWrapperPass(); llvm::Pass *createDeadCodeElimWrapperPass();
llvm::Pass *createDependenceInfoPass(); llvm::Pass *createDependenceInfoPass();
llvm::Pass *createDependenceInfoPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createDependenceInfoWrapperPassPass(); llvm::Pass *createDependenceInfoWrapperPassPass();
llvm::Pass *
createDependenceInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS);
llvm::Pass *createDOTOnlyPrinterPass(); llvm::Pass *createDOTOnlyPrinterPass();
llvm::Pass *createDOTOnlyViewerPass(); llvm::Pass *createDOTOnlyViewerPass();
llvm::Pass *createDOTPrinterPass(); llvm::Pass *createDOTPrinterPass();
llvm::Pass *createDOTViewerPass(); llvm::Pass *createDOTViewerPass();
llvm::Pass *createJSONExporterPass(); llvm::Pass *createJSONExporterPass();
llvm::Pass *createJSONImporterPass(); llvm::Pass *createJSONImporterPass();
llvm::Pass *createJSONImporterPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createPollyCanonicalizePass(); llvm::Pass *createPollyCanonicalizePass();
llvm::Pass *createPolyhedralInfoPass(); llvm::Pass *createPolyhedralInfoPass();
llvm::Pass *createPolyhedralInfoPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createScopDetectionWrapperPassPass(); llvm::Pass *createScopDetectionWrapperPassPass();
llvm::Pass *createScopDetectionPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createScopInfoRegionPassPass(); llvm::Pass *createScopInfoRegionPassPass();
llvm::Pass *createScopInfoPrinterLegacyRegionPass(llvm::raw_ostream &OS);
llvm::Pass *createScopInfoWrapperPassPass(); llvm::Pass *createScopInfoWrapperPassPass();
llvm::Pass *createScopInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS);
llvm::Pass *createIslAstInfoWrapperPassPass(); llvm::Pass *createIslAstInfoWrapperPassPass();
llvm::Pass *createIslAstInfoPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createCodeGenerationPass(); llvm::Pass *createCodeGenerationPass();
#ifdef GPU_CODEGEN #ifdef GPU_CODEGEN
llvm::Pass *createPPCGCodeGenerationPass(GPUArch Arch = GPUArch::NVPTX64, llvm::Pass *createPPCGCodeGenerationPass(GPUArch Arch = GPUArch::NVPTX64,
GPURuntime Runtime = GPURuntime::CUDA); GPURuntime Runtime = GPURuntime::CUDA);
llvm::Pass * llvm::Pass *
createManagedMemoryRewritePassPass(GPUArch Arch = GPUArch::NVPTX64, createManagedMemoryRewritePassPass(GPUArch Arch = GPUArch::NVPTX64,
GPURuntime Runtime = GPURuntime::CUDA); GPURuntime Runtime = GPURuntime::CUDA);
#endif #endif
llvm::Pass *createIslScheduleOptimizerWrapperPass(); llvm::Pass *createIslScheduleOptimizerWrapperPass();
llvm::Pass *createIslScheduleOptimizerPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createFlattenSchedulePass(); llvm::Pass *createFlattenSchedulePass();
llvm::Pass *createFlattenSchedulePrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createForwardOpTreeWrapperPass(); llvm::Pass *createForwardOpTreeWrapperPass();
llvm::Pass *createForwardOpTreePrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createDeLICMWrapperPass(); llvm::Pass *createDeLICMWrapperPass();
llvm::Pass *createDeLICMPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createMaximalStaticExpansionPass(); llvm::Pass *createMaximalStaticExpansionPass();
llvm::Pass *createSimplifyWrapperPass(int); llvm::Pass *createSimplifyWrapperPass(int);
llvm::Pass *createSimplifyPrinterLegacyPass(llvm::raw_ostream &OS);
llvm::Pass *createPruneUnprofitableWrapperPass(); llvm::Pass *createPruneUnprofitableWrapperPass();
extern char &CodePreparationID; extern char &CodePreparationID;
} // namespace polly } // namespace polly
namespace { namespace {
struct PollyForcePassLinking { struct PollyForcePassLinking {
PollyForcePassLinking() { PollyForcePassLinking() {
// We must reference the passes in such a way that compilers will not // We must reference the passes in such a way that compilers will not
// delete it all as dead code, even with whole program optimization, // delete it all as dead code, even with whole program optimization,
// yet is effectively a NO-OP. As the compiler isn't smart enough // yet is effectively a NO-OP. As the compiler isn't smart enough
// to know that getenv() never returns -1, this will do the job. // to know that getenv() never returns -1, this will do the job.
if (std::getenv("bar") != (char *)-1) if (std::getenv("bar") != (char *)-1)
return; return;
polly::createCodePreparationPass(); polly::createCodePreparationPass();
polly::createDeadCodeElimWrapperPass(); polly::createDeadCodeElimWrapperPass();
polly::createDependenceInfoPass(); polly::createDependenceInfoPass();
polly::createDependenceInfoPrinterLegacyPass(llvm::outs());
polly::createDependenceInfoWrapperPassPass();
polly::createDependenceInfoPrinterLegacyFunctionPass(llvm::outs());
polly::createDOTOnlyPrinterPass(); polly::createDOTOnlyPrinterPass();
polly::createDOTOnlyViewerPass(); polly::createDOTOnlyViewerPass();
polly::createDOTPrinterPass(); polly::createDOTPrinterPass();
polly::createDOTViewerPass(); polly::createDOTViewerPass();
polly::createJSONExporterPass(); polly::createJSONExporterPass();
polly::createJSONImporterPass(); polly::createJSONImporterPass();
polly::createJSONImporterPrinterLegacyPass(llvm::outs());
polly::createScopDetectionWrapperPassPass(); polly::createScopDetectionWrapperPassPass();
polly::createScopDetectionPrinterLegacyPass(llvm::outs());
polly::createScopInfoRegionPassPass(); polly::createScopInfoRegionPassPass();
polly::createScopInfoPrinterLegacyRegionPass(llvm::outs());
polly::createScopInfoWrapperPassPass();
polly::createScopInfoPrinterLegacyFunctionPass(llvm::outs());
polly::createPollyCanonicalizePass(); polly::createPollyCanonicalizePass();
polly::createPolyhedralInfoPass(); polly::createPolyhedralInfoPass();
polly::createPolyhedralInfoPrinterLegacyPass(llvm::outs());
polly::createIslAstInfoWrapperPassPass(); polly::createIslAstInfoWrapperPassPass();
polly::createIslAstInfoPrinterLegacyPass(llvm::outs());
polly::createCodeGenerationPass(); polly::createCodeGenerationPass();
#ifdef GPU_CODEGEN #ifdef GPU_CODEGEN
polly::createPPCGCodeGenerationPass(); polly::createPPCGCodeGenerationPass();
polly::createManagedMemoryRewritePassPass(); polly::createManagedMemoryRewritePassPass();
#endif #endif
polly::createIslScheduleOptimizerWrapperPass(); polly::createIslScheduleOptimizerWrapperPass();
polly::createIslScheduleOptimizerPrinterLegacyPass(llvm::outs());
polly::createMaximalStaticExpansionPass(); polly::createMaximalStaticExpansionPass();
polly::createFlattenSchedulePass(); polly::createFlattenSchedulePass();
polly::createFlattenSchedulePrinterLegacyPass(llvm::errs());
polly::createForwardOpTreeWrapperPass(); polly::createForwardOpTreeWrapperPass();
polly::createForwardOpTreePrinterLegacyPass(llvm::errs());
polly::createDeLICMWrapperPass(); polly::createDeLICMWrapperPass();
polly::createDeLICMPrinterLegacyPass(llvm::outs());
polly::createDumpModuleWrapperPass("", true); polly::createDumpModuleWrapperPass("", true);
polly::createDumpFunctionWrapperPass(""); polly::createDumpFunctionWrapperPass("");
polly::createSimplifyWrapperPass(0); polly::createSimplifyWrapperPass(0);
polly::createSimplifyPrinterLegacyPass(llvm::outs());
polly::createPruneUnprofitableWrapperPass(); polly::createPruneUnprofitableWrapperPass();
} }
} PollyForcePassLinking; // Force link by creating a global definition. } PollyForcePassLinking; // Force link by creating a global definition.
} // namespace } // namespace
namespace llvm { namespace llvm {
class PassRegistry;
void initializeCodePreparationPass(llvm::PassRegistry &); void initializeCodePreparationPass(llvm::PassRegistry &);
void initializeScopInlinerPass(llvm::PassRegistry &); void initializeScopInlinerPass(llvm::PassRegistry &);
void initializeScopDetectionWrapperPassPass(llvm::PassRegistry &);
void initializeScopDetectionPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeScopInfoRegionPassPass(PassRegistry &);
void initializeScopInfoPrinterLegacyRegionPassPass(llvm::PassRegistry &);
void initializeScopInfoWrapperPassPass(PassRegistry &);
void initializeScopInfoPrinterLegacyFunctionPassPass(PassRegistry &);
void initializeDeadCodeElimWrapperPassPass(llvm::PassRegistry &); void initializeDeadCodeElimWrapperPassPass(llvm::PassRegistry &);
void initializeJSONExporterPass(llvm::PassRegistry &); void initializeJSONExporterPass(llvm::PassRegistry &);
void initializeJSONImporterPass(llvm::PassRegistry &); void initializeJSONImporterPass(llvm::PassRegistry &);
void initializeJSONImporterPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeDependenceInfoPass(llvm::PassRegistry &);
void initializeDependenceInfoPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeDependenceInfoWrapperPassPass(llvm::PassRegistry &);
void initializeDependenceInfoPrinterLegacyFunctionPassPass(
llvm::PassRegistry &);
void initializeIslAstInfoWrapperPassPass(llvm::PassRegistry &); void initializeIslAstInfoWrapperPassPass(llvm::PassRegistry &);
void initializeIslAstInfoPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeCodeGenerationPass(llvm::PassRegistry &); void initializeCodeGenerationPass(llvm::PassRegistry &);
#ifdef GPU_CODEGEN #ifdef GPU_CODEGEN
void initializePPCGCodeGenerationPass(llvm::PassRegistry &); void initializePPCGCodeGenerationPass(llvm::PassRegistry &);
void initializeManagedMemoryRewritePassPass(llvm::PassRegistry &); void initializeManagedMemoryRewritePassPass(llvm::PassRegistry &);
#endif #endif
void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &); void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &);
void initializeIslScheduleOptimizerPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeMaximalStaticExpanderPass(llvm::PassRegistry &); void initializeMaximalStaticExpanderPass(llvm::PassRegistry &);
void initializePollyCanonicalizePass(llvm::PassRegistry &); void initializePollyCanonicalizePass(llvm::PassRegistry &);
void initializeFlattenSchedulePass(llvm::PassRegistry &); void initializeFlattenSchedulePass(llvm::PassRegistry &);
void initializeFlattenSchedulePrinterLegacyPassPass(llvm::PassRegistry &);
void initializeForwardOpTreeWrapperPassPass(llvm::PassRegistry &); void initializeForwardOpTreeWrapperPassPass(llvm::PassRegistry &);
void initializeForwardOpTreePrinterLegacyPassPass(PassRegistry &);
void initializeDeLICMWrapperPassPass(llvm::PassRegistry &); void initializeDeLICMWrapperPassPass(llvm::PassRegistry &);
void initializeDeLICMPrinterLegacyPassPass(llvm::PassRegistry &);
void initializeSimplifyWrapperPassPass(llvm::PassRegistry &); void initializeSimplifyWrapperPassPass(llvm::PassRegistry &);
void initializeSimplifyPrinterLegacyPassPass(llvm::PassRegistry &);
void initializePruneUnprofitableWrapperPassPass(llvm::PassRegistry &); void initializePruneUnprofitableWrapperPassPass(llvm::PassRegistry &);
void initializePolyhedralInfoPass(llvm::PassRegistry &);
void initializePolyhedralInfoPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif #endif

polly/include/polly/PolyhedralInfo.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linesprivate:
/// @return Returns true if loop is parallel or vectorizable, false /// @return Returns true if loop is parallel or vectorizable, false
/// otherwise. /// otherwise.
bool checkParallel(llvm::Loop *L, bool checkParallel(llvm::Loop *L,
__isl_give isl_pw_aff **MinDepDistPtr = nullptr) const; __isl_give isl_pw_aff **MinDepDistPtr = nullptr) const;
ScopInfo *SI; ScopInfo *SI;
DependenceInfoWrapperPass *DI; DependenceInfoWrapperPass *DI;
}; };
llvm::Pass *createPolyhedralInfoPrinterLegacyPass(llvm::raw_ostream &OS);
} // end namespace polly } // end namespace polly
namespace llvm { namespace llvm {
class PassRegistry; class PassRegistry;
void initializePolyhedralInfoPass(llvm::PassRegistry &); void initializePolyhedralInfoPass(llvm::PassRegistry &);
void initializePolyhedralInfoPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif #endif

polly/include/polly/ScheduleOptimizer.h

Show All 12 Lines
namespace llvm { namespace llvm {
class Pass; class Pass;
class PassRegistry; class PassRegistry;
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
llvm::Pass *createIslScheduleOptimizerWrapperPass(); llvm::Pass *createIslScheduleOptimizerWrapperPass();
llvm::Pass *createIslScheduleOptimizerPrinterLegacyPass(llvm::raw_ostream &OS);
struct IslScheduleOptimizerPass struct IslScheduleOptimizerPass
: llvm::PassInfoMixin<IslScheduleOptimizerPass> { : llvm::PassInfoMixin<IslScheduleOptimizerPass> {
IslScheduleOptimizerPass() {} IslScheduleOptimizerPass() {}
llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM, llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, SPMUpdater &U); ScopStandardAnalysisResults &SAR, SPMUpdater &U);
}; };
struct IslScheduleOptimizerPrinterPass struct IslScheduleOptimizerPrinterPass
: llvm::PassInfoMixin<IslScheduleOptimizerPrinterPass> { : llvm::PassInfoMixin<IslScheduleOptimizerPrinterPass> {
IslScheduleOptimizerPrinterPass(raw_ostream &OS) : OS(OS) {} IslScheduleOptimizerPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Scop &S, ScopAnalysisManager &, PreservedAnalyses run(Scop &S, ScopAnalysisManager &,
ScopStandardAnalysisResults &SAR, SPMUpdater &); ScopStandardAnalysisResults &SAR, SPMUpdater &);
private: private:
llvm::raw_ostream &OS; llvm::raw_ostream &OS;
}; };
} // namespace polly } // namespace polly
namespace llvm { namespace llvm {
void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &); void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &);
} void initializeIslScheduleOptimizerPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm
#endif // POLLY_SCHEDULEOPTIMIZER_H #endif // POLLY_SCHEDULEOPTIMIZER_H

polly/include/polly/ScopDetection.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
#include "llvm/Analysis/AliasSetTracker.h" #include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/RegionInfo.h" #include "llvm/Analysis/RegionInfo.h"
#include "llvm/Analysis/ScalarEvolutionExpressions.h" #include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include <set> #include <set>
namespace llvm { namespace llvm {
class AAResults; class AAResults;
void initializeScopDetectionWrapperPassPass(PassRegistry &);
} // namespace llvm } // namespace llvm
namespace polly { namespace polly {
using llvm::AAResults; using llvm::AAResults;
using llvm::AliasSetTracker; using llvm::AliasSetTracker;
using llvm::AnalysisInfoMixin; using llvm::AnalysisInfoMixin;
using llvm::AnalysisKey; using llvm::AnalysisKey;
using llvm::AnalysisUsage; using llvm::AnalysisUsage;
▲ Show 20 Lines • Show All 584 Lines • ▼ Show 20 Linesstruct ScopDetectionWrapperPass : public FunctionPass {
ScopDetectionWrapperPass(); ScopDetectionWrapperPass();
/// @name FunctionPass interface /// @name FunctionPass interface
//@{ //@{
void getAnalysisUsage(AnalysisUsage &AU) const override; void getAnalysisUsage(AnalysisUsage &AU) const override;
void releaseMemory() override; void releaseMemory() override;
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
void print(raw_ostream &OS, const Module *) const override; void print(raw_ostream &OS, const Module *M = nullptr) const override;
//@} //@}
ScopDetection &getSD() const { return *Result; } ScopDetection &getSD() const { return *Result; }
}; };
llvm::Pass *createScopDetectionPrinterLegacyPass(llvm::raw_ostream &OS);
} // namespace polly } // namespace polly
namespace llvm {
void initializeScopDetectionWrapperPassPass(llvm::PassRegistry &);
void initializeScopDetectionPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm
#endif // POLLY_SCOPDETECTION_H #endif // POLLY_SCOPDETECTION_H

polly/include/polly/ScopInfo.h

Show All 29 Lines
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/IR/ValueHandle.h" #include "llvm/IR/ValueHandle.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "isl/isl-noexceptions.h" #include "isl/isl-noexceptions.h"
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include <forward_list> #include <forward_list>
namespace llvm {
void initializeScopInfoRegionPassPass(PassRegistry &);
void initializeScopInfoWrapperPassPass(PassRegistry &);
} // end namespace llvm
namespace polly { namespace polly {
using llvm::AnalysisInfoMixin; using llvm::AnalysisInfoMixin;
using llvm::ArrayRef; using llvm::ArrayRef;
using llvm::AssertingVH; using llvm::AssertingVH;
using llvm::AssumptionCache; using llvm::AssumptionCache;
using llvm::cast; using llvm::cast;
using llvm::DataLayout; using llvm::DataLayout;
using llvm::DenseMap; using llvm::DenseMap;
▲ Show 20 Lines • Show All 2,662 Lines • ▼ Show 20 Linespublic:
void releaseMemory() override { S.reset(); } void releaseMemory() override { S.reset(); }
void print(raw_ostream &O, const Module *M = nullptr) const override; void print(raw_ostream &O, const Module *M = nullptr) const override;
void getAnalysisUsage(AnalysisUsage &AU) const override; void getAnalysisUsage(AnalysisUsage &AU) const override;
}; };
llvm::Pass *createScopInfoPrinterLegacyRegionPass(raw_ostream &OS);
class ScopInfo { class ScopInfo {
public: public:
using RegionToScopMapTy = MapVector<Region *, std::unique_ptr<Scop>>; using RegionToScopMapTy = MapVector<Region *, std::unique_ptr<Scop>>;
using reverse_iterator = RegionToScopMapTy::reverse_iterator; using reverse_iterator = RegionToScopMapTy::reverse_iterator;
using const_reverse_iterator = RegionToScopMapTy::const_reverse_iterator; using const_reverse_iterator = RegionToScopMapTy::const_reverse_iterator;
using iterator = RegionToScopMapTy::iterator; using iterator = RegionToScopMapTy::iterator;
using const_iterator = RegionToScopMapTy::const_iterator; using const_iterator = RegionToScopMapTy::const_iterator;
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linespublic:
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
void releaseMemory() override { Result.reset(); } void releaseMemory() override { Result.reset(); }
void print(raw_ostream &O, const Module *M = nullptr) const override; void print(raw_ostream &O, const Module *M = nullptr) const override;
void getAnalysisUsage(AnalysisUsage &AU) const override; void getAnalysisUsage(AnalysisUsage &AU) const override;
}; };
llvm::Pass *createScopInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS);
} // end namespace polly } // end namespace polly
namespace llvm {
void initializeScopInfoRegionPassPass(PassRegistry &);
void initializeScopInfoPrinterLegacyRegionPassPass(PassRegistry &);
void initializeScopInfoWrapperPassPass(PassRegistry &);
void initializeScopInfoPrinterLegacyFunctionPassPass(PassRegistry &);
} // end namespace llvm
#endif // POLLY_SCOPINFO_H #endif // POLLY_SCOPINFO_H

polly/include/polly/Simplify.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
/// ///
/// @param CallNo Disambiguates this instance for when there are multiple /// @param CallNo Disambiguates this instance for when there are multiple
/// instances of this pass in the pass manager. It is used only to /// instances of this pass in the pass manager. It is used only to
/// keep the statistics apart and has no influence on the /// keep the statistics apart and has no influence on the
/// simplification itself. /// simplification itself.
/// ///
/// @return The Simplify pass. /// @return The Simplify pass.
llvm::Pass *createSimplifyWrapperPass(int CallNo = 0); llvm::Pass *createSimplifyWrapperPass(int CallNo = 0);
llvm::Pass *createSimplifyPrinterLegacyPass(llvm::raw_ostream &OS);
struct SimplifyPass : public PassInfoMixin<SimplifyPass> { struct SimplifyPass : public PassInfoMixin<SimplifyPass> {
SimplifyPass(int CallNo = 0) : CallNo(CallNo) {} SimplifyPass(int CallNo = 0) : CallNo(CallNo) {}
llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM, llvm::PreservedAnalyses run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &AR, SPMUpdater &U); ScopStandardAnalysisResults &AR, SPMUpdater &U);
private: private:
Show All 10 Lines
private: private:
raw_ostream &OS; raw_ostream &OS;
int CallNo; int CallNo;
}; };
} // namespace polly } // namespace polly
namespace llvm { namespace llvm {
void initializeSimplifyWrapperPassPass(llvm::PassRegistry &); void initializeSimplifyWrapperPassPass(llvm::PassRegistry &);
void initializeSimplifyPrinterLegacyPassPass(llvm::PassRegistry &);
} // namespace llvm } // namespace llvm
#endif /* POLLY_TRANSFORM_SIMPLIFY_H */ #endif /* POLLY_TRANSFORM_SIMPLIFY_H */

polly/lib/Analysis/DependenceInfo.cpp

Show First 20 Lines • Show All 921 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_BEGIN(DependenceInfo, "polly-dependences", INITIALIZE_PASS_BEGIN(DependenceInfo, "polly-dependences",
"Polly - Calculate dependences", false, false); "Polly - Calculate dependences", false, false);
INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass); INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass);
INITIALIZE_PASS_END(DependenceInfo, "polly-dependences", INITIALIZE_PASS_END(DependenceInfo, "polly-dependences",
"Polly - Calculate dependences", false, false) "Polly - Calculate dependences", false, false)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace {
/// Print result from DependenceAnalysis.
class DependenceInfoPrinterLegacyPass : public ScopPass {
public:
static char ID;
DependenceInfoPrinterLegacyPass() : DependenceInfoPrinterLegacyPass(outs()) {}
explicit DependenceInfoPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
DependenceInfo &P = getAnalysis<DependenceInfo>();
OS << "Printing analysis '" << P.getPassName() << "' for "
<< "region: '" << S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<DependenceInfo>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char DependenceInfoPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createDependenceInfoPrinterLegacyPass(raw_ostream &OS) {
return new DependenceInfoPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(DependenceInfoPrinterLegacyPass,
"polly-print-dependences", "Polly - Print dependences",
false, false);
INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
INITIALIZE_PASS_END(DependenceInfoPrinterLegacyPass, "polly-print-dependences",
"Polly - Print dependences", false, false)
//===----------------------------------------------------------------------===//
const Dependences & const Dependences &
DependenceInfoWrapperPass::getDependences(Scop *S, DependenceInfoWrapperPass::getDependences(Scop *S,
Dependences::AnalysisLevel Level) { Dependences::AnalysisLevel Level) {
auto It = ScopToDepsMap.find(S); auto It = ScopToDepsMap.find(S);
if (It != ScopToDepsMap.end()) if (It != ScopToDepsMap.end())
if (It->second) { if (It->second) {
if (It->second->getDependenceLevel() == Level) if (It->second->getDependenceLevel() == Level)
return *It->second.get(); return *It->second.get();
Show All 40 LinesINITIALIZE_PASS_BEGIN(
DependenceInfoWrapperPass, "polly-function-dependences", DependenceInfoWrapperPass, "polly-function-dependences",
"Polly - Calculate dependences for all the SCoPs of a function", false, "Polly - Calculate dependences for all the SCoPs of a function", false,
false) false)
INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass);
INITIALIZE_PASS_END( INITIALIZE_PASS_END(
DependenceInfoWrapperPass, "polly-function-dependences", DependenceInfoWrapperPass, "polly-function-dependences",
"Polly - Calculate dependences for all the SCoPs of a function", false, "Polly - Calculate dependences for all the SCoPs of a function", false,
false) false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from DependenceInfoWrapperPass.
class DependenceInfoPrinterLegacyFunctionPass : public FunctionPass {
public:
static char ID;
DependenceInfoPrinterLegacyFunctionPass()
: DependenceInfoPrinterLegacyFunctionPass(outs()) {}
explicit DependenceInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS)
: FunctionPass(ID), OS(OS) {}
bool runOnFunction(Function &F) override {
DependenceInfoWrapperPass &P = getAnalysis<DependenceInfoWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for function '"
<< F.getName() << "':\n";
P.print(OS);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
FunctionPass::getAnalysisUsage(AU);
AU.addRequired<DependenceInfoWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char DependenceInfoPrinterLegacyFunctionPass::ID = 0;
} // namespace
Pass *polly::createDependenceInfoPrinterLegacyFunctionPass(raw_ostream &OS) {
return new DependenceInfoPrinterLegacyFunctionPass(OS);
}
INITIALIZE_PASS_BEGIN(
DependenceInfoPrinterLegacyFunctionPass, "polly-print-function-dependences",
"Polly - Print dependences for all the SCoPs of a function", false, false);
INITIALIZE_PASS_DEPENDENCY(DependenceInfoWrapperPass);
INITIALIZE_PASS_END(DependenceInfoPrinterLegacyFunctionPass,
"polly-print-function-dependences",
"Polly - Print dependences for all the SCoPs of a function",
false, false)

polly/lib/Analysis/PolyhedralInfo.cpp

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 LinesINITIALIZE_PASS_BEGIN(PolyhedralInfo, "polyhedral-info",
"Polly - Interface to polyhedral analysis engine", false, "Polly - Interface to polyhedral analysis engine", false,
false); false);
INITIALIZE_PASS_DEPENDENCY(DependenceInfoWrapperPass); INITIALIZE_PASS_DEPENDENCY(DependenceInfoWrapperPass);
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass); INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass);
INITIALIZE_PASS_END(PolyhedralInfo, "polyhedral-info", INITIALIZE_PASS_END(PolyhedralInfo, "polyhedral-info",
"Polly - Interface to polyhedral analysis engine", false, "Polly - Interface to polyhedral analysis engine", false,
false) false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from PolyhedralInfo.
class PolyhedralInfoPrinterLegacyPass : public FunctionPass {
public:
static char ID;
PolyhedralInfoPrinterLegacyPass() : PolyhedralInfoPrinterLegacyPass(outs()) {}
explicit PolyhedralInfoPrinterLegacyPass(llvm::raw_ostream &OS)
: FunctionPass(ID), OS(OS) {}
bool runOnFunction(Function &F) override {
PolyhedralInfo &P = getAnalysis<PolyhedralInfo>();
OS << "Printing analysis '" << P.getPassName() << "' for function '"
<< F.getName() << "':\n";
P.print(OS);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
FunctionPass::getAnalysisUsage(AU);
AU.addRequired<PolyhedralInfo>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char PolyhedralInfoPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createPolyhedralInfoPrinterLegacyPass(raw_ostream &OS) {
return new PolyhedralInfoPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(
PolyhedralInfoPrinterLegacyPass, "print-polyhedral-info",
"Polly - Print interface to polyhedral analysis engine analysis", false,
false);
INITIALIZE_PASS_DEPENDENCY(PolyhedralInfo);
INITIALIZE_PASS_END(
PolyhedralInfoPrinterLegacyPass, "print-polyhedral-info",
"Polly - Print interface to polyhedral analysis engine analysis", false,
false)

polly/lib/Analysis/ScopDetection.cpp

Show First 20 Lines • Show All 2,037 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass); INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass);
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass); INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
INITIALIZE_PASS_DEPENDENCY(RegionInfoPass); INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass); INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass); INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass);
INITIALIZE_PASS_END(ScopDetectionWrapperPass, "polly-detect", INITIALIZE_PASS_END(ScopDetectionWrapperPass, "polly-detect",
"Polly - Detect static control parts (SCoPs)", false, false) "Polly - Detect static control parts (SCoPs)", false, false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from ScopDetectionWrapperPass.
class ScopDetectionPrinterLegacyPass : public FunctionPass {
public:
static char ID;
ScopDetectionPrinterLegacyPass() : ScopDetectionPrinterLegacyPass(outs()) {}
explicit ScopDetectionPrinterLegacyPass(llvm::raw_ostream &OS)
: FunctionPass(ID), OS(OS) {}
bool runOnFunction(Function &F) override {
ScopDetectionWrapperPass &P = getAnalysis<ScopDetectionWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for function '"
<< F.getName() << "':\n";
P.print(OS);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
FunctionPass::getAnalysisUsage(AU);
AU.addRequired<ScopDetectionWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char ScopDetectionPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createScopDetectionPrinterLegacyPass(raw_ostream &OS) {
return new ScopDetectionPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(ScopDetectionPrinterLegacyPass, "polly-print-detect",
"Polly - Print static control parts (SCoPs)", false,
false);
INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
INITIALIZE_PASS_END(ScopDetectionPrinterLegacyPass, "polly-print-detect",
"Polly - Print static control parts (SCoPs)", false, false)

polly/lib/Analysis/ScopInfo.cpp

Show First 20 Lines • Show All 2,637 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass); INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops", INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops",
"Polly - Create polyhedral description of Scops", false, "Polly - Create polyhedral description of Scops", false,
false) false)
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace {
/// Print result from ScopInfoRegionPass.
class ScopInfoPrinterLegacyRegionPass : public RegionPass {
public:
static char ID;
ScopInfoPrinterLegacyRegionPass() : ScopInfoPrinterLegacyRegionPass(outs()) {}
explicit ScopInfoPrinterLegacyRegionPass(llvm::raw_ostream &OS)
: RegionPass(ID), OS(OS) {}
bool runOnRegion(Region *R, RGPassManager &RGM) override {
ScopInfoRegionPass &P = getAnalysis<ScopInfoRegionPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< R->getNameStr() << "' in function '"
<< R->getEntry()->getParent()->getName() << "':\n";
P.print(OS);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
RegionPass::getAnalysisUsage(AU);
AU.addRequired<ScopInfoRegionPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char ScopInfoPrinterLegacyRegionPass::ID = 0;
} // namespace
Pass *polly::createScopInfoPrinterLegacyRegionPass(raw_ostream &OS) {
return new ScopInfoPrinterLegacyRegionPass(OS);
}
INITIALIZE_PASS_BEGIN(ScopInfoPrinterLegacyRegionPass, "polly-print-scops",
"Polly - Print polyhedral description of Scops", false,
false);
INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass);
INITIALIZE_PASS_END(ScopInfoPrinterLegacyRegionPass, "polly-print-scops",
"Polly - Print polyhedral description of Scops", false,
false)
//===----------------------------------------------------------------------===//
ScopInfo::ScopInfo(const DataLayout &DL, ScopDetection &SD, ScalarEvolution &SE, ScopInfo::ScopInfo(const DataLayout &DL, ScopDetection &SD, ScalarEvolution &SE,
LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT, LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
AssumptionCache &AC, OptimizationRemarkEmitter &ORE) AssumptionCache &AC, OptimizationRemarkEmitter &ORE)
: DL(DL), SD(SD), SE(SE), LI(LI), AA(AA), DT(DT), AC(AC), ORE(ORE) { : DL(DL), SD(SD), SE(SE), LI(LI), AA(AA), DT(DT), AC(AC), ORE(ORE) {
recompute(); recompute();
} }
void ScopInfo::recompute() { void ScopInfo::recompute() {
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_DEPENDENCY(RegionInfoPass); INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass); INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass); INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
INITIALIZE_PASS_END( INITIALIZE_PASS_END(
ScopInfoWrapperPass, "polly-function-scops", ScopInfoWrapperPass, "polly-function-scops",
"Polly - Create polyhedral description of all Scops of a function", false, "Polly - Create polyhedral description of all Scops of a function", false,
false) false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from ScopInfoWrapperPass.
class ScopInfoPrinterLegacyFunctionPass : public FunctionPass {
public:
static char ID;
ScopInfoPrinterLegacyFunctionPass()
: ScopInfoPrinterLegacyFunctionPass(outs()) {}
explicit ScopInfoPrinterLegacyFunctionPass(llvm::raw_ostream &OS)
: FunctionPass(ID), OS(OS) {}
bool runOnFunction(Function &F) override {
ScopInfoWrapperPass &P = getAnalysis<ScopInfoWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for function '"
<< F.getName() << "':\n";
P.print(OS);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
FunctionPass::getAnalysisUsage(AU);
AU.addRequired<ScopInfoWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char ScopInfoPrinterLegacyFunctionPass::ID = 0;
} // namespace
Pass *polly::createScopInfoPrinterLegacyFunctionPass(raw_ostream &OS) {
return new ScopInfoPrinterLegacyFunctionPass(OS);
}
INITIALIZE_PASS_BEGIN(
ScopInfoPrinterLegacyFunctionPass, "polly-print-function-scops",
"Polly - Print polyhedral description of all Scops of a function", false,
false);
INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass);
INITIALIZE_PASS_END(
ScopInfoPrinterLegacyFunctionPass, "polly-print-function-scops",
"Polly - Print polyhedral description of all Scops of a function", false,
false)

polly/lib/CodeGen/IslAst.cpp

Show First 20 Lines • Show All 817 Lines • ▼ Show 20 Lines
INITIALIZE_PASS_BEGIN(IslAstInfoWrapperPass, "polly-ast", INITIALIZE_PASS_BEGIN(IslAstInfoWrapperPass, "polly-ast",
"Polly - Generate an AST of the SCoP (isl)", false, "Polly - Generate an AST of the SCoP (isl)", false,
false); false);
INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass); INITIALIZE_PASS_DEPENDENCY(ScopInfoRegionPass);
INITIALIZE_PASS_DEPENDENCY(DependenceInfo); INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
INITIALIZE_PASS_END(IslAstInfoWrapperPass, "polly-ast", INITIALIZE_PASS_END(IslAstInfoWrapperPass, "polly-ast",
"Polly - Generate an AST from the SCoP (isl)", false, false) "Polly - Generate an AST from the SCoP (isl)", false, false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from IslAstInfoWrapperPass.
class IslAstInfoPrinterLegacyPass : public ScopPass {
public:
static char ID;
IslAstInfoPrinterLegacyPass() : IslAstInfoPrinterLegacyPass(outs()) {}
explicit IslAstInfoPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
IslAstInfoWrapperPass &P = getAnalysis<IslAstInfoWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<IslAstInfoWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char IslAstInfoPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createIslAstInfoPrinterLegacyPass(raw_ostream &OS) {
return new IslAstInfoPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(IslAstInfoPrinterLegacyPass, "polly-print-ast",
"Polly - Print the AST from a SCoP (isl)", false, false);
INITIALIZE_PASS_DEPENDENCY(IslAstInfoWrapperPass);
INITIALIZE_PASS_END(IslAstInfoPrinterLegacyPass, "polly-print-ast",
"Polly - Print the AST from a SCoP (isl)", false, false)

polly/lib/Exchange/JSONExporter.cpp

Show First 20 Lines • Show All 827 Lines • ▼ Show 20 LinesINITIALIZE_PASS_BEGIN(JSONImporter, "polly-import-jscop",
"Polly - Import Scops from JSON" "Polly - Import Scops from JSON"
" (Reads a .jscop file for each Scop)", " (Reads a .jscop file for each Scop)",
false, false); false, false);
INITIALIZE_PASS_DEPENDENCY(DependenceInfo) INITIALIZE_PASS_DEPENDENCY(DependenceInfo)
INITIALIZE_PASS_END(JSONImporter, "polly-import-jscop", INITIALIZE_PASS_END(JSONImporter, "polly-import-jscop",
"Polly - Import Scops from JSON" "Polly - Import Scops from JSON"
" (Reads a .jscop file for each Scop)", " (Reads a .jscop file for each Scop)",
false, false) false, false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from JSONImporter.
class JSONImporterPrinterLegacyPass : public ScopPass {
public:
static char ID;
JSONImporterPrinterLegacyPass() : JSONImporterPrinterLegacyPass(outs()){};
explicit JSONImporterPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
JSONImporter &P = getAnalysis<JSONImporter>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<JSONImporter>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char JSONImporterPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createJSONImporterPrinterLegacyPass(llvm::raw_ostream &OS) {
return new JSONImporterPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(JSONImporterPrinterLegacyPass, "polly-print-import-jscop",
"Polly - Print Scop import result", false, false)
INITIALIZE_PASS_DEPENDENCY(JSONImporter)
INITIALIZE_PASS_END(JSONImporterPrinterLegacyPass, "polly-print-import-jscop",
"Polly - Print Scop import result", false, false)

polly/lib/Support/RegisterPasses.cpp

Show First 20 Lines • Show All 251 Lines • ▼ Show 20 Lines#ifdef GPU_CODEGEN
LLVMInitializeNVPTXTarget(); LLVMInitializeNVPTXTarget();
LLVMInitializeNVPTXTargetInfo(); LLVMInitializeNVPTXTargetInfo();
LLVMInitializeNVPTXTargetMC(); LLVMInitializeNVPTXTargetMC();
LLVMInitializeNVPTXAsmPrinter(); LLVMInitializeNVPTXAsmPrinter();
#endif #endif
initializeCodePreparationPass(Registry); initializeCodePreparationPass(Registry);
initializeDeadCodeElimWrapperPassPass(Registry); initializeDeadCodeElimWrapperPassPass(Registry);
initializeDependenceInfoPass(Registry); initializeDependenceInfoPass(Registry);
initializeDependenceInfoPrinterLegacyPassPass(Registry);
initializeDependenceInfoWrapperPassPass(Registry); initializeDependenceInfoWrapperPassPass(Registry);
initializeDependenceInfoPrinterLegacyFunctionPassPass(Registry);
initializeJSONExporterPass(Registry); initializeJSONExporterPass(Registry);
initializeJSONImporterPass(Registry); initializeJSONImporterPass(Registry);
initializeJSONImporterPrinterLegacyPassPass(Registry);
initializeMaximalStaticExpanderPass(Registry); initializeMaximalStaticExpanderPass(Registry);
initializeIslAstInfoWrapperPassPass(Registry); initializeIslAstInfoWrapperPassPass(Registry);
initializeIslAstInfoPrinterLegacyPassPass(Registry);
initializeIslScheduleOptimizerWrapperPassPass(Registry); initializeIslScheduleOptimizerWrapperPassPass(Registry);
initializeIslScheduleOptimizerPrinterLegacyPassPass(Registry);
initializePollyCanonicalizePass(Registry); initializePollyCanonicalizePass(Registry);
initializePolyhedralInfoPass(Registry); initializePolyhedralInfoPass(Registry);
initializePolyhedralInfoPrinterLegacyPassPass(Registry);
initializeScopDetectionWrapperPassPass(Registry); initializeScopDetectionWrapperPassPass(Registry);
initializeScopDetectionPrinterLegacyPassPass(Registry);
initializeScopInlinerPass(Registry); initializeScopInlinerPass(Registry);
initializeScopInfoRegionPassPass(Registry); initializeScopInfoRegionPassPass(Registry);
initializeScopInfoPrinterLegacyRegionPassPass(Registry);
initializeScopInfoWrapperPassPass(Registry); initializeScopInfoWrapperPassPass(Registry);
initializeScopInfoPrinterLegacyFunctionPassPass(Registry);
initializeCodegenCleanupPass(Registry); initializeCodegenCleanupPass(Registry);
initializeFlattenSchedulePass(Registry); initializeFlattenSchedulePass(Registry);
initializeFlattenSchedulePrinterLegacyPassPass(Registry);
initializeForwardOpTreeWrapperPassPass(Registry); initializeForwardOpTreeWrapperPassPass(Registry);
initializeForwardOpTreePrinterLegacyPassPass(Registry);
initializeDeLICMWrapperPassPass(Registry); initializeDeLICMWrapperPassPass(Registry);
initializeDeLICMPrinterLegacyPassPass(Registry);
initializeSimplifyWrapperPassPass(Registry); initializeSimplifyWrapperPassPass(Registry);
initializeSimplifyPrinterLegacyPassPass(Registry);
initializeDumpModuleWrapperPassPass(Registry); initializeDumpModuleWrapperPassPass(Registry);
initializePruneUnprofitableWrapperPassPass(Registry); initializePruneUnprofitableWrapperPassPass(Registry);
} }
/// Register Polly passes such that they form a polyhedral optimizer. /// Register Polly passes such that they form a polyhedral optimizer.
/// ///
/// The individual Polly passes are registered in the pass manager such that /// The individual Polly passes are registered in the pass manager such that
/// they form a full polyhedral optimizer. The flow of the optimizer starts with /// they form a full polyhedral optimizer. The flow of the optimizer starts with
▲ Show 20 Lines • Show All 570 Lines • Show Last 20 Lines

polly/lib/Transform/DeLICM.cpp

Show First 20 Lines • Show All 1,451 Lines • ▼ Show 20 Lines virtual void printScop(raw_ostream &OS, Scop &S) const override {
OS << "DeLICM result:\n"; OS << "DeLICM result:\n";
Impl->print(OS); Impl->print(OS);
} }
virtual void releaseMemory() override { Impl.reset(); } virtual void releaseMemory() override { Impl.reset(); }
}; };
char DeLICMWrapperPass::ID; char DeLICMWrapperPass::ID;
/// Print result from DeLICMWrapperPass.
class DeLICMPrinterLegacyPass : public ScopPass {
public:
static char ID;
DeLICMPrinterLegacyPass() : DeLICMPrinterLegacyPass(outs()){};
explicit DeLICMPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
DeLICMWrapperPass &P = getAnalysis<DeLICMWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<DeLICMWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char DeLICMPrinterLegacyPass::ID = 0;
} // anonymous namespace } // anonymous namespace
Pass *polly::createDeLICMWrapperPass() { return new DeLICMWrapperPass(); } Pass *polly::createDeLICMWrapperPass() { return new DeLICMWrapperPass(); }
llvm::Pass *polly::createDeLICMPrinterLegacyPass(llvm::raw_ostream &OS) {
return new DeLICMPrinterLegacyPass(OS);
}
llvm::PreservedAnalyses polly::DeLICMPass::run(Scop &S, llvm::PreservedAnalyses polly::DeLICMPass::run(Scop &S,
ScopAnalysisManager &SAM, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, ScopStandardAnalysisResults &SAR,
SPMUpdater &U) { SPMUpdater &U) {
return runDeLICMUsingNPM(S, SAM, SAR, U, nullptr); return runDeLICMUsingNPM(S, SAM, SAR, U, nullptr);
} }
llvm::PreservedAnalyses DeLICMPrinterPass::run(Scop &S, llvm::PreservedAnalyses DeLICMPrinterPass::run(Scop &S,
Show All 18 Lines
} }
INITIALIZE_PASS_BEGIN(DeLICMWrapperPass, "polly-delicm", "Polly - DeLICM/DePRE", INITIALIZE_PASS_BEGIN(DeLICMWrapperPass, "polly-delicm", "Polly - DeLICM/DePRE",
false, false) false, false)
INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(DeLICMWrapperPass, "polly-delicm", "Polly - DeLICM/DePRE", INITIALIZE_PASS_END(DeLICMWrapperPass, "polly-delicm", "Polly - DeLICM/DePRE",
false, false) false, false)
INITIALIZE_PASS_BEGIN(DeLICMPrinterLegacyPass, "polly-print-delicm",
"Polly - Print DeLICM/DePRE", false, false)
INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass)
INITIALIZE_PASS_END(DeLICMPrinterLegacyPass, "polly-print-delicm",
"Polly - Print DeLICM/DePRE", false, false)

polly/lib/Transform/FlattenSchedule.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linespublic:
virtual void releaseMemory() override { virtual void releaseMemory() override {
OldSchedule = {}; OldSchedule = {};
IslCtx.reset(); IslCtx.reset();
} }
}; };
char FlattenSchedule::ID; char FlattenSchedule::ID;
/// Print result from FlattenSchedule.
class FlattenSchedulePrinterLegacyPass : public ScopPass {
public:
static char ID;
FlattenSchedulePrinterLegacyPass()
: FlattenSchedulePrinterLegacyPass(outs()){};
explicit FlattenSchedulePrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
FlattenSchedule &P = getAnalysis<FlattenSchedule>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<FlattenSchedule>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char FlattenSchedulePrinterLegacyPass::ID = 0;
} // anonymous namespace } // anonymous namespace
Pass *polly::createFlattenSchedulePass() { return new FlattenSchedule(); } Pass *polly::createFlattenSchedulePass() { return new FlattenSchedule(); }
Pass *polly::createFlattenSchedulePrinterLegacyPass(llvm::raw_ostream &OS) {
return new FlattenSchedulePrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(FlattenSchedule, "polly-flatten-schedule", INITIALIZE_PASS_BEGIN(FlattenSchedule, "polly-flatten-schedule",
"Polly - Flatten schedule", false, false) "Polly - Flatten schedule", false, false)
INITIALIZE_PASS_END(FlattenSchedule, "polly-flatten-schedule", INITIALIZE_PASS_END(FlattenSchedule, "polly-flatten-schedule",
"Polly - Flatten schedule", false, false) "Polly - Flatten schedule", false, false)
INITIALIZE_PASS_BEGIN(FlattenSchedulePrinterLegacyPass,
"polly-print-flatten-schedule",
"Polly - Print flattened schedule", false, false)
INITIALIZE_PASS_DEPENDENCY(FlattenSchedule)
INITIALIZE_PASS_END(FlattenSchedulePrinterLegacyPass,
"polly-print-flatten-schedule",
"Polly - Print flattened schedule", false, false)

polly/lib/Transform/ForwardOpTree.cpp

Show First 20 Lines • Show All 1,137 Lines • ▼ Show 20 Lines void printScop(raw_ostream &OS, Scop &S) const override {
assert(Impl->getScop() == &S); assert(Impl->getScop() == &S);
Impl->print(OS); Impl->print(OS);
} }
void releaseMemory() override { Impl.reset(); } void releaseMemory() override { Impl.reset(); }
}; // class ForwardOpTree }; // class ForwardOpTree
char ForwardOpTreeWrapperPass::ID; char ForwardOpTreeWrapperPass::ID;
/// Print result from ForwardOpTreeWrapperPass.
class ForwardOpTreePrinterLegacyPass : public ScopPass {
public:
static char ID;
ForwardOpTreePrinterLegacyPass() : ForwardOpTreePrinterLegacyPass(outs()){};
explicit ForwardOpTreePrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
ForwardOpTreeWrapperPass &P = getAnalysis<ForwardOpTreeWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<ForwardOpTreeWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char ForwardOpTreePrinterLegacyPass::ID = 0;
} // namespace } // namespace
Pass *polly::createForwardOpTreeWrapperPass() { Pass *polly::createForwardOpTreeWrapperPass() {
return new ForwardOpTreeWrapperPass(); return new ForwardOpTreeWrapperPass();
} }
Pass *polly::createForwardOpTreePrinterLegacyPass(llvm::raw_ostream &OS) {
return new ForwardOpTreePrinterLegacyPass(OS);
}
llvm::PreservedAnalyses ForwardOpTreePass::run(Scop &S, llvm::PreservedAnalyses ForwardOpTreePass::run(Scop &S,
ScopAnalysisManager &SAM, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, ScopStandardAnalysisResults &SAR,
SPMUpdater &U) { SPMUpdater &U) {
return runForwardOpTreeUsingNPM(S, SAM, SAR, U, nullptr); return runForwardOpTreeUsingNPM(S, SAM, SAR, U, nullptr);
} }
llvm::PreservedAnalyses llvm::PreservedAnalyses
ForwardOpTreePrinterPass::run(Scop &S, ScopAnalysisManager &SAM, ForwardOpTreePrinterPass::run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, SPMUpdater &U) { ScopStandardAnalysisResults &SAR, SPMUpdater &U) {
return runForwardOpTreeUsingNPM(S, SAM, SAR, U, &OS); return runForwardOpTreeUsingNPM(S, SAM, SAR, U, &OS);
} }
INITIALIZE_PASS_BEGIN(ForwardOpTreeWrapperPass, "polly-optree", INITIALIZE_PASS_BEGIN(ForwardOpTreeWrapperPass, "polly-optree",
"Polly - Forward operand tree", false, false) "Polly - Forward operand tree", false, false)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(ForwardOpTreeWrapperPass, "polly-optree", INITIALIZE_PASS_END(ForwardOpTreeWrapperPass, "polly-optree",
"Polly - Forward operand tree", false, false) "Polly - Forward operand tree", false, false)
INITIALIZE_PASS_BEGIN(ForwardOpTreePrinterLegacyPass, "polly-print-optree",
"Polly - Print forward operand tree result", false, false)
INITIALIZE_PASS_DEPENDENCY(ForwardOpTreeWrapperPass)
INITIALIZE_PASS_END(ForwardOpTreePrinterLegacyPass, "polly-print-optree",
"Polly - Print forward operand tree result", false, false)

polly/lib/Transform/ScheduleOptimizer.cpp

Show First 20 Lines • Show All 1,002 Lines • ▼ Show 20 Lines
} }
llvm::PreservedAnalyses llvm::PreservedAnalyses
IslScheduleOptimizerPrinterPass::run(Scop &S, ScopAnalysisManager &SAM, IslScheduleOptimizerPrinterPass::run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, ScopStandardAnalysisResults &SAR,
SPMUpdater &U) { SPMUpdater &U) {
return runIslScheduleOptimizerUsingNPM(S, SAM, SAR, U, &OS); return runIslScheduleOptimizerUsingNPM(S, SAM, SAR, U, &OS);
} }
//===----------------------------------------------------------------------===//
namespace {
/// Print result from IslScheduleOptimizerWrapperPass.
class IslScheduleOptimizerPrinterLegacyPass : public ScopPass {
public:
static char ID;
IslScheduleOptimizerPrinterLegacyPass()
: IslScheduleOptimizerPrinterLegacyPass(outs()) {}
explicit IslScheduleOptimizerPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
IslScheduleOptimizerWrapperPass &P =
getAnalysis<IslScheduleOptimizerWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<IslScheduleOptimizerWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char IslScheduleOptimizerPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createIslScheduleOptimizerPrinterLegacyPass(raw_ostream &OS) {
return new IslScheduleOptimizerPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(IslScheduleOptimizerPrinterLegacyPass,
"polly-print-opt-isl",
"Polly - Print optimizer schedule of SCoP", false, false);
INITIALIZE_PASS_DEPENDENCY(IslScheduleOptimizerWrapperPass)
INITIALIZE_PASS_END(IslScheduleOptimizerPrinterLegacyPass,
"polly-print-opt-isl",
"Polly - Print optimizer schedule of SCoP", false, false)

polly/lib/Transform/Simplify.cpp

Show First 20 Lines • Show All 844 Lines • ▼ Show 20 LinesPass *polly::createSimplifyWrapperPass(int CallNo) {
return new SimplifyWrapperPass(CallNo); return new SimplifyWrapperPass(CallNo);
} }
INITIALIZE_PASS_BEGIN(SimplifyWrapperPass, "polly-simplify", "Polly - Simplify", INITIALIZE_PASS_BEGIN(SimplifyWrapperPass, "polly-simplify", "Polly - Simplify",
false, false) false, false)
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
INITIALIZE_PASS_END(SimplifyWrapperPass, "polly-simplify", "Polly - Simplify", INITIALIZE_PASS_END(SimplifyWrapperPass, "polly-simplify", "Polly - Simplify",
false, false) false, false)
//===----------------------------------------------------------------------===//
namespace {
/// Print result from SimplifyWrapperPass.
class SimplifyPrinterLegacyPass : public ScopPass {
public:
static char ID;
SimplifyPrinterLegacyPass() : SimplifyPrinterLegacyPass(outs()) {}
explicit SimplifyPrinterLegacyPass(llvm::raw_ostream &OS)
: ScopPass(ID), OS(OS) {}
bool runOnScop(Scop &S) override {
SimplifyWrapperPass &P = getAnalysis<SimplifyWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
ScopPass::getAnalysisUsage(AU);
AU.addRequired<SimplifyWrapperPass>();
AU.setPreservesAll();
}
private:
llvm::raw_ostream &OS;
};
char SimplifyPrinterLegacyPass::ID = 0;
} // namespace
Pass *polly::createSimplifyPrinterLegacyPass(raw_ostream &OS) {
return new SimplifyPrinterLegacyPass(OS);
}
INITIALIZE_PASS_BEGIN(SimplifyPrinterLegacyPass, "polly-print-simplify",
"Polly - Print Simplify actions", false, false)
INITIALIZE_PASS_DEPENDENCY(SimplifyWrapperPass)
INITIALIZE_PASS_END(SimplifyPrinterLegacyPass, "polly-print-simplify",
"Polly - Print Simplify actions", false, false)

polly/test/CodeGen/20100622.ll

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

polly/test/CodeGen/20100720-MultipleConditions.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s ; RUN: opt %loadPolly -polly-ast -disable-output < %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 86 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/bad_alignment.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -analyze 2>&1 < %s | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -disable-output 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/test/CodeGen/MemAccess/create_arrays.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s 2>&1 | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -S < %s 2>&1 | FileCheck %s --check-prefix=CODEGEN
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
; B[i][j] = beta * A[i][k]; ; B[i][j] = beta * A[i][k];
; ;
; ;
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

polly/test/CodeGen/MemAccess/create_arrays_heap.ll

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

polly/test/CodeGen/MemAccess/default_aligned_new_access_function.ll

; RUN: opt %loadPolly -basic-aa -polly-import-jscop -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-import-jscop -disable-output < %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/test/CodeGen/MemAccess/map_scalar_access.ll

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

polly/test/CodeGen/MemAccess/simple_analyze.ll

;RUN: opt %loadPolly -polly-import-jscop -analyze -polly-import-jscop-postfix=transformed < %s | FileCheck %s ;RUN: opt %loadPolly -polly-print-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s | FileCheck %s
;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -polly-vectorizer=polly -S < %s | FileCheck %s --check-prefix=JSCOPVEC ;RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-codegen -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:
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

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

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

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

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

polly/test/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-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction. ; Make sure we correctly forward the reference to 'A' to the OpenMP subfunction.
; ;
; void loop_references_outer_ids(float *A) { ; void loop_references_outer_ids(float *A) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] = i; ; A[i] = i;
; } ; }
Show All 36 Lines

polly/test/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-parallel -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-codegen -S < %s | FileCheck %s -check-prefix=IR
; ;
; float A[100]; ; float A[100];
; ;
; void loop_references_outer_ids(long n) { ; void loop_references_outer_ids(long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; for (long k = 0; k < n + i; k++) ; for (long k = 0; k < n + i; k++)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/new_multidim_access.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt %loadPolly -polly-print-import-jscop \
; RUN: -analyze < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt %loadPolly -polly-import-jscop \
; RUN: -polly-codegen -S < %s \ ; RUN: -polly-codegen -S < %s \
; RUN: -polly-parallel \ ; RUN: -polly-parallel \
; RUN: | FileCheck %s -check-prefix=IR ; RUN: | FileCheck %s -check-prefix=IR
; void new_multidim_access(long n, long m, float A[][m]) { ; void new_multidim_access(long n, long m, float A[][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/test/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-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; - Test the case where scalar evolution references a loop that is outside ; - Test the case where scalar evolution references a loop that is outside
; of the scop, but does not contain the scop. ; of the scop, but does not contain the scop.
; AST: { ; AST: {
; AST-NEXT: #pragma simd ; AST-NEXT: #pragma simd
Show All 34 Lines

polly/test/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-parallel -polly-parallel-force -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -S -verify-dom-info < %s | FileCheck %s -check-prefix=IR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-ast -analyze < %s | FileCheck %s -check-prefix=AST-STRIDE4 ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=AST-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -S < %s | FileCheck %s -check-prefix=IR-STRIDE4 ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -S < %s | FileCheck %s -check-prefix=IR-STRIDE4
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -polly-scheduling-chunksize=43 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC-CHUNKED ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -polly-scheduling-chunksize=43 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC-CHUNKED
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=static -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-STATIC
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -polly-scheduling-chunksize=4 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC-FOUR ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-codegen -polly-omp-backend=LLVM -polly-scheduling=dynamic -polly-scheduling-chunksize=4 -S -verify-dom-info < %s | FileCheck %s -check-prefix=LIBOMP-IR-DYNAMIC-FOUR
; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -polly-omp-backend=LLVM -S < %s | FileCheck %s -check-prefix=LIBOMP-IR-STRIDE4 ; RUN: opt %loadPolly -polly-parallel -polly-parallel-force -polly-import-jscop -polly-codegen -polly-omp-backend=LLVM -S < %s | FileCheck %s -check-prefix=LIBOMP-IR-STRIDE4
▲ Show 20 Lines • Show All 231 Lines • Show Last 20 Lines

polly/test/CodeGen/OpenMP/single_loop_with_loop_invariant_baseptr.ll

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

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

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

; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-codegen < %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-codegen -disable-output < %s
; ;
; CHECK: store i32 %tmp14_p_scalar_, i32* %tmp14.s2a ; CHECK: store i32 %tmp14_p_scalar_, i32* %tmp14.s2a
; CHECK: %tmp14.final_reload = load i32, i32* %tmp14.s2a ; CHECK: %tmp14.final_reload = load i32, i32* %tmp14.s2a
; CHECK: %tmp17b.final_reload = load i32, i32* %tmp17b.preload.s2a ; CHECK: %tmp17b.final_reload = load i32, i32* %tmp17b.preload.s2a
; CHECK: %tmp17.final_reload = load i32, i32* %tmp17.preload.s2a ; CHECK: %tmp17.final_reload = load i32, i32* %tmp17.preload.s2a
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/CodeGen/constant_condition.ll

;RUN: opt %loadPolly -polly-prepare -polly-ast -analyze < %s | FileCheck %s ;RUN: opt %loadPolly -polly-prepare -polly-print-ast -disable-output < %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 46 Lines • Show Last 20 Lines

polly/test/CodeGen/dominance_problem_after_early_codegen_bailout.ll

; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %s
; ;
; This caused dominance problems at some point as we do bail out during ; This caused dominance problems at some point as we do bail out during
; code generation. Just verify it runs through. ; code generation. Just verify it runs through.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.hashheader.0.5.10.165.180.185 = type { i16, i16, i16, i16, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, [5 x i8], [13 x i8], i8, i8, i8, [228 x i16], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [128 x i8], [100 x [11 x i8]], [100 x i32], [100 x i32], i16 } %struct.hashheader.0.5.10.165.180.185 = type { i16, i16, i16, i16, i16, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, [5 x i8], [13 x i8], i8, i8, i8, [228 x i16], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [228 x i8], [128 x i8], [100 x [11 x i8]], [100 x i32], [100 x i32], i16 }
Show All 40 Lines

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

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

polly/test/CodeGen/inner_scev_sdiv_in_lb.ll

; RUN: opt %loadPolly \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
; RUN: opt %loadPolly \
; RUN: -S -polly-codegen < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; CHECK: [N] -> { Stmt_bb11[i0, i1] : i0 < N and i1 >= 0 and 3i1 <= -3 + i0 }; ; CHECK: [N] -> { Stmt_bb11[i0, i1] : i0 < N and i1 >= 0 and 3i1 <= -3 + i0 };
; CODEGEN: polly ; CODEGEN: polly
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; for (int j = 0; j < i / 3; j++) ; for (int j = 0; j < i / 3; j++)
; A[i] += A[j]; ; A[i] += A[j];
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

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

polly/test/CodeGen/invariant_cannot_handle_void.ll

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

polly/test/CodeGen/invariant_load_base_pointer_conditional_2.ll

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

polly/test/CodeGen/invariant_load_not_executed_but_in_parameters.ll

; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -disable-output < %s
; ;
; Check that this does not crash as the invariant load is not executed (thus ; Check that this does not crash as the invariant load is not executed (thus
; not preloaded) but still referenced by one of the parameters. ; not preloaded) but still referenced by one of the parameters.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.Exp.204.248.358 = type { %struct.Exp_.200.244.354*, i32, i32, i32, %struct.Exp.204.248.358*, %struct.Exp.204.248.358*, %union.anon.2.201.245.355, %union.anon.3.202.246.356, %union.anon.4.203.247.357 } %struct.Exp.204.248.358 = type { %struct.Exp_.200.244.354*, i32, i32, i32, %struct.Exp.204.248.358*, %struct.Exp.204.248.358*, %union.anon.2.201.245.355, %union.anon.3.202.246.356, %union.anon.4.203.247.357 }
%struct.Exp_.200.244.354 = type { i32, i32, i32, i32, %struct.Id.199.243.353* } %struct.Exp_.200.244.354 = type { i32, i32, i32, i32, %struct.Id.199.243.353* }
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

polly/test/CodeGen/invariant_load_parameters_cyclic_dependence.ll

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

polly/test/CodeGen/invariant_verify_function_failed.ll

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

polly/test/CodeGen/invariant_verify_function_failed_2.ll

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

polly/test/CodeGen/loop_with_condition.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %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 165 Lines • Show Last 20 Lines

polly/test/CodeGen/loop_with_condition_2.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -polly-ast-detect-parallel -disable-output < %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 131 Lines • Show Last 20 Lines

polly/test/CodeGen/loop_with_condition_ineq.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %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 165 Lines • Show Last 20 Lines

polly/test/CodeGen/loop_with_condition_nested.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -basic-aa -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
;#include <string.h> ;#include <string.h>
;#define N 1024 ;#define N 1024
;int A[N]; ;int A[N];
;int B[N]; ;int B[N];
; ;
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

polly/test/CodeGen/multiple_sai_fro_same_base_address.ll

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

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

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

polly/test/CodeGen/param_div_div_div_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; ;
; Check that we guard the divisions because we moved them and thereby increased ; Check that we guard the divisions because we moved them and thereby increased
; their domain. ; their domain.
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [p_0] -> { : false } ; CHECK-NEXT: [p_0] -> { : false }
; CHECK: p0: (((zext i32 %a to i64) /u (zext i32 %b to i64)) /u ((zext i32 %c to i64) /u (zext i32 %d to i64))) ; CHECK: p0: (((zext i32 %a to i64) /u (zext i32 %b to i64)) /u ((zext i32 %c to i64) /u (zext i32 %d to i64)))
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/CodeGen/phi_conditional_simple_1.ll

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

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

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

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

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

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

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

polly/test/CodeGen/pointer_rem.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-ast -analyze -S < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-print-ast -disable-output -S < %s | FileCheck %s --check-prefix=AST
; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-codegen -S < %s | FileCheck %s --check-prefix=CODEGEN
target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
; This test is to ensure that for we generate signed remainder for ; This test is to ensure that for we generate signed remainder for
; the polly.cond check. ; the polly.cond check.
Show All 39 Lines

polly/test/CodeGen/reduction_2.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze \ ; RUN: opt %loadPolly -basic-aa -polly-invariant-load-hoisting=true -polly-print-ast -disable-output < %s | FileCheck %s --allow-empty
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
;#include <string.h> ;#include <string.h>
;#include <stdio.h> ;#include <stdio.h>
;#define N 1021 ;#define N 1021
; ;
;int main () { ;int main () {
; int i; ; int i;
; int A[N]; ; int A[N];
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

polly/test/CodeGen/reduction_simple_binary.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/CodeGen/region_exiting-domtree.ll

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

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

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

polly/test/CodeGen/sequential_loops.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 128 Lines • Show Last 20 Lines

polly/test/CodeGen/simple_nonaffine_loop.ll

; RUN: opt %loadPolly -polly-ast -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-allow-nonaffine -disable-output < %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 49 Lines • Show Last 20 Lines

polly/test/CodeGen/single_do_loop_int_max_iterations.ll

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 83 Lines • Show Last 20 Lines

polly/test/CodeGen/single_do_loop_int_param_iterations.ll

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 67 Lines • Show Last 20 Lines

polly/test/CodeGen/single_do_loop_ll_max_iterations.ll

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

polly/test/CodeGen/single_do_loop_one_iteration.ll

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 60 Lines • Show Last 20 Lines

polly/test/CodeGen/single_do_loop_scev_replace.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 85 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 75 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_int_max_iterations.ll

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 62 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_ll_max_iterations.ll

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 62 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_one_iteration.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 59 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_param.ll

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

polly/test/CodeGen/single_loop_param_less_equal.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS ; RUN: opt %loadPolly -polly-codegen -loops -analyze < %s | FileCheck %s -check-prefix=LOOPS
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
@A = common global [1024 x i32] zeroinitializer @A = common global [1024 x i32] zeroinitializer
define void @bar(i64 %n) { define void @bar(i64 %n) {
start: start:
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/CodeGen/single_loop_param_less_than.ll

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

polly/test/CodeGen/single_loop_zero_iterations.ll

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=SCALAR --allow-empty
;#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 58 Lines • Show Last 20 Lines

polly/test/CodeGen/split_edge_of_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -verify-region-info -analyze < %s ; RUN: opt %loadPolly -polly-codegen -verify-region-info -disable-output < %s
; ;
; This is a scop directly precedented by a region, i.e. the scop's entry is the ; This is a scop directly precedented by a region, i.e. the scop's entry is the
; region's exit block. This test is to ensure that the RegionInfo is correctly ; region's exit block. This test is to ensure that the RegionInfo is correctly
; preserved. ; preserved.
; ;
; CHECK: Valid Region for Scop: region2 => return ; CHECK: Valid Region for Scop: region2 => return
; ;
define void @f1(i64* %A, i64 %N) nounwind { define void @f1(i64* %A, i64 %N) nounwind {
Show All 21 Lines

polly/test/CodeGen/test.ll

; RUN: opt %loadPolly -polly-ast -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 58 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-ast -analyze -polly-ignore-aliasing < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt %loadPolly -polly-print-ast -polly-ignore-aliasing -disable-output < %s | FileCheck %s -check-prefix=SCALAR
; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -disable-output < %s ; RUN: opt %loadPolly -polly-codegen -polly-ignore-aliasing -disable-output < %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; SCALAR: if ( ; SCALAR: if (
; SCALAR: { ; SCALAR: {
; SCALAR: Stmt_for_1(0); ; SCALAR: Stmt_for_1(0);
; SCALAR: for (int c0 = 1; c0 <= -Scalar0_val + 99; c0 += 1) ; SCALAR: for (int c0 = 1; c0 <= -Scalar0_val + 99; c0 += 1)
; SCALAR: Stmt_for_1(c0); ; SCALAR: Stmt_for_1(c0);
Show All 31 Lines

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

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

polly/test/CodeGen/variant_load_empty_domain.ll

; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %s
; ;
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 1; i < 10; i++) { ; for (int i = 1; i < 10; i++) {
; A[i]++; ; A[i]++;
; if (i > 10) ; if (i > 10)
; A[i] += A[0]; ; A[i] += A[0];
; } ; }
Show All 38 Lines

polly/test/DeLICM/confused_order.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-delicm -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-delicm -disable-output -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s -check-prefix=REMARKS ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-delicm -disable-output -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s -check-prefix=REMARKS
; ;
; ForwardOptree changes the SCoP and may already map some accesses. ; ForwardOptree changes the SCoP and may already map some accesses.
; DeLICM must be prepared to encounter implicit reads ; DeLICM must be prepared to encounter implicit reads
; (isOriginalScalarKind()) that occur at the beginning of the SCoP ; (isOriginalScalarKind()) that occur at the beginning of the SCoP
; to an array (isLatestArrayKind()). Otherwise it may confuse the ; to an array (isLatestArrayKind()). Otherwise it may confuse the
; MemoryAccess execution order. ; MemoryAccess execution order.
Show All 32 Lines

polly/test/DeLICM/contradicting_assumed_context_and_domain.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; The domain of bb14 contradicts the SCoP's assumptions. This leads to ; The domain of bb14 contradicts the SCoP's assumptions. This leads to
; 'anything goes' inside the statement since it is never executed, ; 'anything goes' inside the statement since it is never executed,
; including changing a memory write inside to ; including changing a memory write inside to
; [p_0, arg1] -> { Stmt_bb14[i0] -> MemRef_tmp[o0] : false } ; [p_0, arg1] -> { Stmt_bb14[i0] -> MemRef_tmp[o0] : false }
; (i.e.: never write) ; (i.e.: never write)
; ;
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/test/DeLICM/load-in-cond-inf-loop.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; When %b is 0, %for.body13 is an infite loop. In this case the loaded ; When %b is 0, %for.body13 is an infite loop. In this case the loaded
; value %1 is not used anywhere. ; value %1 is not used anywhere.
; This is a problem when DeLICM tries to map %1 to %arrayidx16 because ; This is a problem when DeLICM tries to map %1 to %arrayidx16 because
; %1 has no corresponding when %b == 0 and therefore hat no location ; %1 has no corresponding when %b == 0 and therefore hat no location
; where it can be mapped to. However, since %b == 0 results in an ; where it can be mapped to. However, since %b == 0 results in an
; infinite loop, it should not in the Context, or in this case, in the ; infinite loop, it should not in the Context, or in this case, in the
; InvalidContext. ; InvalidContext.
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/DeLICM/map_memset_zero.ll

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

polly/test/DeLICM/nomap_alreadymapped.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi1 = 0.0, phi2 = 0.0; ; double phi1 = 0.0, phi2 = 0.0;
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
; phi1 += 4.2; ; phi1 += 4.2;
; phi2 += 29.0; ; phi2 += 29.0;
; } ; }
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/DeLICM/nomap_escaping.ll

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

polly/test/DeLICM/nomap_occupied.ll

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

polly/test/DeLICM/nomap_readonly.ll

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

polly/test/DeLICM/nomap_spuriouswrite.ll

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

polly/test/DeLICM/nomap_storagesize.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; void func(float *A) { ; void func(float *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = fsomeval; ; A[j] = fsomeval;
; } ; }
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/DeLICM/nomap_writewrite.ll

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

polly/test/DeLICM/outofquota-reverseDomain.ll

; RUN: opt %loadPolly -polly-delicm-max-ops=1000000 -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-delicm-max-ops=1000000 -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; This causes an assertion to fail on out-of-quota after 1000000 operations. ; This causes an assertion to fail on out-of-quota after 1000000 operations.
; (The error was specific to -polly-delicm-max-ops=1000000 and changes ; (The error was specific to -polly-delicm-max-ops=1000000 and changes
; in the implementation are likely to change the number of operations ; in the implementation are likely to change the number of operations
; up to the point where the error uses to occur) ; up to the point where the error uses to occur)
; ;
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

polly/test/DeLICM/pass_existence.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-delicm -disable-output < %s
; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly "-passes=scop(print<polly-delicm>)" -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly "-passes=scop(print<polly-delicm>)" -disable-output < %s | FileCheck %s
; ;
; Simple test for the existence of the DeLICM pass. ; Simple test for the existence of the DeLICM pass.
; ;
; // Simplest detected SCoP to run DeLICM on. ; // Simplest detected SCoP to run DeLICM on.
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: A[0] = 0.0; ; body: A[0] = 0.0;
; } ; }
Show All 28 Lines

polly/test/DeLICM/pr41656.ll

; RUN: opt %loadPolly -polly-scops -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; llvm.org/PR41656 ; llvm.org/PR41656
; ;
; This test case has an InvalidContext such that part of the predecessors ; This test case has an InvalidContext such that part of the predecessors
; of for.body.us.i lie within the invalid context. This causes a ; of for.body.us.i lie within the invalid context. This causes a
; consistency check withing the invalid context of PR41656 to fail. ; consistency check withing the invalid context of PR41656 to fail.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

polly/test/DeLICM/pr48783.ll

; RUN: opt %loadPolly -polly-scops -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; llvm.org/PR48783 ; llvm.org/PR48783
; ;
; PHI predecessors of statement instances can only be reliably derived in defined behaviour situations. In this case, the inner loop's counter would overflow when its upper bound (%call24) is lower than its lower bound (2). However, due to the nsw flag, this would be undefined behavior and therefore not added to any runtime-check context, but to the defined-behaviour context. ; PHI predecessors of statement instances can only be reliably derived in defined behaviour situations. In this case, the inner loop's counter would overflow when its upper bound (%call24) is lower than its lower bound (2). However, due to the nsw flag, this would be undefined behavior and therefore not added to any runtime-check context, but to the defined-behaviour context.
; ;
; Dereived from test case pr41656.ll ; Dereived from test case pr41656.ll
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

polly/test/DeLICM/reduction.ll

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

polly/test/DeLICM/reduction_constant_selfconflict.ll

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

polly/test/DeLICM/reduction_looprotate.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-flatten-schedule -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; for (int i = 0; i < 4; i += 1) { /* reduction */ ; for (int i = 0; i < 4; i += 1) { /* reduction */
; double phi = A[j]; ; double phi = A[j];
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/DeLICM/reduction_looprotate_alwaystaken.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm-overapproximate-writes=true -polly-delicm-compute-known=true -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; Verify that delicm can cope with never taken PHI incoming edges. ; Verify that delicm can cope with never taken PHI incoming edges.
; The edge %body -> %body_phi is never taken, hence the access MemoryKind::PHI, ; The edge %body -> %body_phi is never taken, hence the access MemoryKind::PHI,
; WRITE in %body for %phi is never used. ; WRITE in %body for %phi is never used.
; When mapping %phi, the write's access relation is the empty set. ; When mapping %phi, the write's access relation is the empty set.
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/DeLICM/reduction_looprotate_gvnpre.ll

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

polly/test/DeLICM/reduction_looprotate_gvnpre_cond1.ll

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

polly/test/DeLICM/reduction_looprotate_gvnpre_cond2.ll

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

polly/test/DeLICM/reduction_looprotate_gvnpre_nopreheader.ll

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

polly/test/DeLICM/reduction_looprotate_hoisted.ll

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

polly/test/DeLICM/reduction_looprotate_licm.ll

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

polly/test/DeLICM/reduction_looprotate_licm2.ll

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

polly/test/DeLICM/reduction_looprotate_licm_double_write.ll

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

polly/test/DeLICM/reduction_looprotate_licm_nopreheader.ll

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

polly/test/DeLICM/reduction_looprotate_load.ll

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

polly/test/DeLICM/reduction_looprotate_loopguard_gvnpre.ll

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

polly/test/DeLICM/reduction_looprotate_loopguard_licm1.ll

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

polly/test/DeLICM/reduction_looprotate_loopguard_licm2.ll

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

polly/test/DeLICM/reduction_looprotate_loopguard_licm3.ll

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

polly/test/DeLICM/reduction_looprotate_readonly.ll

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

polly/test/DeLICM/reduction_looprotate_synthesizable.ll

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

polly/test/DeLICM/reduction_looprotate_undef.ll

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

polly/test/DeLICM/reduction_overapproximate.ll

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

polly/test/DeLICM/reduction_preheader.ll

; RUN: opt %loadPolly -polly-flatten-schedule -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-flatten-schedule -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

polly/test/DeLICM/reduction_unrelatedunusual.ll

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

polly/test/DeLICM/reject_loadafterstore.ll

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

polly/test/DeLICM/reject_outofquota.ll

; RUN: opt %loadPolly -polly-delicm -analyze -pass-remarks-analysis=polly-delicm -polly-delicm-max-ops=1 < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -pass-remarks-analysis=polly-delicm -polly-delicm-max-ops=1 -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-delicm -polly-dependences -analyze -polly-delicm-max-ops=1 -polly-dependences-computeout=0 < %s | FileCheck %s -check-prefix=DEP ; RUN: opt %loadPolly -polly-delicm -polly-print-dependences -polly-delicm-max-ops=1 -polly-dependences-computeout=0 -disable-output < %s | FileCheck %s -check-prefix=DEP
; ;
; void func(double *A) { ; void func(double *A) {
; for (int j = 0; j < 2; j += 1) { /* outer */ ; for (int j = 0; j < 2; j += 1) { /* outer */
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[j] = phi; ; A[j] = phi;
; } ; }
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/DeLICM/reject_storeafterstore.ll

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

polly/test/DeLICM/reject_storeinsubregion.ll

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

polly/test/DeLICM/reject_unusualstore.ll

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

polly/test/DeLICM/skip_maywrite.ll

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

polly/test/DeLICM/skip_notinloop.ll

; RUN: opt %loadPolly -polly-delicm -analyze -pass-remarks-missed=polly-delicm < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -pass-remarks-missed=polly-delicm -disable-output < %s 2>&1 | FileCheck %s
; ;
; void func(double *A) { ; void func(double *A) {
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < 4; i += 1) /* reduction */ ; for (int i = 0; i < 4; i += 1) /* reduction */
; phi += 4.2; ; phi += 4.2;
; A[0] = phi; ; A[0] = phi;
; } ; }
; ;
Show All 36 Lines

polly/test/DeLICM/skip_scalaraccess.ll

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

polly/test/DeadCodeElimination/chained_iterations.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-print-ast -disable-output < %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"
; ;
; 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 51 Lines • Show Last 20 Lines

polly/test/DeadCodeElimination/chained_iterations_2.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-print-ast -disable-output < %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"
; ;
; 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 55 Lines • Show Last 20 Lines

polly/test/DeadCodeElimination/computeout.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dce -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-dce -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly "-passes=scop(polly-dce,print<polly-ast>)" < %s | FileCheck %s ; RUN: opt -S %loadPolly "-passes=scop(polly-dce,print<polly-ast>)" < %s | FileCheck %s
; RUN: opt -S %loadPolly -basic-aa -polly-dce -polly-ast -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -basic-aa -polly-dce -polly-print-ast -polly-dependences-computeout=1 -disable-output < %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"
; 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 53 Lines • Show Last 20 Lines

polly/test/DeadCodeElimination/dead_iteration_elimination.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-dce-precise-steps=2 -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly "-passes=scop(polly-dce,print<polly-ast>)" -polly-dependences-analysis-type=value-based -polly-dce-precise-steps=2 < %s | FileCheck %s ; RUN: opt -S %loadPolly "-passes=scop(polly-dce,print<polly-ast>)" -polly-dependences-analysis-type=value-based -polly-dce-precise-steps=2 < %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"
; ;
; 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/test/DeadCodeElimination/non-affine-affine-mix.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-print-ast -disable-output < %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[bar(i)] = i; ; S1: A[bar(i)] = 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 55 Lines • Show Last 20 Lines

polly/test/DeadCodeElimination/non-affine.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-dce -polly-print-ast -disable-output < %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[bar(i)] = i; ; A[bar(i)] = i;
; } ; }
; ;
Show All 28 Lines

polly/test/DeadCodeElimination/null_schedule.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-ast -analyze < %s | FileCheck %s -check-prefix=CHECK-DCE ; RUN: opt -S %loadPolly -basic-aa -polly-dependences-analysis-type=value-based -polly-dce -polly-print-ast -disable-output < %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"
; 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++ )
; A[i] = B[i] * 2; ; A[i] = B[i] * 2;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/DependenceInfo/computeout.ll

; RUN: opt -S %loadPolly -polly-dependences -analyze < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt -S %loadPolly -polly-function-dependences -analyze < %s | FileCheck %s -check-prefix=FUNC-VALUE ; RUN: opt -S %loadPolly -polly-print-function-dependences -disable-output < %s | FileCheck %s -check-prefix=FUNC-VALUE
; RUN: opt -S %loadPolly -polly-dependences -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -polly-print-dependences -polly-dependences-computeout=1 -disable-output < %s | FileCheck %s -check-prefix=TIMEOUT
; RUN: opt -S %loadPolly -polly-function-dependences -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -polly-print-function-dependences -polly-dependences-computeout=1 -disable-output < %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"
; 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/test/DependenceInfo/different_schedule_dimensions.ll

; RUN: opt -S %loadPolly -polly-dependences \ ; RUN: opt -S %loadPolly -polly-print-dependences \
; RUN: -analyze < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly -polly-function-dependences \ ; RUN: opt -S %loadPolly -polly-print-function-dependences \
; RUN: -analyze < %s | FileCheck %s -check-prefix=FUNC ; RUN: -disable-output < %s | FileCheck %s -check-prefix=FUNC
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK: { Stmt_bb9[0] -> Stmt_bb10[0] } ; CHECK: { Stmt_bb9[0] -> Stmt_bb10[0] }
; CHECK: WAR dependences: ; CHECK: WAR dependences:
; CHECK: { Stmt_bb3[0] -> Stmt_bb10[0] } ; CHECK: { Stmt_bb3[0] -> Stmt_bb10[0] }
; CHECK: WAW dependences: ; CHECK: WAW dependences:
; CHECK: { Stmt_bb3[0] -> Stmt_bb10[0] } ; CHECK: { Stmt_bb3[0] -> Stmt_bb10[0] }
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/DependenceInfo/do_pluto_matmult.ll

; RUN: opt %loadPolly -basic-aa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt %loadPolly -basic-aa -polly-print-dependences -polly-dependences-analysis-type=value-based -disable-output < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt %loadPolly -basic-aa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY ; RUN: opt %loadPolly -basic-aa -polly-print-dependences -polly-dependences-analysis-type=memory-based -disable-output < %s | FileCheck %s -check-prefix=MEMORY
; RUN: opt %loadPolly -basic-aa -polly-function-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=FUNC-VALUE ; RUN: opt %loadPolly -basic-aa -polly-print-function-dependences -polly-dependences-analysis-type=value-based -disable-output < %s | FileCheck %s -check-prefix=FUNC-VALUE
; RUN: opt %loadPolly -basic-aa -polly-function-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=FUNC-MEMORY ; RUN: opt %loadPolly -basic-aa -polly-print-function-dependences -polly-dependences-analysis-type=memory-based -disable-output < %s | FileCheck %s -check-prefix=FUNC-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"
%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]
@B = common global [36 x [49 x double]] zeroinitializer, align 8 ; <[36 x [49 x double]]*> [#uses=3] @B = common global [36 x [49 x double]] zeroinitializer, align 8 ; <[36 x [49 x double]]*> [#uses=3]
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

polly/test/DependenceInfo/fine_grain_dep_0.ll

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

polly/test/DependenceInfo/generate_may_write_dependence_info.ll

; RUN: opt -S %loadPolly -polly-dependences -analyze < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s -check-prefix=VALUE
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; A.must.write.20: A[i] = 20; ; A.must.write.20: A[i] = 20;
; ;
; compute.i.square: if (i * i) ; compute.i.square: if (i * i)
; A.may.write.90: A[i] = 90; ; A.may.write.90: A[i] = 90;
; ;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/DependenceInfo/infeasible_context.ll

; RUN: opt %loadPolly -polly-function-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %s \
; RUN: | FileCheck %s -check-prefix=FUNC-SCOP ; RUN: | FileCheck %s -check-prefix=FUNC-SCOP
; RUN: opt %loadPolly -polly-function-dependences -analyze < %s \ ; RUN: opt %loadPolly -polly-print-function-dependences -disable-output < %s \
; RUN: | FileCheck %s -check-prefix=FUNC-DEPS ; RUN: | FileCheck %s -check-prefix=FUNC-DEPS
; ;
; FUNC-SCOP-NOT: Statement ; FUNC-SCOP-NOT: Statement
; FUNC-DEPS-LABEL: Printing analysis 'Polly - Calculate dependences for all the SCoPs of a function' for function 'readgeo' ; FUNC-DEPS-LABEL: Printing analysis 'Polly - Calculate dependences for all the SCoPs of a function' for function 'readgeo'
; FUNC-DEPS-NOT: RAW dependences ; FUNC-DEPS-NOT: RAW dependences
; ;
; Due to an infeasible run-time check, scop object is empty and we do not compute dependences. ; Due to an infeasible run-time check, scop object is empty and we do not compute dependences.
; ;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/DependenceInfo/may_writes_do_not_block_must_writes_for_war.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; ;
; Verify that the presence of a may-write (S1) between a read (S0) and a ; Verify that the presence of a may-write (S1) between a read (S0) and a
; must-write (S2) does not block the generation of RAW dependences. This makes ; must-write (S2) does not block the generation of RAW dependences. This makes
; sure that we capture as many RAW dependences as possible. ; sure that we capture as many RAW dependences as possible.
; ;
; For this example, we want both (S0(Read) -> S1 (May-Write)) as well as ; For this example, we want both (S0(Read) -> S1 (May-Write)) as well as
; (S0(Read) -> S2(Must-Write)). ; (S0(Read) -> S2(Must-Write)).
; ;
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_complex_location.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -polly-dependences-analysis-level=reference-wise -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-dependences -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -polly-dependences-analysis-level=access-wise -disable-output < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_dependences_equal_non_reduction_dependences.ll

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

polly/test/DependenceInfo/reduction_dependences_not_null.ll

; Test that the reduction dependences are always initialised, even in a case ; Test that the reduction dependences are always initialised, even in a case
; where we have no reduction. If this object is NULL, then isl operations on ; where we have no reduction. If this object is NULL, then isl operations on
; it will fail. ; it will fail.
; RUN: opt -S %loadPolly -polly-dependences -analyze < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s -check-prefix=VALUE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for(i = 0; i < 100; i++ ) ; for(i = 0; i < 100; i++ )
; S1: A[i] = 2; ; S1: A[i] = 2;
define void @sequential_writes() { define void @sequential_writes() {
entry: entry:
%A = alloca [200 x i32] %A = alloca [200 x i32]
Show All 22 Lines

polly/test/DependenceInfo/reduction_mixed_reduction_and_non_reduction_dependences.ll

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

polly/test/DependenceInfo/reduction_multiple_loops_array_sum.ll

; RUN: opt -basic-aa %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; RUN: opt -basic-aa %loadPolly -polly-dependences -polly-dependences-analysis-level=reference-wise -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-print-dependences -polly-dependences-analysis-level=reference-wise -disable-output < %s | FileCheck %s
; RUN: opt -basic-aa %loadPolly -polly-dependences -polly-dependences-analysis-level=access-wise -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-print-dependences -polly-dependences-analysis-level=access-wise -disable-output < %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-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : 0 <= i0 <= 99 and 0 <= i1 <= 98 } ; CHECK-NEXT: { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : 0 <= i0 <= 99 and 0 <= i1 <= 98 }
; ;
; 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/test/DependenceInfo/reduction_multiple_loops_array_sum_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basic-aa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -basic-aa -disable-output < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_multiple_loops_array_sum_3.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basic-aa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -basic-aa -disable-output < %s | FileCheck %s
; ;
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> Stmt_for_inc[i0, 1 + i1] : 0 <= i0 <= 99 and 0 <= i1 <= 98 } ; CHECK-NEXT: { Stmt_for_inc[i0, i1] -> Stmt_for_inc[i0, 1 + i1] : 0 <= i0 <= 99 and 0 <= i1 <= 98 }
; ;
; 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/test/DependenceInfo/reduction_multiple_reductions.ll

; RUN: opt %loadPolly -basic-aa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-dependences -disable-output < %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-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { } ; CHECK-NEXT: { }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_multiple_reductions_2.ll

; RUN: opt %loadPolly -basic-aa -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-dependences -disable-output < %s | FileCheck %s
; ;
; ;
; 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:
; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] ; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1]
; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0] ; Stmt_S1[i0, i1] -> Stmt_S2[i0, 0]
; ;
; These are the important WAW dependences, as they need to originate/end in only one iteration: ; These are the important WAW dependences, as they need to originate/end in only one iteration:
; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1] ; Stmt_S1[i0, 1023] -> Stmt_S2[i0, o1]
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_only_reduction_like_access.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %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/test/DependenceInfo/reduction_partially_escaping_intermediate_in_other_stmt.ll

; RUN: opt %loadPolly -polly-dependences -analyze -basic-aa < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -basic-aa -disable-output < %s | FileCheck %s
; ;
; CHECK: Reduction dependences: ; CHECK: Reduction dependences:
; CHECK-NEXT: [N] -> { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : 0 <= i0 <= 1023 and i1 >= 0 and 1024 - N + i0 <= i1 <= 1022 } ; CHECK-NEXT: [N] -> { Stmt_for_body3[i0, i1] -> Stmt_for_body3[i0, 1 + i1] : 0 <= i0 <= 1023 and i1 >= 0 and 1024 - N + i0 <= i1 <= 1022 }
; ;
; 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/test/DependenceInfo/reduction_privatization_deps.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : 0 <= i0 <= 1023 and i1 >= 0 and -i0 < i1 <= 1024 - i0 and i1 <= 1023; Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and 0 <= o0 <= i0 } ; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[-1 + i0 + i1] : 0 <= i0 <= 1023 and i1 >= 0 and -i0 < i1 <= 1024 - i0 and i1 <= 1023; Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and 0 <= o0 <= i0 }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i0 >= 0 and 0 <= i1 <= 1023 - i0; Stmt_S2[i0] -> Stmt_S2[1 + i0] : 0 <= i0 <= 1022 } ; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i0 >= 0 and 0 <= i1 <= 1023 - i0; Stmt_S2[i0] -> Stmt_S2[1 + i0] : 0 <= i0 <= 1022 }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i0 >= 0 and 0 <= i1 <= 1023 - i0; Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and 0 <= o0 <= i0 } ; CHECK-NEXT: { Stmt_S1[i0, i1] -> Stmt_S2[i0 + i1] : i0 >= 0 and 0 <= i1 <= 1023 - i0; Stmt_S0[i0] -> Stmt_S1[o0, i0 - o0] : i0 <= 1023 and 0 <= o0 <= i0 }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_privatization_deps_2.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %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-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : 0 <= i0 <= 97 and 0 <= o1 <= 99; Stmt_S1[i0] -> Stmt_S3[i0] : 0 <= i0 <= 98 } ; CHECK-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : 0 <= i0 <= 97 and 0 <= o1 <= 99; Stmt_S1[i0] -> Stmt_S3[i0] : 0 <= i0 <= 98 }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : 0 <= i0 <= 97 and 0 <= o1 <= 99; Stmt_S1[i0] -> Stmt_S3[i0] : 0 <= i0 <= 98 } ; CHECK-NEXT: { Stmt_S3[i0] -> Stmt_S2[1 + i0, o1] : 0 <= i0 <= 97 and 0 <= o1 <= 99; Stmt_S1[i0] -> Stmt_S3[i0] : 0 <= i0 <= 98 }
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_privatization_deps_3.ll

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

polly/test/DependenceInfo/reduction_privatization_deps_4.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 } ; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 } ; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 } ; CHECK-NEXT: { Stmt_S1[i0] -> Stmt_S2[i0, i0] : 0 <= i0 <= 98; Stmt_S2[i0, i0] -> Stmt_S3[i0] : 0 <= i0 <= 98; Stmt_S3[i0] -> Stmt_S2[o0, i0] : i0 >= 0 and i0 < o0 <= 98; Stmt_S2[i0, i1] -> Stmt_S1[i1] : i0 >= 0 and i0 < i1 <= 98 }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_privatization_deps_5.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; ;
; CHECK: RAW dependences: ; CHECK: RAW dependences:
; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 } ; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 }
; CHECK-NEXT: WAR dependences: ; CHECK-NEXT: WAR dependences:
; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 } ; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 }
; CHECK-NEXT: WAW dependences: ; CHECK-NEXT: WAW dependences:
; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 } ; CHECK-NEXT: { Stmt_S1[i0, 0] -> Stmt_S2[i0, 0] : 0 <= i0 <= 98; Stmt_S2[i0, 0] -> Stmt_S1[1 + i0, 0] : 0 <= i0 <= 97 }
; CHECK-NEXT: Reduction dependences: ; CHECK-NEXT: Reduction dependences:
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_sequence.ll

; RUN: opt %loadPolly -polly-dependences -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s
; void manyreductions(long *A) { ; void manyreductions(long *A) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; for (long j = 0; j < 1024; j++) ; for (long j = 0; j < 1024; j++)
; *A += 42; ; *A += 42;
; ;
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; for (long j = 0; j < 1024; j++) ; for (long j = 0; j < 1024; j++)
▲ Show 20 Lines • Show All 532 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_simple_iv.ll

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

polly/test/DependenceInfo/reduction_simple_iv_debug_wrapped_dependences.ll

; RUN: opt %loadPolly -polly-dependences -analyze -debug-only=polly-dependence 2>&1 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-dependences -debug-only=polly-dependence -disable-output < %s 2>&1 | FileCheck %s
; ;
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : 0 <= i0 <= 100 } ; CHECK: Read: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : 0 <= i0 <= 100 }
; CHECK-NEXT: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : 0 <= i0 <= 100 } ; CHECK-NEXT: Write: { [Stmt_for_cond[i0] -> MemRef_sum[0{{\]\]}} -> MemRef_sum[0] : 0 <= i0 <= 100 }
; CHECK-NEXT: MayWrite: { } ; CHECK-NEXT: MayWrite: { }
; ;
; CHECK: Wrapped Dependences: ; CHECK: Wrapped Dependences:
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

polly/test/DependenceInfo/reduction_simple_privatization_deps_2.ll

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

polly/test/DependenceInfo/reduction_simple_privatization_deps_w_parameter.ll

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

polly/test/DependenceInfo/reduction_two_reductions_different_rloops.ll

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

polly/test/DependenceInfo/sequential_loops.ll

; RUN: opt -S %loadPolly -basic-aa -polly-dependences -analyze -polly-dependences-analysis-type=value-based < %s | FileCheck %s -check-prefix=VALUE ; RUN: opt -S %loadPolly -basic-aa -polly-print-dependences -polly-dependences-analysis-type=value-based -disable-output < %s | FileCheck %s -check-prefix=VALUE
; RUN: opt -S %loadPolly -basic-aa -polly-dependences -analyze -polly-dependences-analysis-type=memory-based < %s | FileCheck %s -check-prefix=MEMORY ; RUN: opt -S %loadPolly -basic-aa -polly-print-dependences -polly-dependences-analysis-type=memory-based -disable-output < %s | FileCheck %s -check-prefix=MEMORY
; RUN: opt -S %loadPolly -basic-aa -polly-dependences -analyze -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise < %s | FileCheck %s -check-prefix=VALUE_ACCESS ; RUN: opt -S %loadPolly -basic-aa -polly-print-dependences -polly-dependences-analysis-type=value-based -polly-dependences-analysis-level=access-wise -disable-output < %s | FileCheck %s -check-prefix=VALUE_ACCESS
; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'sequential_writes': ; VALUE-LABEL: Printing analysis 'Polly - Calculate dependences' for region: 'S1 => exit.3' in function 'sequential_writes':
; VALUE-NEXT: RAW dependences: ; VALUE-NEXT: RAW dependences:
; VALUE-NEXT: { } ; VALUE-NEXT: { }
; VALUE-NEXT: WAR dependences: ; VALUE-NEXT: WAR dependences:
; VALUE-NEXT: { } ; VALUE-NEXT: { }
; VALUE-NEXT: WAW dependences: ; VALUE-NEXT: WAW dependences:
; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S3[i0] : 10 <= i0 <= 99; Stmt_S1[i0] -> Stmt_S2[i0] : 0 <= i0 <= 9; Stmt_S2[i0] -> Stmt_S3[i0] : 0 <= i0 <= 9 } ; VALUE-NEXT: { Stmt_S1[i0] -> Stmt_S3[i0] : 10 <= i0 <= 99; Stmt_S1[i0] -> Stmt_S2[i0] : 0 <= i0 <= 9; Stmt_S2[i0] -> Stmt_S3[i0] : 0 <= i0 <= 9 }
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

polly/test/FlattenSchedule/gemm.ll

; RUN: opt %loadPolly -polly-flatten-schedule -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-flatten-schedule -disable-output < %s | FileCheck %s
; ;
; dgemm kernel ; dgemm kernel
; C := alpha*A*B + beta*C ; C := alpha*A*B + beta*C
; C[ni][nj] ; C[ni][nj]
; A[ni][nk] ; A[ni][nk]
; B[nk][nj] ; B[nk][nj]
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/atax.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define internal fastcc void @kernel_atax([2100 x double]* nocapture readonly %A, double* nocapture readonly %x, double* nocapture %y, double* nocapture %tmp) unnamed_addr #0 { define internal fastcc void @kernel_atax([2100 x double]* nocapture readonly %A, double* nocapture readonly %x, double* nocapture %y, double* nocapture %tmp) unnamed_addr #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/changed-kind.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; In the code below, %0 is known to be equal to the content of @c (constant 0). ; In the code below, %0 is known to be equal to the content of @c (constant 0).
; Thus, in order to save a scalar dependency, forward-optree replaces ; Thus, in order to save a scalar dependency, forward-optree replaces
; the use of %0 in Stmt_lor_end93 by a load from @c by changing the ; the use of %0 in Stmt_lor_end93 by a load from @c by changing the
; access find from a scalar access to a array accesses. ; access find from a scalar access to a array accesses.
; llvm.org/PR48034 decribes a crash caused by the mid-processing change. ; llvm.org/PR48034 decribes a crash caused by the mid-processing change.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
Show All 38 Lines

polly/test/ForwardOpTree/forward_from_region.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move instructions from region statements. ; Move instructions from region statements.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = 21.0 + 21.0; ; double val = 21.0 + 21.0;
; if (cond) ; if (cond)
; ;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_hoisted.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify). ; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify).
; This involves making the load-hoisted %val1 to be made available in %bodyB. ; This involves making the load-hoisted %val1 to be made available in %bodyB.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[0] + 21.0; ; double val = B[0] + 21.0;
; ;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_instruction.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify) ; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = 21.0 + 21.0; ; double val = 21.0 + 21.0;
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_into_region.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move instructions to region statements. ; Move instructions to region statements.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = 21.0 + 21.0; ; double val = 21.0 + 21.0;
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_into_region_redundant_use.ll

; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
define void @foo(float* %A, i32 %p, float* %B) { define void @foo(float* %A, i32 %p, float* %B) {
start: start:
br label %branch br label %branch
branch: branch:
%cmp = icmp eq i32 %p, 1024 %cmp = icmp eq i32 %p, 1024
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_load.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-optree>)" -disable-output < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-optree>)" -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load. ; Rematerialize a load.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_load_differentarray.ll

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

polly/test/ForwardOpTree/forward_load_double_write.ll

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

polly/test/ForwardOpTree/forward_load_fromloop.ll

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

polly/test/ForwardOpTree/forward_load_indirect.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Forward an operand tree consisting of a speculatable instruction (%add) ; Forward an operand tree consisting of a speculatable instruction (%add)
; and a load (%val). ; and a load (%val).
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; double add = val + 42.0; ; double add = val + 42.0;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_load_memset_after.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load in the presence of a non-store WRITE access. ; Rematerialize a load in the presence of a non-store WRITE access.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_load_memset_before.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load in the presence of a non-store WRITE access. ; Rematerialize a load in the presence of a non-store WRITE access.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; memset(A, 0, 16); ; memset(A, 0, 16);
; memset(B, 0, 16); ; memset(B, 0, 16);
; ;
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_load_tripleuse.ll

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

polly/test/ForwardOpTree/forward_load_unrelatedunusual.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load. ; Rematerialize a load.
; The non-analyzable store to C[0] is unrelated and can be ignored. ; The non-analyzable store to C[0] is unrelated and can be ignored.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; C[0] = 21.0; ; C[0] = 21.0;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_phi_load.ll

; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load. ; Rematerialize a load.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_readonly.ll

; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines -check-prefixes=STATS,MODEL ; RUN: opt %loadPolly -polly-analyze-read-only-scalars=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines -check-prefixes=STATS,MODEL
; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -polly-optree -analyze < %s | FileCheck %s -match-full-lines -check-prefixes=STATS,NOMODEL ; RUN: opt %loadPolly -polly-analyze-read-only-scalars=false -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines -check-prefixes=STATS,NOMODEL
; ;
; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify) ; Move %val to %bodyB, so %bodyA can be removed (by -polly-simplify)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = arg + 21.0; ; double val = arg + 21.0;
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_reusue.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move operand tree without duplicating values used multiple times. ; Move operand tree without duplicating values used multiple times.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_store.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Rematerialize a load. ; Rematerialize a load.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_synthesizable_definloop.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Copy %val to bodyB, assuming the exit value of %i. ; Copy %val to bodyB, assuming the exit value of %i.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double val; ; double val;
; for (int i = 0; i < 128; i += 1) { ; for (int i = 0; i < 128; i += 1) {
; bodyA: ; bodyA:
; val = j; ; val = j;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_synthesizable_indvar.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Test support for (synthesizable) inducation variables. ; Test support for (synthesizable) inducation variables.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = j; ; double val = j;
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_synthesizable_useinloop.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Synthesizable values defined outside of a loop can be used ; Synthesizable values defined outside of a loop can be used
; inside the loop. ; inside the loop.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = j; ; double val = j;
; ;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/forward_transitive.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Move %v and %val to %bodyB, so %bodyA can be removed (by -polly-simplify) ; Move %v and %val to %bodyB, so %bodyA can be removed (by -polly-simplify)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val1 = 12.5 + 12.5; ; double val1 = 12.5 + 12.5;
; ;
; bodyB: ; bodyB:
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-optree-normalize-phi=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define internal fastcc void @kernel_jacobi_1d(double* noalias nocapture %A, double* noalias nocapture %B) unnamed_addr #0 { define internal fastcc void @kernel_jacobi_1d(double* noalias nocapture %A, double* noalias nocapture %B) unnamed_addr #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/noforward_from_region.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Ensure we do not move instructions from region statements in case the ; Ensure we do not move instructions from region statements in case the
; instruction to move loads from an array which is also written to from ; instruction to move loads from an array which is also written to from
; within the region. This is necessary as complex region statements may prevent ; within the region. This is necessary as complex region statements may prevent
; us from detecting possible memory conflicts. ; us from detecting possible memory conflicts.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/noforward_load_conditional.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; B[j] is overwritten by at least one statement between the ; B[j] is overwritten by at least one statement between the
; definition of %val and its use. Hence, it cannot be forwarded. ; definition of %val and its use. Hence, it cannot be forwarded.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; if (j < 1) { ; if (j < 1) {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/noforward_load_writebetween.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Cannot rematerialize %val from B[0] at bodyC because B[0] has been ; Cannot rematerialize %val from B[0] at bodyC because B[0] has been
; overwritten in bodyB. ; overwritten in bodyB.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/noforward_outofquota.ll

; RUN: opt %loadPolly -polly-optree-max-ops=1 -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-optree-max-ops=1 -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly -polly-optree-max-ops=1 -polly-optree -disable-output -stats < %s 2>&1 | FileCheck %s -match-full-lines -check-prefix=STATS ; RUN: opt %loadPolly -polly-optree-max-ops=1 -polly-optree -disable-output -stats < %s 2>&1 | FileCheck %s -match-full-lines -check-prefix=STATS
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = B[j]; ; double val = B[j];
; ;
; bodyB: ; bodyB:
Show All 39 Lines

polly/test/ForwardOpTree/noforward_partial.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Not the entire operand tree can be forwarded, ; Not the entire operand tree can be forwarded,
; some scalar dependencies would remain. ; some scalar dependencies would remain.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = f() + 21.0; ; double val = f() + 21.0;
; ;
Show All 39 Lines

polly/test/ForwardOpTree/noforward_phi.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Do not move PHI nodes. ; Do not move PHI nodes.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = 42.0; ; double val = 42.0;
; ;
; bodyB: ; bodyB:
Show All 33 Lines

polly/test/ForwardOpTree/noforward_selfrefphi.ll

; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-optree-normalize-phi=true -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Contains a self-referencing PHINode that would require a ; Contains a self-referencing PHINode that would require a
; transitive closure to handle. ; transitive closure to handle.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double phi = 0.0; ; double phi = 0.0;
; for (int i = 0; i < m; i += 1) ; for (int i = 0; i < m; i += 1)
; phi = phi; ; phi = phi;
Show All 40 Lines

polly/test/ForwardOpTree/noforward_sideffects.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Do not forward instructions with side-effects (here: function call). ; Do not forward instructions with side-effects (here: function call).
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = f(); ; double val = f();
; ;
; bodyB: ; bodyB:
Show All 37 Lines

polly/test/ForwardOpTree/noforward_synthesizable_unknownit.ll

; RUN: opt %loadPolly -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-optree -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Do not try to forward %i.trunc, it is not synthesizable in %body. ; Do not try to forward %i.trunc, it is not synthesizable in %body.
; ;
define void @func(i32 %n, i32* noalias nonnull %A) { define void @func(i32 %n, i32* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/ForwardOpTree/out-of-quota1.ll

; RUN: opt %loadPolly -polly-optree -analyze %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-optree -disable-output %s | FileCheck %s
; This used to loop infinitely because of UINT_MAX returned by ISL on out-of-quota. ; This used to loop infinitely because of UINT_MAX returned by ISL on out-of-quota.
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
%struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187 = type { i32, i32, i32, i32, i32, [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16**, i16***, i8*, i16**, i8***, i64***, i64***, i16****, i8**, i8**, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [2 x i32], i32, %struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186*, i32 } %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187 = type { i32, i32, i32, i32, i32, [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], [50 x [6 x [33 x i64]]], i32, i32, i32, i32, i32, i32, i32, i32, i32, i16, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16**, i16***, i8*, i16**, i8***, i64***, i64***, i16****, i8**, i8**, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, %struct.storable_picture.5.221.389.509.629.797.917.1133.1205.1445.1469.1517.1541.1565.1589.1661.1685.1757.1781.1829.1877.2165.2285.2405.2429.2453.2477.2501.2525.2837.2861.2885.2909.4417.1.7.13.17.23.29.55.57.59.61.187*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [2 x i32], i32, %struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186*, i32 }
%struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186 = type { i32, i32, i32, i32, i32, %struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186* } %struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186 = type { i32, i32, i32, i32, i32, %struct.DecRefPicMarking_s.4.220.388.508.628.796.916.1132.1204.1444.1468.1516.1540.1564.1588.1660.1684.1756.1780.1828.1876.2164.2284.2404.2428.2452.2476.2500.2524.2836.2860.2884.2908.4416.0.6.12.16.22.28.54.56.58.60.186* }
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/test/GPGPU/add-scalars-in-scop-to-kills.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we detect a scop. ; Check that we detect a scop.
; SCOP: Function: checkScalarKill ; SCOP: Function: checkScalarKill
; SCOP-NEXT: Region: %XLoopInit---%for.end ; SCOP-NEXT: Region: %XLoopInit---%for.end
; SCOP-NEXT: Max Loop Depth: 1 ; SCOP-NEXT: Max Loop Depth: 1
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/GPGPU/double-parallel-loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-outout < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-schedule \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-schedule \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=SCHED %s ; RUN: FileCheck -check-prefix=SCHED %s
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
; RUN: -disable-output < %s | \ ; RUN: -disable-output < %s | \
; RUN: FileCheck -check-prefix=CODE %s ; RUN: FileCheck -check-prefix=CODE %s
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

polly/test/GPGPU/failing-invariant-load-handling.ll

; RUN: opt %loadPolly < %s -analyze -polly-scops -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=SCOPS ; RUN: opt %loadPolly -polly-process-unprofitable -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOPS
; RUN: opt %loadPolly -S < %s -polly-codegen-ppcg -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -S < %s -polly-codegen-ppcg -polly-process-unprofitable -polly-invariant-load-hoisting | FileCheck %s -check-prefix=CODEGEN
; REQUIRES: pollyacc ; REQUIRES: pollyacc
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
%S = type { i32, i32, [12 x %L] } %S = type { i32, i32, [12 x %L] }
%L = type { i32, i32, double, i32, i32, i32, i32, i32 } %L = type { i32, i32, double, i32, i32, i32, i32, i32 }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/GPGPU/intrinsic-copied-into-kernel.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -analyze -polly-codegen-ppcg -polly-acc-dump-kernel-ir < %s | FileCheck %s --check-prefix=KERNEL-IR ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir -disable-output < %s | FileCheck %s --check-prefix=KERNEL-IR
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s --check-prefix=HOST-IR
; Test that we do recognise and codegen a kernel that has intrinsics. ; Test that we do recognise and codegen a kernel that has intrinsics.
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we model the kernel as a scop. ; Check that we model the kernel as a scop.
; SCOP: Function: f ; SCOP: Function: f
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-array-access.ll

; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-invariant-load-hoisting < %s| FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we detect a scop. ; Check that we detect a scop.
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting-of-array.ll

; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Entry: Contains (%loaded.ptr.preload.s2a = alloca double*) which is ; Entry: Contains (%loaded.ptr.preload.s2a = alloca double*) which is
; | invariant load hoisted `%loaded.ptr` ; | invariant load hoisted `%loaded.ptr`
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting-with-variable-bounds.ll

; RUN: opt %loadPolly -analyze -polly-use-llvm-names -polly-scops \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; SCOP: Function: f ; SCOP: Function: f
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting-with-variable-lower-bound.ll

; RUN: opt %loadPolly -analyze -polly-use-llvm-names -polly-scops \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we detect a scop with invariant accesses. ; Check that we detect a scop with invariant accesses.
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting-with-variable-upper-bound.ll

; RUN: opt %loadPolly -analyze -polly-use-llvm-names -polly-scops -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Check that we detect a scop with invariant accesses. ; Check that we detect a scop with invariant accesses.
; SCOP: Function: f ; SCOP: Function: f
; SCOP-NEXT: Region: %entry.split---%for.end ; SCOP-NEXT: Region: %entry.split---%for.end
; SCOP-NEXT: Max Loop Depth: 1 ; SCOP-NEXT: Max Loop Depth: 1
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-hoisting.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP
; ;
; RUN: opt %loadPolly -polly-scops -S -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-scops -S -polly-invariant-load-hoisting \
; RUN: -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR
; ;
; RUN: opt %loadPolly -polly-scops -analyze -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-codegen-ppcg -polly-acc-dump-kernel-ir -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=KERNEL-IR
; RUN: -polly-codegen-ppcg -polly-acc-dump-kernel-ir < %s | FileCheck %s -check-prefix=KERNEL-IR
; ;
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; ;
; SCOP: Function: f ; SCOP: Function: f
; SCOP-NEXT: Region: %entry.split---%for.end26 ; SCOP-NEXT: Region: %entry.split---%for.end26
; SCOP-NEXT: Max Loop Depth: 3 ; SCOP-NEXT: Max Loop Depth: 3
; SCOP-NEXT: Invariant Accesses: { ; SCOP-NEXT: Invariant Accesses: {
; SCOP-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; SCOP-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

polly/test/GPGPU/invariant-load-of-scalar.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck -check-prefix=SCOP %s
; RUN: -analyze < %s | \
; RUN: FileCheck -check-prefix=SCOP %s
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-invariant-load-hoisting \
; RUN: -S < %s | \ ; RUN: -S < %s | \
; RUN: FileCheck -check-prefix=HOST-IR %s ; RUN: FileCheck -check-prefix=HOST-IR %s
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-invariant-load-hoisting \
; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \ ; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/test/GPGPU/libdevice-functions-copied-into-kernel.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s \ ; RUN: opt %loadPolly -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll -disable-output < %s | FileCheck %s --check-prefix=KERNEL-IR
; RUN: | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -analyze -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
; RUN: -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll \
; RUN: < %s | FileCheck %s --check-prefix=KERNEL-IR
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s \ ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s \
; RUN: -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll \ ; RUN: -polly-acc-libdevice=%S/Inputs/libdevice-functions-copied-into-kernel_libdevice.ll \
; RUN: | FileCheck %s --check-prefix=HOST-IR ; RUN: | FileCheck %s --check-prefix=HOST-IR
; Test that we do recognise and codegen a kernel that has functions that can ; Test that we do recognise and codegen a kernel that has functions that can
; be mapped to NVIDIA's libdevice ; be mapped to NVIDIA's libdevice
; REQUIRES: pollyacc ; REQUIRES: pollyacc
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

polly/test/GPGPU/loops-outside-scop.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; There is no FileCheck because we want to make sure that this doesn't crash. ; There is no FileCheck because we want to make sure that this doesn't crash.
; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-fail-on-verify-module-failure \ ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-fail-on-verify-module-failure \
; RUN: -disable-output < %s ; RUN: -disable-output < %s
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; Due to the existence of the `fence` call, We can only detect the inner loop ; Due to the existence of the `fence` call, We can only detect the inner loop
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/GPGPU/managed-memory-rewrite-alloca.ll

; RUN: opt %loadPolly -analyze -polly-process-unprofitable \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: -polly-scops -polly-use-llvm-names < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 \ ; RUN: opt %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 \
; RUN: -polly-target=gpu -polly-codegen-ppcg -polly-acc-codegen-managed-memory \ ; RUN: -polly-target=gpu -polly-codegen-ppcg -polly-acc-codegen-managed-memory \
; RUN: -polly-acc-rewrite-managed-memory -polly-acc-rewrite-allocas < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: -polly-acc-rewrite-managed-memory -polly-acc-rewrite-allocas < %s | FileCheck %s --check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; SCOP: Function: f ; SCOP: Function: f
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/test/GPGPU/managed-memory-rewrite-malloc-free-inside-constexpr.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: -analyze < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt %loadPolly -polly-codegen-ppcg \
; RUN: -S -polly-acc-codegen-managed-memory \ ; RUN: -S -polly-acc-codegen-managed-memory \
; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR
; ;
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; ;
; Check that we can correctly rewrite `malloc` to `polly_mallocManaged`, and ; Check that we can correctly rewrite `malloc` to `polly_mallocManaged`, and
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/test/GPGPU/managed-memory-rewrite-malloc-free.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: -analyze < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -polly-codegen-ppcg \ ; RUN: opt %loadPolly -polly-codegen-ppcg \
; RUN: -S -polly-acc-codegen-managed-memory \ ; RUN: -S -polly-acc-codegen-managed-memory \
; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR
; ;
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; ;
; Check that we can correctly rewrite `malloc` to `polly_mallocManaged`, and ; Check that we can correctly rewrite `malloc` to `polly_mallocManaged`, and
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/test/GPGPU/privatization-simple.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; SCOP: Function: f ; SCOP: Function: f
; SCOP-NEXT: Region: %for.body---%for.end ; SCOP-NEXT: Region: %for.body---%for.end
; SCOP-NEXT: Max Loop Depth: 1 ; SCOP-NEXT: Max Loop Depth: 1
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/GPGPU/privatization.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s -check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s -check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; SCOP: Function: checkPrivatization ; SCOP: Function: checkPrivatization
; SCOP-NEXT: Region: %for.body---%for.end ; SCOP-NEXT: Region: %for.body---%for.end
; SCOP-NEXT: Max Loop Depth: 1 ; SCOP-NEXT: Max Loop Depth: 1
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/GPGPU/scalar-writes-in-scop-requires-abort.ll

; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-scops \ ; RUN: opt %loadPolly -polly-acc-dump-code -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCOP
; RUN: -polly-acc-dump-code -analyze \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \
; RUN: -polly-acc-dump-code -polly-stmt-granularity=bb \ ; RUN: -polly-acc-dump-code -polly-stmt-granularity=bb \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=CODE ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s -check-prefix=CODE
; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \ ; RUN: opt %loadPolly -S -polly-use-llvm-names -polly-codegen-ppcg \
; RUN: -polly-invariant-load-hoisting -polly-stmt-granularity=bb < %s \ ; RUN: -polly-invariant-load-hoisting -polly-stmt-granularity=bb < %s \
; RUN: | FileCheck %s -check-prefix=HOST-IR ; RUN: | FileCheck %s -check-prefix=HOST-IR
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/GPGPU/simple-managed-memory-rewrite.ll

; RUN: opt %loadPolly -analyze -polly-process-unprofitable \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: -polly-scops -polly-use-llvm-names < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 \ ; RUN: opt %loadPolly -S -polly-process-unprofitable -polly-acc-mincompute=0 \
; RUN: -polly-target=gpu -polly-codegen-ppcg -polly-acc-codegen-managed-memory \ ; RUN: -polly-target=gpu -polly-codegen-ppcg -polly-acc-codegen-managed-memory \
; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR ; RUN: -polly-acc-rewrite-managed-memory < %s | FileCheck %s --check-prefix=HOST-IR
; REQUIRES: pollyacc ; REQUIRES: pollyacc
; SCOP: Function: f ; SCOP: Function: f
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/GPGPU/unknown-fn-call-not-copied-into-kernel.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s ; RUN: opt %loadPolly -S -polly-codegen-ppcg < %s | FileCheck %s
; Check that we do not create a kernel if there is an ; Check that we do not create a kernel if there is an
; unknown function call in a candidate kernel. ; unknown function call in a candidate kernel.
; Check that we model the kernel as a scop. ; Check that we model the kernel as a scop.
; SCOP: Function: f ; SCOP: Function: f
; SCOP-NEXT: Region: %entry.split---%for.end13 ; SCOP-NEXT: Region: %entry.split---%for.end13
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

polly/test/IstAstInfo/OpenMP/multiple_loops_outer_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -polly-parallel-force -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; void jd(int *A) { ; void jd(int *A) {
; CHECK: #pragma omp parallel for ; CHECK: #pragma omp parallel for
; PINFO: for.cond2: Loop is parallel. ; PINFO: for.cond2: Loop is parallel.
; 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
; PINFO: for.cond: Loop is parallel. ; PINFO: for.cond: Loop is parallel.
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/IstAstInfo/OpenMP/nested_loop_both_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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
define void @bar() { define void @bar() {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/IstAstInfo/OpenMP/nested_loop_both_parallel_parametric.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -polly-parallel-force -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32: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"
; 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;
; } ; }
@A = common global [1024 x [1024 x i32]] zeroinitializer @A = common global [1024 x [1024 x i32]] zeroinitializer
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/IstAstInfo/OpenMP/nested_loop_inner_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -polly-parallel-force -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output< %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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
define void @bar(i64 %n) { define void @bar(i64 %n) {
Show All 40 Lines

polly/test/IstAstInfo/OpenMP/nested_loop_outer_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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
define void @bar(i64 %n) { define void @bar(i64 %n) {
Show All 39 Lines

polly/test/IstAstInfo/OpenMP/single_loop_param_non_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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) {
start: start:
Show All 25 Lines

polly/test/IstAstInfo/OpenMP/single_loop_param_parallel.ll

; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-parallel-force -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-parallel -polly-parallel-force -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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) {
start: start:
Show All 27 Lines

polly/test/IstAstInfo/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-print-ast -polly-parallel -polly-dependences-computeout=1 -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; for (i = 0; i < 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) {
start: start:
Show All 27 Lines

polly/test/IstAstInfo/alias_checks_with_empty_context.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s \ ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@global = external local_unnamed_addr global i32, align 4 @global = external local_unnamed_addr global i32, align 4
@global.1 = external local_unnamed_addr global i32, align 4 @global.1 = external local_unnamed_addr global i32, align 4
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/IstAstInfo/alias_simple_1.ll

; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -disable-output < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -tbaa -disable-output < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -scev-aa -disable-output < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -globals-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -globals-aa -disable-output < %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/test/IstAstInfo/alias_simple_2.ll

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

polly/test/IstAstInfo/alias_simple_3.ll

; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -disable-output < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=BASI ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=BASI
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -tbaa -disable-output < %s | FileCheck %s --check-prefix=TBAA
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -scev-aa < %s | FileCheck %s --check-prefix=SCEV ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -scev-aa -disable-output < %s | FileCheck %s --check-prefix=SCEV
; RUN: opt %loadPolly -polly-ast -analyze -disable-basic-aa -globals-aa < %s | FileCheck %s --check-prefix=GLOB ; RUN: opt %loadPolly -polly-print-ast -disable-basic-aa -globals-aa -disable-output < %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/test/IstAstInfo/aliasing_arrays_with_identical_base.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s \ ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: if (1 && 1 && (&MemRef_X[1] <= &MemRef_BaseA[0] || &MemRef_BaseA[1024] <= &MemRef_X[0]) && (&MemRef_X[1] <= &MemRef_BaseB[0] || &MemRef_BaseB[1024] <= &MemRef_X[0])) ; CHECK: if (1 && 1 && (&MemRef_X[1] <= &MemRef_BaseA[0] || &MemRef_BaseA[1024] <= &MemRef_X[0]) && (&MemRef_X[1] <= &MemRef_BaseB[0] || &MemRef_BaseB[1024] <= &MemRef_X[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 24 Lines

polly/test/IstAstInfo/aliasing_multiple_alias_groups.ll

; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-ast -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-print-ast -tbaa -disable-output < %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/test/IstAstInfo/aliasing_parametric_simple_1.ll

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

polly/test/IstAstInfo/aliasing_parametric_simple_2.ll

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

polly/test/IstAstInfo/dependence_distance_constant.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; 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
; PINFO-NEXT: for.cond1: Loop is not parallel. ; PINFO-NEXT: for.cond1: Loop is not parallel.
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/IstAstInfo/dependence_distance_minimal.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; ;
; The minimal dependence distance of the innermost loop should be 1 instead of 250. ; The minimal dependence distance of the innermost loop should be 1 instead of 250.
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; CHECK: for (int c0 = 0; c0 <= 499; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 499; c0 += 1)
; CHECK: #pragma minimal dependence distance: 1 ; CHECK: #pragma minimal dependence distance: 1
; CHECK: for (int c1 = 0; c1 <= 998; c1 += 1) { ; CHECK: for (int c1 = 0; c1 <= 998; c1 += 1) {
; CHECK: Stmt_bb9(c0, c1); ; CHECK: Stmt_bb9(c0, c1);
; CHECK: Stmt_bb9_b(c0, c1); ; CHECK: Stmt_bb9_b(c0, c1);
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/IstAstInfo/dependence_distance_multiple_constant.ll

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

polly/test/IstAstInfo/dependence_distance_parametric.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; 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
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; CHECK: #pragma minimal dependence distance: max(-c, c) ; CHECK: #pragma minimal dependence distance: max(-c, c)
; PINFO-NEXT: for.cond1: Loop is not parallel. ; PINFO-NEXT: for.cond1: Loop is not parallel.
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/IstAstInfo/dependence_distance_parametric_expr.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; 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
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; CHECK: #pragma minimal dependence distance: max(-c - v, c + v) ; CHECK: #pragma minimal dependence distance: max(-c - v, c + v)
; PINFO-NEXT: for.cond1: Loop is not parallel. ; PINFO-NEXT: for.cond1: Loop is not parallel.
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/IstAstInfo/dependence_distance_varying.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; CHECK: #pragma minimal dependence distance: -(N % 2) + 2 ; CHECK: #pragma minimal dependence distance: -(N % 2) + 2
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i] = A[N - i] + 1; ; A[i] = A[N - i] + 1;
; } ; }
; ;
Show All 27 Lines

polly/test/IstAstInfo/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-canonicalize -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; 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
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; 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
; PINFO-NEXT: for.cond1: Loop is not parallel. ; PINFO-NEXT: for.cond1: Loop is not parallel.
; for (int i = j; i < 1024; i++) ; for (int i = j; i < 1024; i++)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/IstAstInfo/dependence_distance_varying_multiple.ll

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

polly/test/IstAstInfo/domain_bounded_only_with_context.ll

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

polly/test/IstAstInfo/non_affine_access.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-print-accesses -analyze \ ; RUN: opt %loadPolly -polly-print-ast -polly-ast-print-accesses -polly-allow-nonaffine -disable-output < %s | FileCheck %s
; RUN: -polly-allow-nonaffine < %s \
; RUN: | FileCheck %s
; ;
; void non_affine_access(float A[]) { ; void non_affine_access(float A[]) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; A[i * i] = 1; ; A[i * i] = 1;
; } ; }
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
; CHECK: Stmt_bb3( ; CHECK: Stmt_bb3(
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_clauses_multidimensional_access.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; CHECK: #pragma known-parallel reduction (^ : MemRef_sum) ; CHECK: #pragma known-parallel reduction (^ : MemRef_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]) {
; PINFO: for.cond: Loop is not parallel. ; PINFO: for.cond: Loop is not parallel.
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; PINFO-NEXT: for.cond1: Loop is parallel. ; PINFO-NEXT: for.cond1: Loop is parallel.
; for (int j = 0; j < P; j++) ; for (int j = 0; j < P; j++)
; CHECK: #pragma simd ; CHECK: #pragma simd
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_clauses_onedimensional_access.ll

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

polly/test/IstAstInfo/reduction_dependences_equal_non_reduction_dependences.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_different_reduction_clauses.ll

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

polly/test/IstAstInfo/reduction_in_one_dimension.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; 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
; PINFO: for.cond: Loop is parallel. ; PINFO: for.cond: Loop is 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
; PINFO-NEXT: for.cond1: Loop is not parallel. ; PINFO-NEXT: for.cond1: Loop is not parallel.
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_loop_reversal.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; 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)
; ;
; PINFO: for.cond2: Loop is parallel. ; PINFO: for.cond2: Loop is parallel.
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_modulo_and_loop_reversal_schedule.ll

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

polly/test/IstAstInfo/reduction_modulo_and_loop_reversal_schedule_2.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_modulo_schedule.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polyhedral-info -polly-check-parallel -analyze < %s | FileCheck %s -check-prefix=PINFO ; RUN: opt %loadPolly -print-polyhedral-info -polly-check-parallel -disable-output < %s | FileCheck %s -check-prefix=PINFO
; ;
; CHECK: #pragma known-parallel reduction (+ : MemRef_A) ; CHECK: #pragma known-parallel reduction (+ : MemRef_A)
; CHECK-NEXT: for (int c0 = 0; c0 <= 2; c0 += 1) { ; CHECK-NEXT: for (int c0 = 0; c0 <= 2; c0 += 1) {
; CHECK-NEXT: if (c0 == 1) { ; CHECK-NEXT: if (c0 == 1) {
; CHECK-NEXT: #pragma simd ; CHECK-NEXT: #pragma simd
; CHECK-NEXT: for (int c1 = 0; c1 < 2 * n; c1 += 1) ; CHECK-NEXT: for (int c1 = 0; c1 < 2 * n; c1 += 1)
; CHECK-NEXT: Stmt_S1(c1); ; CHECK-NEXT: Stmt_S1(c1);
; CHECK-NEXT: } else ; CHECK-NEXT: } else
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_modulo_schedule_multiple_dimensions.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_modulo_schedule_multiple_dimensions_2.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_modulo_schedule_multiple_dimensions_3.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_modulo_schedule_multiple_dimensions_4.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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 = -1023; c3 <= 1023; c3 += 1) { ; CHECK: for (int c3 = -1023; c3 <= 1023; c3 += 1) {
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_modulo_schedule_multiple_dimensions_5.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-print-ast -polly-ast-detect-parallel -disable-output < %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 + 1) % 2 == 0) { ; CHECK: if ((c1 + 1) % 2 == 0) {
; CHECK-NOT: #pragma simd reduction ; CHECK-NOT: #pragma simd reduction
; CHECK: #pragma simd ; CHECK: #pragma simd
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/test/IstAstInfo/reduction_multiple_dimensions.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_multiple_dimensions_2.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_multiple_dimensions_3.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/reduction_multiple_dimensions_4.ll

; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -polly-ast-detect-parallel -disable-output < %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/test/IstAstInfo/run-time-condition.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %s | FileCheck %s
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i] = B[i]; ; A[i] = B[i];
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define void @run-time-condition(i16* noalias %A, i16* noalias %B) { define void @run-time-condition(i16* noalias %A, i16* noalias %B) {
entry: entry:
Show All 26 Lines

polly/test/IstAstInfo/runtime_context_with_error_blocks.ll

; RUN: opt %loadPolly -polly-ast -analyze \ ; RUN: opt %loadPolly -polly-print-ast -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; Verify we do not simplify the runtime check to "true" due to the domain ; Verify we do not simplify the runtime check to "true" due to the domain
; constraints as the test contains an error block that influenced the domains ; constraints as the test contains an error block that influenced the domains
; already. ; already.
; ;
; CHECK: if (p_0_loaded_from_this <= -1 || p_0_loaded_from_this >= 1) ; CHECK: if (p_0_loaded_from_this <= -1 || p_0_loaded_from_this >= 1)
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/IstAstInfo/simple-run-time-condition.ll

; RUN: opt %loadPolly -polly-ast -analyze -polly-precise-inbounds < %s \ ; RUN: opt %loadPolly -polly-print-ast -polly-precise-inbounds -polly-precise-fold-accesses -disable-output < %s | FileCheck %s
; RUN: -polly-precise-fold-accesses \
; RUN: | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, int o, double A[n][m], long p, long q) { ; void foo(long n, long m, int o, double A[n][m], long p, long q) {
; ;
; 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 85 Lines • Show Last 20 Lines

polly/test/IstAstInfo/single_loop_strip_mine.ll

; RUN: opt %loadPolly -basic-aa -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-import-jscop \ ; RUN: opt %loadPolly -basic-aa -polly-import-jscop -polly-ast-print-accesses -polly-ast-detect-parallel -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=CHECK-VECTOR
; RUN: -polly-ast-print-accesses \
; RUN: -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s \
; RUN: -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"
define void @single_loop_strip_mine(i16* noalias %A, i16* noalias %B) { define void @single_loop_strip_mine(i16* noalias %A, i16* noalias %B) {
entry: entry:
Show All 32 Lines

polly/test/IstAstInfo/single_loop_uint_max_iterations.ll

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 62 Lines • Show Last 20 Lines

polly/test/IstAstInfo/single_loop_ull_max_iterations.ll

; RUN: opt %loadPolly -polly-ast -S -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-ast -disable-output < %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 62 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Bad-relation.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: expecting other token ; CHECK: expecting other token
; ;
; Verify that the JSONImporter checks if the relation is valid. ; Verify that the JSONImporter checks if the relation is valid.
; ;
; void ia6(int *A, long n) { ; void ia6(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-No-accesses-key.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: Statement from JScop file has no key name 'accesses' for index 1. ; CHECK: Statement from JScop file has no key name 'accesses' for index 1.
; ;
; Verify that the JSONImporter checks if there is a key name "accesses" for each statement. ; Verify that the JSONImporter checks if there is a key name "accesses" for each statement.
; ;
; void ia3(int *A, long n) { ; void ia3(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Not-enough-MemAcc.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: The number of memory accesses in the JSop file and the number of memory accesses differ for index 0. ; CHECK: The number of memory accesses in the JSop file and the number of memory accesses differ for index 0.
; ;
; Verify that the JSONImporter checks if there is the correct number of memory accesses. ; Verify that the JSONImporter checks if there is the correct number of memory accesses.
; ;
; void ia4(int *A, long n) { ; void ia4(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Not-enough-statements.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: The number of indices and the number of statements differ. ; CHECK: The number of indices and the number of statements differ.
; ;
; Verify that the JSONImporter checks if the number of indices and the number of statements differ. ; Verify that the JSONImporter checks if the number of indices and the number of statements differ.
; ;
; void ia2(int *A, long n) { ; void ia2(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Relation-mispelled.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: Memory access number 0 has no key name 'relation' for statement number 1. ; CHECK: Memory access number 0 has no key name 'relation' for statement number 1.
; ;
; Verify that the JSONImporter checks if there is a key name 'relation' for each MemAcc. ; Verify that the JSONImporter checks if there is a key name 'relation' for each MemAcc.
; ;
; void ia5(int *A, long n) { ; void ia5(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Statements-mispelled.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: JScop file has no key name 'statements'. ; CHECK: JScop file has no key name 'statements'.
; ;
; Verify that the JSONImporter checks if there is a key name 'statements'. ; Verify that the JSONImporter checks if there is a key name 'statements'.
; ;
; void ia(int *A, long n) { ; void ia(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Undeclared-ScopArrayInfo.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: JScop file contains access function with undeclared ScopArrayInfo ; CHECK: JScop file contains access function with undeclared ScopArrayInfo
; ;
; Verify that the JSONImporter checks if the access function have a declared ScopArrayInfo. ; Verify that the JSONImporter checks if the access function have a declared ScopArrayInfo.
; ;
; void ia8(int *A, long n) { ; void ia8(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportAccesses/ImportAccesses-Wrong-number-dimensions.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: JScop file changes the number of parameter dimensions. ; CHECK: JScop file changes the number of parameter dimensions.
; ;
; Verify that the JSONImporter checks if there is the right parameter dimensions. ; Verify that the JSONImporter checks if there is the right parameter dimensions.
; ;
; void ia7(int *A, long n) { ; void ia7(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportArrays/ImportArrays-Mispelled-type.ll

; RUN: not --crash opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Array has not a valid type. ; CHECK: Array has not a valid type.
; ;
; Verify if the JSONImporter checks if the parsed type is valid. ; Verify if the JSONImporter checks if the parsed type is valid.
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

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

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

polly/test/JSONExporter/ImportArrays/ImportArrays-No-name.ll

; RUN: not --crash opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Array has no key 'name'. ; CHECK: Array has no key 'name'.
; ;
; Verify if the JSONImporter checks if the arrays have a key name 'name'. ; Verify if the JSONImporter checks if the arrays have a key name 'name'.
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportArrays/ImportArrays-No-sizes-key.ll

; RUN: not --crash opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Array has no key 'sizes'. ; CHECK: Array has no key 'sizes'.
; ;
; Verify if the JSONImporter checks if the arrays have a key name 'sizes'. ; Verify if the JSONImporter checks if the arrays have a key name 'sizes'.
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportArrays/ImportArrays-No-type-key.ll

; RUN: not --crash opt %loadPolly -polly-scops -analyze -polly-import-jscop -polly-import-jscop-postfix=transformed < %s 2>&1 | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Array has no key 'type'. ; CHECK: Array has no key 'type'.
; ;
; Verify if the JSONImporter checks if the arrays have a key name 'type'. ; Verify if the JSONImporter checks if the arrays have a key name 'type'.
; ;
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportContext/ImportContext-Context-mispelled.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: JScop file has no key named 'context'. ; CHECK: JScop file has no key named 'context'.
; ;
; Verify if the JSONImporter check if there is a key name 'context'. ; Verify if the JSONImporter check if there is a key name 'context'.
; ;
; void ic(int *A, long n) { ; void ic(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportContext/ImportContext-Not-parameter-set.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: The isl_set is not a parameter set. ; CHECK: The isl_set is not a parameter set.
; ;
; Verify if the JSONImporter check if the imported set is a parameter one. ; Verify if the JSONImporter check if the imported set is a parameter one.
; ;
; void ic3(int *A, long n) { ; void ic3(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportContext/ImportContext-Unvalid-Context.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: unexpected isl_token ; CHECK: unexpected isl_token
; ;
; Verify if the JSONImporter check if the context is parsed successfully. ; Verify if the JSONImporter check if the context is parsed successfully.
; ;
; void ic2(int *A, long n) { ; void ic2(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportContext/ImportContext-Wrong-dimension.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: Imported context has the wrong number of parameters : Found 2 Expected 1 ; CHECK: Imported context has the wrong number of parameters : Found 2 Expected 1
; ;
; Verify if the JSONImporter check if there is the right number of parameters. ; Verify if the JSONImporter check if there is the right number of parameters.
; ;
; void ic4(int *A, long n) { ; void ic4(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportSchedule/ImportSchedule-No-schedule-key.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: Statement 0 has no 'schedule' key. ; CHECK: Statement 0 has no 'schedule' key.
; ;
; Verify if the JSONImporter check if there is a key name 'schedule'. ; Verify if the JSONImporter check if there is a key name 'schedule'.
; ;
; void is3(int *A, long n) { ; void is3(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportSchedule/ImportSchedule-Schedule-not-valid.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: expecting other token ; CHECK: expecting other token
; ;
; Verify if the JSONImporter check if the parsed schedule is valid. ; Verify if the JSONImporter check if the parsed schedule is valid.
; ;
; void is4(int *A, long n) { ; void is4(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportSchedule/ImportSchedule-Statements-mispelled.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: JScop file has no key name 'statements'. ; CHECK: JScop file has no key name 'statements'.
; ;
; Verify if the JSONImporter check if there is a key name 'statements'. ; Verify if the JSONImporter check if there is a key name 'statements'.
; ;
; void is(int *A, long n) { ; void is(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/JSONExporter/ImportSchedule/ImportSchedule-Wrong-number-statements.ll

; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel < %s 2>&1 >/dev/null | FileCheck %s ; RUN: not --crash opt %loadPolly -polly-import-jscop -polly-ast -polly-ast-detect-parallel -disable-output < %s 2>&1 >/dev/null | FileCheck %s
; ;
; CHECK: The number of indices and the number of statements differ. ; CHECK: The number of indices and the number of statements differ.
; ;
; Verify if the JSONImporter check if there is the right number of statements. ; Verify if the JSONImporter check if there is the right number of statements.
; ;
; void is2(int *A, long n) { ; void is2(int *A, long n) {
; for (long i = 0; i < 2 * n; i++) ; for (long i = 0; i < 2 * n; i++)
; S0: A[0] += i; ; S0: A[0] += i;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/load_after_store_same_statement.ll

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

polly/test/MaximalStaticExpansion/read_from_original.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1| FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-mse -polly-print-scops -pass-remarks-analysis="polly-mse" -disable-output < %s 2>&1| FileCheck %s --check-prefix=MSE
; ;
; Verify that Polly detects problems and does not expand the array ; Verify that Polly detects problems and does not expand the array
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/too_many_writes.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1 | FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-mse -polly-print-scops -pass-remarks-analysis="polly-mse" -disable-output < %s 2>&1 | FileCheck %s --check-prefix=MSE
; ;
; Verify that Polly detects problems and does not expand the array ; Verify that Polly detects problems and does not expand the array
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 2000 ; #define Nj 2000
; ;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/working_deps_between_inners.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify that the accesses are correctly expanded for MemoryKind::Array ; Verify that the accesses are correctly expanded for MemoryKind::Array
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/working_deps_between_inners_phi.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1| FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-mse -polly-print-scops -pass-remarks-analysis="polly-mse" -disable-output < %s 2>&1 | FileCheck %s --check-prefix=MSE
; ;
; Verify that the accesses are correctly expanded for MemoryKind::Array and MemoryKind::PHI. ; Verify that the accesses are correctly expanded for MemoryKind::Array and MemoryKind::PHI.
; tmp_06_phi is not expanded because it need copy in. ; tmp_06_phi is not expanded because it need copy in.
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/working_expansion.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify that the accesses are correctly expanded for MemoryKind::Array ; Verify that the accesses are correctly expanded for MemoryKind::Array
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 2000 ; #define Ni 2000
; #define Nj 3000 ; #define Nj 3000
; ;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/working_expansion_multiple_dependences_per_statement.ll

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

polly/test/MaximalStaticExpansion/working_expansion_multiple_instruction_per_statement.ll

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

polly/test/MaximalStaticExpansion/working_phi_expansion.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-mse -pass-remarks-analysis="polly-mse" -analyze < %s 2>&1 | FileCheck %s --check-prefix=MSE ; RUN: opt %loadPolly -polly-mse -polly-print-scops -pass-remarks-analysis="polly-mse" -disable-output < %s 2>&1 | FileCheck %s --check-prefix=MSE
; ;
; Verify that the accesses are correctly expanded for MemoryKind::PHI ; Verify that the accesses are correctly expanded for MemoryKind::PHI
; tmp_04 is not expanded because it need copy-in. ; tmp_04 is not expanded because it need copy-in.
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 10000 ; #define Ni 10000
; #define Nj 10000 ; #define Nj 10000
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/test/MaximalStaticExpansion/working_phi_two_scalars.ll

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

polly/test/MaximalStaticExpansion/working_value_expansion.ll

; RUN: opt %loadPolly -polly-mse -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-mse -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify that the accesses are correctly expanded for MemoryKind::Value ; Verify that the accesses are correctly expanded for MemoryKind::Value
; ;
; Original source code : ; Original source code :
; ;
; #define Ni 10000 ; #define Ni 10000
; #define Nj 10000 ; #define Nj 10000
; ;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basic-aa -polly-opt-isl -polly-vectorizer=polly < %s ; RUN: opt %loadPolly -basic-aa -polly-opt-isl -polly-vectorizer=polly -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-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"
%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
@stdout = external global %struct._IO_FILE* @stdout = external global %struct._IO_FILE*
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-double.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
define void @func(i32 %n, [1024 x double]* noalias nonnull %A, [1024 x double]* noalias nonnull %B) { define void @func(i32 %n, [1024 x double]* noalias nonnull %A, [1024 x double]* noalias nonnull %B) {
entry: entry:
br label %outer.for1 br label %outer.for1
outer.for1: outer.for1:
%k1 = phi i32 [0, %entry], [%k1.inc, %outer.inc1] %k1 = phi i32 [0, %entry], [%k1.inc, %outer.inc1]
%k1.cmp = icmp slt i32 %k1, %n %k1.cmp = icmp slt i32 %k1, %n
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-except-first.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,RAW ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,RAW
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,OPT ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,OPT
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) {
entry: entry:
br label %for1 br label %for1
for1: for1:
%j1 = phi i32 [0, %entry], [%j1.inc, %inc1] %j1 = phi i32 [0, %entry], [%j1.inc, %inc1]
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-except-third.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,RAW ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,RAW
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) {
entry: entry:
br label %for1 br label %for1
for1: for1:
%j1 = phi i32 [0, %entry], [%j1.inc, %inc1] %j1 = phi i32 [0, %entry], [%j1.inc, %inc1]
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner-carried.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,RAW ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,RAW
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,OPT ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,OPT
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %outer.for br label %outer.for
outer.for: outer.for:
%k = phi i32 [0, %entry], [%k.inc, %outer.inc] %k = phi i32 [0, %entry], [%k.inc, %outer.inc]
%k.cmp = icmp slt i32 %k, %n %k.cmp = icmp slt i32 %k, %n
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner-third.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK,RAW ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK,RAW
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s --check-prefixes=CHECK ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefixes=CHECK
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) {
entry: entry:
br label %for1 br label %for1
for1: for1:
%j1 = phi i32 [0, %entry], [%j1.inc, %inc1] %j1 = phi i32 [0, %entry], [%j1.inc, %inc1]
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-inner.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
define void @func(i32 %n, [1024 x double]* noalias nonnull %A) { define void @func(i32 %n, [1024 x double]* noalias nonnull %A) {
entry: entry:
br label %outer.for br label %outer.for
outer.for: outer.for:
%k = phi i32 [0, %entry], [%k.inc, %outer.inc] %k = phi i32 [0, %entry], [%k.inc, %outer.inc]
%k.cmp = icmp slt i32 %k, %n %k.cmp = icmp slt i32 %k, %n
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/fuse-simple.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for1 br label %for1
for1: for1:
%j1 = phi i32 [0, %entry], [%j1.inc, %inc1] %j1 = phi i32 [0, %entry], [%j1.inc, %inc1]
%j1.cmp = icmp slt i32 %j1, %n %j1.cmp = icmp slt i32 %j1, %n
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/nofuse-simple.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; This could theoretically be fused by adjusting the offset of the second loop by %k (instead of relying on schedule dimensions). ; This could theoretically be fused by adjusting the offset of the second loop by %k (instead of relying on schedule dimensions).
define void @func(i32 %n, double* noalias nonnull %A, i32 %k) { define void @func(i32 %n, double* noalias nonnull %A, i32 %k) {
entry: entry:
br label %for1 br label %for1
for1: for1:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/GreedyFuse/nofuse-with-middle.ll

; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=0 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-opt-isl -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-reschedule=1 -polly-loopfusion-greedy=1 -polly-postopts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B, i32 %k) {
entry: entry:
br label %for1 br label %for1
for1: for1:
%j1 = phi i32 [0, %entry], [%j1.inc, %inc1] %j1 = phi i32 [0, %entry], [%j1.inc, %inc1]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/ManualOptimization/disable_nonforced.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-opt-isl -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Check that the disable_nonforced metadata is honored; optimization ; Check that the disable_nonforced metadata is honored; optimization
; heuristics/rescheduling must not be applied. ; heuristics/rescheduling must not be applied.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/ManualOptimization/distribute_heuristic.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-reschedule=0 -polly-pragma-based-opts=1 -analyze < %s | FileCheck %s --match-full-lines --check-prefix=ON ; RUN: opt %loadPolly -polly-reschedule=0 -polly-pragma-based-opts=1 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines --check-prefix=ON
; RUN: opt %loadPolly -polly-opt-isl -polly-reschedule=0 -polly-pragma-based-opts=0 -analyze < %s | FileCheck %s --match-full-lines --check-prefix=OFF ; RUN: opt %loadPolly -polly-reschedule=0 -polly-pragma-based-opts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines --check-prefix=OFF
; ;
define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B) { define void @func(i32 %n, double* noalias nonnull %A, double* noalias nonnull %B) {
entry: entry:
br label %for br label %for
for: for:
%j = phi i32 [0, %entry], [%j.inc, %inc] %j = phi i32 [0, %entry], [%j.inc, %inc]
%j.cmp = icmp slt i32 %j, %n %j.cmp = icmp slt i32 %j, %n
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_disable.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pragma-based-opts=1 -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-pragma-based-opts=1 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; ;
; Override unroll metadata with llvm.loop.unroll.disable. ; Override unroll metadata with llvm.loop.unroll.disable.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
Show All 28 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_double.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; ;
; Apply two loop transformations. First partial, then full unrolling. ; Apply two loop transformations. First partial, then full unrolling.
; ;
define void @func(double* noalias nonnull %A) { define void @func(double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_full.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; ;
; Full unroll of a loop with 5 iterations. ; Full unroll of a loop with 5 iterations.
; ;
define void @func(double* noalias nonnull %A) { define void @func(double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
Show All 32 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_heuristic.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pragma-based-opts=1 -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-pragma-based-opts=1 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; RUN: opt %loadPolly -polly-opt-isl -polly-pragma-based-opts=0 -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-pragma-based-opts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; ;
; Unrolling with heuristic factor. ; Unrolling with heuristic factor.
; Currently not supported and expected to be handled by LLVM's unroll pass. ; Currently not supported and expected to be handled by LLVM's unroll pass.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 28 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_partial.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pragma-based-opts=1 -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-pragma-based-opts=1 -polly-print-opt-isl -disable-output < %s | FileCheck %s --match-full-lines
; RUN: opt %loadPolly -polly-opt-isl -polly-pragma-based-opts=0 -analyze < %s | FileCheck %s --check-prefix=OFF --match-full-lines ; RUN: opt %loadPolly -polly-pragma-based-opts=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefix=OFF --match-full-lines
; ;
; Partial unroll by a factor of 4. ; Partial unroll by a factor of 4.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
for: for:
Show All 37 Lines

polly/test/ScheduleOptimizer/ManualOptimization/unroll_partial_followup.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-ast -analyze < %s | FileCheck %s --match-full-lines ; RUN: opt %loadPolly -polly-print-opt-isl -disable-output < %s | FileCheck %s --check-prefix=OPT --match-full-lines
; RUN: opt %loadPolly -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST --match-full-lines
; RUN: opt %loadPolly -polly-opt-isl -polly-codegen -simplifycfg -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-opt-isl -polly-codegen -simplifycfg -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; Partial unroll by a factor of 4. ; Partial unroll by a factor of 4.
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 22 Lines
!4 = !{!"llvm.loop.unroll.enable", i1 true} !4 = !{!"llvm.loop.unroll.enable", i1 true}
!5 = !{!"llvm.loop.unroll.count", i4 4} !5 = !{!"llvm.loop.unroll.count", i4 4}
!6 = !{!"llvm.loop.unroll.followup_unrolled", !7} !6 = !{!"llvm.loop.unroll.followup_unrolled", !7}
!7 = distinct !{!7, !8} !7 = distinct !{!7, !8}
!8 = !{!"llvm.loop.id", !"This-is-the-unrolled-loop"} !8 = !{!"llvm.loop.id", !"This-is-the-unrolled-loop"}
; CHECK-LABEL: Printing analysis 'Polly - Optimize schedule of SCoP' for region: 'for => return' in function 'func': ; OPT-LABEL: Printing analysis 'Polly - Optimize schedule of SCoP' for region: 'for => return' in function 'func':
; CHECK: domain: "[n] -> { Stmt_body[i0] : 0 <= i0 < n }" ; OPT: domain: "[n] -> { Stmt_body[i0] : 0 <= i0 < n }"
; CHECKL mark: "Loop with Metadata" ; OPT: mark: "Loop with Metadata"
; CHECK: schedule: "[n] -> [{ Stmt_body[i0] -> [(i0 - (i0) mod 4)] }]" ; OPT: schedule: "[n] -> [{ Stmt_body[i0] -> [(i0 - (i0) mod 4)] }]"
; CHECK: sequence: ; OPT: sequence:
; CHECK-NEXT: - filter: "[n] -> { Stmt_body[i0] : (i0) mod 4 = 0 }" ; OPT-NEXT: - filter: "[n] -> { Stmt_body[i0] : (i0) mod 4 = 0 }"
; CHECK-NEXT: - filter: "[n] -> { Stmt_body[i0] : (-1 + i0) mod 4 = 0 }" ; OPT-NEXT: - filter: "[n] -> { Stmt_body[i0] : (-1 + i0) mod 4 = 0 }"
; CHECK-NEXT: - filter: "[n] -> { Stmt_body[i0] : (2 + i0) mod 4 = 0 }" ; OPT-NEXT: - filter: "[n] -> { Stmt_body[i0] : (2 + i0) mod 4 = 0 }"
; CHECK-NEXT: - filter: "[n] -> { Stmt_body[i0] : (1 + i0) mod 4 = 0 }" ; OPT-NEXT: - filter: "[n] -> { Stmt_body[i0] : (1 + i0) mod 4 = 0 }"
; CHECK-LABEL: Printing analysis 'Polly - Generate an AST of the SCoP (isl)'for => return' in function 'func': ; AST-LABEL: Printing analysis 'Polly - Generate an AST of the SCoP (isl)'for => return' in function 'func':
; CHECK: // Loop with Metadata ; AST: // Loop with Metadata
; CHECK-NEXT: for (int c0 = 0; c0 < n; c0 += 4) { ; AST-NEXT: for (int c0 = 0; c0 < n; c0 += 4) {
; CODEGEN: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.exiting, !llvm.loop ![[LOOPID:[0-9]+]] ; CODEGEN: br i1 %polly.loop_cond, label %polly.loop_header, label %polly.exiting, !llvm.loop ![[LOOPID:[0-9]+]]
; CODEGEN: ![[LOOPID]] = distinct !{![[LOOPID]], ![[LOOPNAME:[0-9]+]]} ; CODEGEN: ![[LOOPID]] = distinct !{![[LOOPID]], ![[LOOPNAME:[0-9]+]]}
; CODEGEN: ![[LOOPNAME]] = !{!"llvm.loop.id", !"This-is-the-unrolled-loop"} ; CODEGEN: ![[LOOPNAME]] = !{!"llvm.loop.id", !"This-is-the-unrolled-loop"}

polly/test/ScheduleOptimizer/SIMDInParallelFor.ll

; RUN: opt %loadPolly -polly-parallel -polly-vectorizer=stripmine -polly-codegen-verify -polly-opt-isl -polly-ast -polly-codegen -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-parallel -polly-vectorizer=stripmine -polly-codegen-verify -polly-opt-isl -polly-print-ast -polly-codegen -disable-output < %s | FileCheck %s
; ;
; Check that there are no nested #pragma omp parallel for inside a ; Check that there are no nested #pragma omp parallel for inside a
; #pragma omp parallel for loop. ; #pragma omp parallel for loop.
; See llvm.org/PR38073 and llvm.org/PR33153 ; See llvm.org/PR38073 and llvm.org/PR33153
; ;
; This test unfortunately is very dependent on the result of the schedule ; This test unfortunately is very dependent on the result of the schedule
; optimizer (-polly-opt-isl). ; optimizer (-polly-opt-isl).
; ;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/computeout.ll

; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl -polly-isl-arg=--no-schedule-serialize-sccs -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl -polly-isl-arg=--no-schedule-serialize-sccs -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly "-passes=scop(polly-opt-isl,print<polly-ast>)" -polly-isl-arg=--no-schedule-serialize-sccs -disable-output < %s | FileCheck %s ; RUN: opt -S %loadPolly "-passes=scop(polly-opt-isl,print<polly-ast>)" -polly-isl-arg=--no-schedule-serialize-sccs -disable-output < %s | FileCheck %s
; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl -polly-isl-arg=--schedule-serialize-sccs -polly-ast -analyze -polly-dependences-computeout=1 < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl -polly-isl-arg=--schedule-serialize-sccs -polly-dependences-computeout=1 -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=TIMEOUT
; RUN: opt -S %loadPolly "-passes=scop(polly-opt-isl,print<polly-ast>)" -polly-isl-arg=--no-schedule-serialize-sccs -polly-dependences-computeout=1 -disable-output < %s | FileCheck %s -check-prefix=TIMEOUT ; RUN: opt -S %loadPolly "-passes=scop(polly-opt-isl,print<polly-ast>)" -polly-isl-arg=--no-schedule-serialize-sccs -polly-dependences-computeout=1 -disable-output < %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"
; 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/test/ScheduleOptimizer/ensure-correct-tile-sizes.ll

; RUN: opt %loadPolly -analyze -polly-process-unprofitable -polly-remarks-minimal \ ; RUN: opt %loadPolly -polly-process-unprofitable -polly-remarks-minimal \
; RUN: -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: -polly-opt-isl -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=1 \ ; RUN: -polly-target-latency-vector-fma=1 \
; RUN: -polly-ast -polly-target-vector-register-bitwidth=4096 \ ; RUN: -polly-target-vector-register-bitwidth=4096 \
; RUN: -polly-target-1st-cache-level-associativity=3 < %s | FileCheck %s ; RUN: -polly-target-1st-cache-level-associativity=3 -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; /* Test that Polly does not crash due to configurations that can lead to ; /* Test that Polly does not crash due to configurations that can lead to
; incorrect tile size computations. ; incorrect tile size computations.
; The parameters are setup such that Car in `getMacroKernelParams` ; The parameters are setup such that Car in `getMacroKernelParams`
; is evaluated to 0. */ ; is evaluated to 0. */
; ;
; static const int N = 3000; ; static const int N = 3000;
; ;
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/focaltech_test_detail_threshold-7bc17e.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-vectorizer=stripmine -polly-invariant-load-hoisting -polly-optimized-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-vectorizer=stripmine -polly-invariant-load-hoisting -polly-optimized-scops -polly-print-opt-isl -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly "-passes=scop(print<polly-opt-isl>)" -polly-vectorizer=stripmine -polly-invariant-load-hoisting -disable-output < %s | FileCheck %s ; RUN: opt %loadPolly "-passes=scop(print<polly-opt-isl>)" -polly-vectorizer=stripmine -polly-invariant-load-hoisting -disable-output < %s | FileCheck %s
; ;
; llvm.org/PR46578 ; llvm.org/PR46578
; ;
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
%struct.stCfg_Incell_DetailThreshold.2.30.42.62.74.94.122.126.134.166.194.242.338.342.346.350.354.358.496.0.2.9.16.28.36.37.38.39.40.75 = type { [60 x i8]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]* } %struct.stCfg_Incell_DetailThreshold.2.30.42.62.74.94.122.126.134.166.194.242.338.342.346.350.354.358.496.0.2.9.16.28.36.37.38.39.40.75 = type { [60 x i8]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]*, [60 x i32]* }
@ft8006m_g_stCfg_Incell_DetailThreshold = external dso_local local_unnamed_addr global %struct.stCfg_Incell_DetailThreshold.2.30.42.62.74.94.122.126.134.166.194.242.338.342.346.350.354.358.496.0.2.9.16.28.36.37.38.39.40.75, align 8 @ft8006m_g_stCfg_Incell_DetailThreshold = external dso_local local_unnamed_addr global %struct.stCfg_Incell_DetailThreshold.2.30.42.62.74.94.122.126.134.166.194.242.338.342.346.350.354.358.496.0.2.9.16.28.36.37.38.39.40.75, align 8
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/full_partial_tile_separation.ll

; RUN: opt -S %loadPolly -polly-pattern-matching-based-opts=false \ ; RUN: opt -S %loadPolly -polly-pattern-matching-based-opts=false -polly-vectorizer=stripmine -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: -polly-vectorizer=stripmine -polly-opt-isl -polly-ast -analyze \
; RUN: < %s | FileCheck %s
; CHECK: // 1st level tiling - Tiles ; CHECK: // 1st level tiling - Tiles
; CHECK-NEXT: #pragma known-parallel ; CHECK-NEXT: #pragma known-parallel
; CHECK-NEXT: for (int c0 = 0; c0 <= floord(ni - 1, 32); c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 <= floord(ni - 1, 32); c0 += 1)
; CHECK-NEXT: for (int c1 = 0; c1 <= floord(nj - 1, 32); c1 += 1) ; CHECK-NEXT: for (int c1 = 0; c1 <= floord(nj - 1, 32); c1 += 1)
; CHECK-NEXT: #pragma minimal dependence distance: 1 ; CHECK-NEXT: #pragma minimal dependence distance: 1
; CHECK-NEXT: for (int c2 = 0; c2 <= floord(nk - 1, 32); c2 += 1) { ; CHECK-NEXT: for (int c2 = 0; c2 <= floord(nk - 1, 32); c2 += 1) {
; CHECK-NEXT: // 1st level tiling - Points ; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: for (int c3 = 0; c3 <= min(31, ni - 32 * c0 - 1); c3 += 1) { ; CHECK-NEXT: for (int c3 = 0; c3 <= min(31, ni - 32 * c0 - 1); c3 += 1) {
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-opt-isl -analyze \ ; RUN: opt %loadPolly -polly-tile-sizes=1,64 -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: -polly-ast -polly-tile-sizes=1,64 < %s | FileCheck %s
; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 1023; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 7; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 7; c1 += 1)
; CHECK: for (int c3 = 0; c3 <= 63; c3 += 1) ; CHECK: for (int c3 = 0; c3 <= 63; c3 += 1)
; CHECK: Stmt_for_body3(c0, 64 * c1 + c3); ; CHECK: Stmt_for_body3(c0, 64 * c1 + c3);
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 30 Lines

polly/test/ScheduleOptimizer/line-tiling.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-ast -polly-tile-sizes=64,1 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-tile-sizes=64,1 -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; CHECK: for (int c0 = 0; c0 <= 15; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 15; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 511; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 511; c1 += 1)
; CHECK: for (int c2 = 0; c2 <= 63; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 63; c2 += 1)
; CHECK: Stmt_for_body3(64 * c0 + c2, c1); ; CHECK: Stmt_for_body3(64 * c0 + c2, c1);
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 30 Lines

polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-2nd-cache-level-size=262144 -polly-ast \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -analyze < %s | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; /* C := alpha*A*B + beta*C */ ; /* C := alpha*A*B + beta*C */
; /* _PB_NK % Kc != 0 */ ; /* _PB_NK % Kc != 0 */
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; { ; {
; C[i][j] *= beta; ; C[i][j] *= beta;
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/one-dimensional-band.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-ast -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; void jacobi1d(long T, long N, float *A, float *B) { ; void jacobi1d(long T, long N, float *A, float *B) {
; long t, i, j; ; long t, i, j;
; for (t = 0; t < T; t++) { ; for (t = 0; t < T; t++) {
; for (i = 1; i < N - 1; i++) ; for (i = 1; i < N - 1; i++)
; B[i] = 0.33333 * (A[i - 1] + A[i] + A[i + 1]); ; B[i] = 0.33333 * (A[i - 1] + A[i] + A[i + 1]);
; for (j = 1; j < N - 1; j++) ; for (j = 1; j < N - 1; j++)
; A[j] = 0.33333 * (B[i - 1] + B[i] + B[i + 1]); ; A[j] = 0.33333 * (B[i - 1] + B[i] + B[i + 1]);
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/outer_coincidence.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-ast -polly-tiling=0 -polly-parallel -polly-opt-outer-coincidence=no -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-tiling=0 -polly-parallel -polly-opt-outer-coincidence=no -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-opt-isl -polly-ast -polly-tiling=0 -polly-parallel -polly-opt-outer-coincidence=yes -analyze < %s | FileCheck %s --check-prefix=OUTER ; RUN: opt %loadPolly -polly-tiling=0 -polly-parallel -polly-opt-outer-coincidence=yes -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=OUTER
; By skewing, the diagonal can be made parallel. ISL does this when the Check ; By skewing, the diagonal can be made parallel. ISL does this when the Check
; the 'outer_coincidence' option is enabled. ; the 'outer_coincidence' option is enabled.
; ;
; void func(int m, int n, float A[static const restrict m][n]) { ; void func(int m, int n, float A[static const restrict m][n]) {
; for (int i = 1; i < m; i+=1) ; for (int i = 1; i < m; i+=1)
; for (int j = 1; j < n; j+=1) ; for (int j = 1; j < n; j+=1)
; A[i][j] = A[i-1][j] + A[i][j-1]; ; A[i][j] = A[i-1][j] + A[i][j-1];
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=false \ ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=false -debug < %s 2>&1 | FileCheck %s
; RUN: -debug < %s 2>&1| FileCheck %s
; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -debug < %s 2>&1| FileCheck %s --check-prefix=PATTERN-MATCHING-OPTS ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -debug < %s 2>&1 | FileCheck %s --check-prefix=PATTERN-MATCHING-OPTS
; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -polly-ast-detect-parallel -polly-ast -analyze < %s | FileCheck %s --check-prefix=PARALLEL-AST ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -polly-ast-detect-parallel -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=PARALLEL-AST
; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -stats -disable-output < %s 2>&1| FileCheck %s --check-prefix=STATS -match-full-lines ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true -stats -disable-output < %s 2>&1 | FileCheck %s --check-prefix=STATS -match-full-lines
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; /* C := alpha*A*B + beta*C */ ; /* C := alpha*A*B + beta*C */
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; { ; {
; C[i][j] *= beta; ; C[i][j] *= beta;
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_12.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: -polly-opt-isl -disable-output < %s
; ;
; Test whether isolation works as expected. ; Test whether isolation works as expected.
; ;
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 internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, i8 signext %alpha, i8 signext %beta, [1020 x i8]* %C, [1020 x i8]* %A, [1020 x i8]* %B) { define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, i8 signext %alpha, i8 signext %beta, [1020 x i8]* %C, [1020 x i8]* %A, [1020 x i8]* %B) {
entry: entry:
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=2 \ ; RUN: -polly-target-throughput-vector-fma=2 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=128 \ ; RUN: -polly-target-vector-register-bitwidth=128 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; Test whether isolation works as expected. ; Test whether isolation works as expected.
; ;
; CHECK: // 1st level tiling - Tiles ; CHECK: // 1st level tiling - Tiles
; CHECK-NEXT: for (int c0 = 0; c0 <= 1; c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 <= 1; c0 += 1)
; CHECK-NEXT: for (int c1 = 0; c1 <= 6; c1 += 1) { ; CHECK-NEXT: for (int c1 = 0; c1 <= 6; c1 += 1) {
; CHECK-NEXT: for (int c3 = 1536 * c0; c3 <= min(1999, 1536 * c0 + 1535); c3 += 1) ; CHECK-NEXT: for (int c3 = 1536 * c0; c3 <= min(1999, 1536 * c0 + 1535); c3 += 1)
; CHECK-NEXT: for (int c4 = 307 * c1; c4 <= min(1999, 307 * c1 + 306); c4 += 1) ; CHECK-NEXT: for (int c4 = 307 * c1; c4 <= min(1999, 307 * c1 + 306); c4 += 1)
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-size=0 \ ; RUN: -polly-target-1st-cache-level-size=0 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s 2>&1 \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s --check-prefix=EXTRACTION-OF-MACRO-KERNEL ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s 2>&1 | FileCheck %s --check-prefix=EXTRACTION-OF-MACRO-KERNEL
; ;
; /* C := alpha*A*B + beta*C */ ; /* C := alpha*A*B + beta*C */
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; { ; {
; C[i][j] *= beta; ; C[i][j] *= beta;
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
; C[i][j] += alpha * A[i][k] * B[k][j]; ; C[i][j] += alpha * A[i][k] * B[k][j];
▲ Show 20 Lines • Show All 166 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \
; RUN: -debug < %s 2>&1| FileCheck %s ; RUN: -debug < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 -polly-ast \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: -analyze < %s | FileCheck %s --check-prefix=PATTERN-MATCHING-OPTS ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=PATTERN-MATCHING-OPTS
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; C := A * B + C ; C := A * B + C
; Check that the pattern matching optimizations can detect different ; Check that the pattern matching optimizations can detect different
; permutations of GEMM loop and produce the correct ISL AST. In this case, ; permutations of GEMM loop and produce the correct ISL AST. In this case,
; dimensions of band nodes can be implicitly permuted by the algorithm ; dimensions of band nodes can be implicitly permuted by the algorithm
; applied during the schedule generation. It should be taken into the ; applied during the schedule generation. It should be taken into the
; account during the pattern matching optimizations. ; account during the pattern matching optimizations.
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \
; -polly-target-throughput-vector-fma=1 \ ; -polly-target-throughput-vector-fma=1 \
; -polly-target-latency-vector-fma=8 \ ; -polly-target-latency-vector-fma=8 \
; -polly-codegen -polly-target-1st-cache-level-associativity=8 \ ; -polly-codegen -polly-target-1st-cache-level-associativity=8 \
; -polly-target-2nd-cache-level-associativity=8 \ ; -polly-target-2nd-cache-level-associativity=8 \
; -polly-target-1st-cache-level-size=32768 \ ; -polly-target-1st-cache-level-size=32768 \
; -polly-target-vector-register-bitwidth=256 \ ; -polly-target-vector-register-bitwidth=256 \
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \
; -polly-target-throughput-vector-fma=1 \ ; -polly-target-throughput-vector-fma=1 \
; -polly-target-latency-vector-fma=8 \ ; -polly-target-latency-vector-fma=8 \
; -polly-codegen -polly-target-1st-cache-level-associativity=8 \ ; -polly-codegen -polly-target-1st-cache-level-associativity=8 \
; -polly-target-2nd-cache-level-associativity=8 \ ; -polly-target-2nd-cache-level-associativity=8 \
; -polly-target-1st-cache-level-size=32768 \ ; -polly-target-1st-cache-level-size=32768 \
; -polly-target-vector-register-bitwidth=256 \ ; -polly-target-vector-register-bitwidth=256 \
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; /* C := A * B + C */ ; /* C := A * B + C */
; /* Elements of the matrices A, B, C have the float type. */ ; /* Elements of the matrices A, B, C have the float type. */
; /* The type size of elements of the matrix multiplication operands is used ; /* The type size of elements of the matrix multiplication operands is used
; to determine the parameters of the code produced by the optimization ; to determine the parameters of the code produced by the optimization
; of the matrix multiplication (e.g. bounds of the loops of the loop ; of the matrix multiplication (e.g. bounds of the loops of the loop
; nest, the innermost loop body). This test checks the form of ; nest, the innermost loop body). This test checks the form of
; the generated loop nest. See getMicroKernelParams and ; the generated loop nest. See getMicroKernelParams and
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: | FileCheck %s ; RUN: -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; /* C := A * B + C */ ; /* C := A * B + C */
; /* Elements of the matrices B, C have the double type. */ ; /* Elements of the matrices B, C have the double type. */
; /* Elements of the matrix A have the float type. */ ; /* Elements of the matrix A have the float type. */
; /* The type size of elements of the matrix multiplication operands is used ; /* The type size of elements of the matrix multiplication operands is used
; to determine the parameters of the code produced by the optimization ; to determine the parameters of the code produced by the optimization
; of the matrix multiplication (e.g. bounds of the loops of the loop ; of the matrix multiplication (e.g. bounds of the loops of the loop
; nest, the innermost loop body). This test checks the form of ; nest, the innermost loop body). This test checks the form of
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/pattern-matching-based-opts_9.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=1 \ ; RUN: -polly-target-throughput-vector-fma=1 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \ ; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s ; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: -polly-opt-isl -disable-output < %s
; ;
; RUN: opt %loadPolly -analyze -polly-dependences < %s | FileCheck %s \ ; RUN: opt %loadPolly -polly-print-dependences -disable-output < %s | FileCheck %s --check-prefix=DEPENDENCES
; RUN: --check-prefix=DEPENDENCES
; ;
; /* C := A * B + C */ ; /* C := A * B + C */
; /* Elements of the matrices A, B, C have the char type. */ ; /* Elements of the matrices A, B, C have the char type. */
; /* The type size of elements of the matrix multiplication operands is used ; /* The type size of elements of the matrix multiplication operands is used
; to determine the parameters of the code produced by the optimization ; to determine the parameters of the code produced by the optimization
; of the matrix multiplication (e.g. bounds of the loops of the loop ; of the matrix multiplication (e.g. bounds of the loops of the loop
; nest, the innermost loop body). This test checks the form of ; nest, the innermost loop body). This test checks the form of
; the generated loop nest. See getMicroKernelParams and ; the generated loop nest. See getMicroKernelParams and
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/prevectorization-without-tiling.ll

; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl -polly-tiling=false \ ; RUN: opt -S %loadPolly -basic-aa -polly-tiling=false -polly-pattern-matching-based-opts=false -polly-vectorizer=polly -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: -polly-pattern-matching-based-opts=false -polly-vectorizer=polly \
; RUN: -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"
@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
define void @foo() #0 { define void @foo() #0 {
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/prevectorization.ll

; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl \ ; RUN: opt -S %loadPolly -basic-aa -polly-pattern-matching-based-opts=false -polly-vectorizer=polly -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: -polly-pattern-matching-based-opts=false -polly-vectorizer=polly \ ; RUN: opt -S %loadPolly -basic-aa -polly-pattern-matching-based-opts=false -polly-vectorizer=stripmine -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: -polly-ast -analyze < %s | FileCheck %s ; RUN: opt -S %loadPolly -basic-aa -polly-pattern-matching-based-opts=false -polly-vectorizer=polly -polly-prevect-width=16 -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s -check-prefix=VEC16
; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl \
; RUN: -polly-pattern-matching-based-opts=false -polly-vectorizer=stripmine \
; RUN: -polly-ast -analyze < %s | FileCheck %s
; RUN: opt -S %loadPolly -basic-aa -polly-opt-isl \
; RUN: -polly-vectorizer=polly -polly-pattern-matching-based-opts=false \
; RUN: -polly-ast -analyze -polly-prevect-width=16 < %s | \
; RUN: FileCheck %s -check-prefix=VEC16
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"
@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 91 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/rectangular-tiling.ll

; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-ast -polly-tile-sizes=256,16 < %s | FileCheck %s ; RUN: opt %loadPolly -polly-tile-sizes=256,16 -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-opt-isl -analyze -polly-tiling=false -polly-ast -polly-tile-sizes=256,16 < %s | FileCheck %s --check-prefix=NOTILING ; RUN: opt %loadPolly -polly-tile-sizes=256,16 -polly-tiling=false -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=NOTILING
; RUN: opt %loadPolly -polly-tile-sizes=256,16 -polly-2nd-level-tiling -polly-2nd-level-tile-sizes=16,8 -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=TWOLEVEL
; RUN: opt %loadPolly -polly-opt-isl -analyze \ ; RUN: opt %loadPolly -polly-tile-sizes=256,16 -polly-2nd-level-tiling -polly-2nd-level-tile-sizes=16,8 -polly-register-tiling -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=TWO-PLUS-REGISTER
; RUN: -polly-2nd-level-tiling -polly-ast \ ; RUN: opt %loadPolly -polly-tile-sizes=256,16 -polly-2nd-level-tiling -polly-2nd-level-tile-sizes=16,8 -polly-register-tiling -polly-register-tile-sizes=2,4 -polly-vectorizer=polly -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=TWO-PLUS-REGISTER-PLUS-VECTORIZATION
; RUN: -polly-tile-sizes=256,16 \
; RUN: -polly-2nd-level-tile-sizes=16,8 < %s | \
; RUN: FileCheck %s --check-prefix=TWOLEVEL
; RUN: opt %loadPolly -polly-opt-isl -analyze \
; RUN: -polly-2nd-level-tiling -polly-ast \
; RUN: -polly-tile-sizes=256,16 \
; RUN: -polly-register-tiling \
; RUN: -polly-2nd-level-tile-sizes=16,8 < %s | \
; RUN: FileCheck %s --check-prefix=TWO-PLUS-REGISTER
; RUN: opt %loadPolly -polly-opt-isl -analyze \
; RUN: -polly-2nd-level-tiling -polly-ast \
; RUN: -polly-tile-sizes=256,16 \
; RUN: -polly-register-tiling -polly-register-tile-sizes=2,4 \
; RUN: -polly-vectorizer=polly \
; RUN: -polly-2nd-level-tile-sizes=16,8 < %s | \
; RUN: FileCheck %s --check-prefix=TWO-PLUS-REGISTER-PLUS-VECTORIZATION
; CHECK: // 1st level tiling - Tiles ; CHECK: // 1st level tiling - Tiles
; CHECK: for (int c0 = 0; c0 <= 3; c0 += 1) ; CHECK: for (int c0 = 0; c0 <= 3; c0 += 1)
; CHECK: for (int c1 = 0; c1 <= 31; c1 += 1) ; CHECK: for (int c1 = 0; c1 <= 31; c1 += 1)
; CHECK: // 1st level tiling - Points ; CHECK: // 1st level tiling - Points
; CHECK: for (int c2 = 0; c2 <= 255; c2 += 1) ; CHECK: for (int c2 = 0; c2 <= 255; c2 += 1)
; CHECK: for (int c3 = 0; c3 <= 15; c3 += 1) ; CHECK: for (int c3 = 0; c3 <= 15; c3 += 1)
; CHECK: Stmt_for_body3(256 * c0 + c2, 16 * c1 + c3); ; CHECK: Stmt_for_body3(256 * c0 + c2, 16 * c1 + c3);
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/tile_after_fusion.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-ast -polly-isl-arg=--no-schedule-serialize-sccs -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-isl-arg=--no-schedule-serialize-sccs -polly-opt-isl -polly-print-ast -disable-output < %s | FileCheck %s
; ;
; ;
; void tf(int C[256][256][256], int A0[256][256][256], int A1[256][256][256]) { ; void tf(int C[256][256][256], int A0[256][256][256], int A1[256][256][256]) {
; for (int i = 0; i < 256; ++i) ; for (int i = 0; i < 256; ++i)
; for (int j = 0; j < 256; ++j) ; for (int j = 0; j < 256; ++j)
; for (int k = 0; k < 256; ++k) ; for (int k = 0; k < 256; ++k)
; C[i][j][k] += A0[i][j][k]; ; C[i][j][k] += A0[i][j][k];
; ;
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

polly/test/ScheduleOptimizer/vivid-vbi-gen-vivid_vbi_gen_sliced-before-llvmreduced.ll

; RUN: opt %loadPolly -polly-vectorizer=stripmine -polly-isl-arg=--no-schedule-serialize-sccs -polly-tiling=0 -polly-opt-isl -analyze - < %s | FileCheck %s ; RUN: opt %loadPolly -polly-vectorizer=stripmine -polly-isl-arg=--no-schedule-serialize-sccs -polly-tiling=0 -polly-print-opt-isl -disable-output < %s | FileCheck %s
; isl_schedule_node_band_sink may sink into multiple children. ; isl_schedule_node_band_sink may sink into multiple children.
; https://llvm.org/PR52637 ; https://llvm.org/PR52637
%struct.v4l2_sliced_vbi_data = type { [48 x i8] } %struct.v4l2_sliced_vbi_data = type { [48 x i8] }
define void @vivid_vbi_gen_sliced() { define void @vivid_vbi_gen_sliced() {
entry: entry:
Show All 36 Lines

polly/test/ScopDetect/aliasing_parametric_simple_1.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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/test/ScopDetect/aliasing_parametric_simple_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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/test/ScopDetect/aliasing_simple_1.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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/test/ScopDetect/aliasing_simple_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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/test/ScopDetect/base_pointer.ll

; RUN: opt %loadPolly -disable-basic-aa -polly-detect -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -disable-basic-aa -polly-invariant-load-hoisting=true -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
define void @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind { define void @base_pointer_in_condition(i64** noalias %A_ptr, i64 %N) nounwind {
entry: entry:
fence seq_cst fence seq_cst
br label %pre br label %pre
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

polly/test/ScopDetect/base_pointer_load_setNewAccessRelation.ll

; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -polly-import-jscop -polly-codegen -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -polly-print-import-jscop -polly-codegen -disable-output < %s | FileCheck %s
; ;
; This violated an assertion in setNewAccessRelation that assumed base pointers ; This violated an assertion in setNewAccessRelation that assumed base pointers
; to be load-hoisted. Without this assertion, it codegen would generate invalid ; to be load-hoisted. Without this assertion, it codegen would generate invalid
; code. ; code.
; ;
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
define void @base_pointer_load_is_inst_inside_invariant_1(i64 %n, float** %A) { define void @base_pointer_load_is_inst_inside_invariant_1(i64 %n, float** %A) {
Show All 33 Lines

polly/test/ScopDetect/base_pointer_setNewAccessRelation.ll

; RUN: opt %loadPolly -disable-basic-aa -polly-detect -polly-import-jscop -polly-codegen -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -disable-basic-aa -polly-detect -polly-print-import-jscop -polly-codegen -disable-output < %s | FileCheck %s --allow-empty
; ;
; Polly codegen used to generate invalid code (referring to %ptr from the ; Polly codegen used to generate invalid code (referring to %ptr from the
; original region) when regeneration of the access function is necessary. ; original region) when regeneration of the access function is necessary.
; The SCoP is now rejected as a whole because %ptr is not considered a valid ; The SCoP is now rejected as a whole because %ptr is not considered a valid
; base pointer. ; base pointer.
; ;
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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/test/ScopDetect/collective_invariant_loads.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting -disable-output< %s | FileCheck %s
;CHECK: Function: test_init_chpl ;CHECK: Function: test_init_chpl
;CHECK-NEXT: Region: %bb1---%bb16 ;CHECK-NEXT: Region: %bb1---%bb16
;CHECK-NEXT: Max Loop Depth: 2 ;CHECK-NEXT: Max Loop Depth: 2
;CHECK-NEXT: Invariant Accesses: { ;CHECK-NEXT: Invariant Accesses: {
;CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ;CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
;CHECK-NEXT: [tmp5] -> { Stmt_bb2[i0, i1] -> MemRef_arg[1] }; ;CHECK-NEXT: [tmp5] -> { Stmt_bb2[i0, i1] -> MemRef_arg[1] };
;CHECK-NEXT: Execution Context: [tmp5] -> { : } ;CHECK-NEXT: Execution Context: [tmp5] -> { : }
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/ScopDetect/cross_loop_non_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 39 Lines

polly/test/ScopDetect/cross_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 51 Lines • Show Last 20 Lines

polly/test/ScopDetect/dot-scops.ll

; RUN: opt %loadPolly -polly-scops -dot-scops -analyze < %s ; RUN: opt %loadPolly -polly-scops -dot-scops -disable-output < %s
; ;
; Check that the ScopPrinter does not crash. ; Check that the ScopPrinter does not crash.
; ScopPrinter needs the ScopDetection pass, which should depend on ; ScopPrinter needs the ScopDetection pass, which should depend on
; ScalarEvolution transitively. ; ScalarEvolution transitively.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @func(i32 %n, i32 %m, double* noalias nonnull %A) { define void @func(i32 %n, i32 %m, double* noalias nonnull %A) {
Show All 38 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.hoge = type { i32, i32, i32, i32 } %struct.hoge = type { i32, i32, i32, i32 }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @hoge() #0 { define void @hoge() #0 {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopDetect/error-block-unreachable.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s ; RUN: opt %loadPolly -polly-detect -disable-output < %s
; Verify that the scop detection does not crash on inputs with unreachable ; Verify that the scop detection does not crash on inputs with unreachable
; blocks. Earlier we crashed when detecting error blocks. ; blocks. Earlier we crashed when detecting error blocks.
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
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer ; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer
; ;
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @qtm_decompress() #0 { define void @qtm_decompress() #0 {
entry: entry:
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer ; CHECK: Valid Region for Scop: if.end.1631 => for.cond.1647.outer
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @qtm_decompress() { define void @qtm_decompress() {
entry: entry:
br label %while.cond.outer.outer br label %while.cond.outer.outer
Show All 35 Lines

polly/test/ScopDetect/ignore_func_flag_regex.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-ignore-func=f.*,g.* < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ignore-func=f.*,g.* -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the flag `-polly-ignore-func` works with regexes. ; Check that the flag `-polly-ignore-func` works with regexes.
; ;
; CHECK: Function: h ; CHECK: Function: h
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
; ;
; CHECK-NOT: Function: ; CHECK-NOT: Function:
; ;
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

polly/test/ScopDetect/index_from_unpredictable_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=AFFINE ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=AFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=NONAFFINE
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; The loop for.body => for.inc has an unpredictable iteration count could due to ; The loop for.body => for.inc has an unpredictable iteration count could due to
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/ScopDetect/index_from_unpredictable_loop2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=AFFINE ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=AFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=NONAFFINE
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; The loop for.body => for.inc has an unpredictable iteration count could due to ; The loop for.body => for.inc has an unpredictable iteration count could due to
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

polly/test/ScopDetect/indvars.ll

; RUN: opt %loadPolly -analyze -polly-detect -polly-codegen < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -polly-codegen -disable-output < %s | FileCheck %s
; ;
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
define void @main(i64* %A, i64* %B) nounwind { define void @main(i64* %A, i64* %B) nounwind {
entry: entry:
br label %for.i br label %for.i
for.i: for.i:
Show All 30 Lines

polly/test/ScopDetect/intrinsics_1.ll

; RUN: opt %loadPolly -basic-aa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-detect -disable-output < %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/test/ScopDetect/intrinsics_2.ll

; RUN: opt %loadPolly -basic-aa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-detect -disable-output < %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/test/ScopDetect/intrinsics_3.ll

; RUN: opt %loadPolly -basic-aa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-detect -disable-output < %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 83 Lines • Show Last 20 Lines

polly/test/ScopDetect/invalid-latch-conditions.ll

; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=NALOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: opt %loadPolly -polly-allow-nonaffine-loops \
; RUN: -polly-detect -analyze < %s | FileCheck %s --check-prefix=NALOOPS
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-detect -analyze \
; RUN: -polly-process-unprofitable=false < %s | \
; RUN: FileCheck %s --check-prefix=PROFIT
; The latch conditions of the outer loop are not affine, thus the loop cannot ; The latch conditions of the outer loop are not affine, thus the loop cannot
; handled by the domain generation and needs to be overapproximated. ; handled by the domain generation and needs to be overapproximated.
; CHECK-NOT: Valid ; CHECK-NOT: Valid
; NALOOPS: Valid Region for Scop: for.body.6 => for.end.45 ; NALOOPS: Valid Region for Scop: for.body.6 => for.end.45
; PROFIT-NOT: Valid ; PROFIT-NOT: Valid
Show All 30 Lines

polly/test/ScopDetect/invalidate_scalar_evolution.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s -check-prefix=PHI ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s -check-prefix=PHI
; void f(long A[], long N) { ; void f(long A[], long N) {
; long i; ; long i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; A[i] = i; ; A[i] = i;
; } ; }
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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 33 Lines

polly/test/ScopDetect/invariant-load-before-scop.ll

; RUN: opt %loadPolly -polly-detect -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s -match-full-lines
; ;
; The LoadInst %.b761 is defined outside the SCoP, hence is always constant ; The LoadInst %.b761 is defined outside the SCoP, hence is always constant
; within it. It is no "required invariant load". ; within it. It is no "required invariant load".
; This test is designed to ensure that %.b761 is not added to the list of ; This test is designed to ensure that %.b761 is not added to the list of
; "required invariant loads" which causes an assertion fail in ScopInfo. ; "required invariant loads" which causes an assertion fail in ScopInfo.
; ScopInfo rejects the SCoP, so we cannot check the list if invariant loads. ; ScopInfo rejects the SCoP, so we cannot check the list if invariant loads.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/test/ScopDetect/keep_going_expansion.ll

; RUN: opt %loadPolly -basic-aa -polly-detect-track-failures -polly-detect-keep-going -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-detect-track-failures -polly-detect-keep-going -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 { define i32 @a(i32 %n, i32* noalias %A, i32* noalias %B) #0 {
entry: entry:
br label %entry.split br label %entry.split
entry.split: ; preds = %entry entry.split: ; preds = %entry
Show All 36 Lines

polly/test/ScopDetect/mod_ref_read_pointer.ll

; RUN: opt %loadPolly -basic-aa -polly-detect -analyze \ ; RUN: opt %loadPolly -basic-aa -polly-allow-modref-calls -polly-print-detect -disable-output < %s | FileCheck %s -check-prefix=MODREF
; RUN: -polly-allow-modref-calls < %s | FileCheck %s -check-prefix=MODREF ; RUN: opt %loadPolly -basic-aa -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-detect -analyze \
; RUN: < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: for.body => for.end ; CHECK-NOT: Valid Region for Scop: for.body => for.end
; MODREF: Valid Region for Scop: for.body => for.end ; MODREF: Valid Region for Scop: for.body => for.end
; ;
; #pragma readonly ; #pragma readonly
; int func(int *A); ; int func(int *A);
; ;
; void jd(int *A) { ; void jd(int *A) {
Show All 30 Lines

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

; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: \ ; RUN: opt %loadPolly -polly-process-unprofitable=true -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -polly-detect -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=true \
; RUN: \
; RUN: -polly-detect -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: ; CHECK: Valid Region for Scop:
; void foo(float *A, float *B, long N) { ; void foo(float *A, float *B, long N) {
; if (N > 100) ; if (N > 100)
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] += i; ; A[i] += i;
; else ; else
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Valid Region for Scop: bb14 => bb17 ; CHECK: Valid Region for Scop: bb14 => bb17
; Make sure we do not detect the larger region bb14->bb19 that contains ; Make sure we do not detect the larger region bb14->bb19 that contains
; a multi-dimensional memory access with a size of 'undef * undef'. ; a multi-dimensional memory access with a size of 'undef * undef'.
define void @hoge(i8* %arg) { define void @hoge(i8* %arg) {
Show All 27 Lines

polly/test/ScopDetect/multidim.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; CHECK: Valid Region for Scop: bb19 => bb20 ; CHECK: Valid Region for Scop: bb19 => bb20
; Make sure we do not crash in this test case. ; Make sure we do not crash in this test case.
define void @hoge(i8* %arg) { define void @hoge(i8* %arg) {
bb: bb:
Show All 27 Lines

polly/test/ScopDetect/multidim_indirect_access.ll

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

polly/test/ScopDetect/multidim_two_accesses_different_delinearization.ll

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

polly/test/ScopDetect/nested_loop_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %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 34 Lines

polly/test/ScopDetect/non-affine-conditional.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-detect \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; A[i] = 0; ; A[i] = 0;
; } ; }
; ;
; CHECK: Valid Region for Scop: bb1 => bb9 ; CHECK: Valid Region for Scop: bb1 => bb9
Show All 33 Lines

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

; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i] == A[i - 1]) ; if (A[i] == A[i - 1])
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Valid Region for Scop: bb1 => bb14 ; CHECK: Valid Region for Scop: bb1 => bb14
Show All 37 Lines

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

; RUN: opt %loadPolly -basic-aa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly -basic-aa -polly-detect -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -basic-aa -polly-detect -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -basic-aa -polly-detect -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -analyze < %s \
; RUN: | FileCheck %s --check-prefix=PROFIT
; ;
; Here we have a non-affine loop but also a non-affine access which should ; Here we have a non-affine loop but also a non-affine access which should
; be rejected as long as -polly-allow-nonaffine isn't given. ; be rejected as long as -polly-allow-nonaffine isn't given.
; ;
; REJECTNONAFFINELOOPS-NOT: Valid ; REJECTNONAFFINELOOPS-NOT: Valid
; ALLOWNONAFFINELOOPS-NOT: Valid ; ALLOWNONAFFINELOOPS-NOT: Valid
; ALLOWNONAFFINELOOPSANDACCESSES: Valid Region for Scop: bb1 => bb13 ; ALLOWNONAFFINELOOPSANDACCESSES: Valid Region for Scop: bb1 => bb13
; PROFIT-NOT: Valid ; PROFIT-NOT: Valid
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s \
; RUN: | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always detect the ; and also a non-affine access (A[k]). While we can always detect the
; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not ; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not
; both, non-affine loops as well as non-affine accesses are allowed. ; both, non-affine loops as well as non-affine accesses are allowed.
; ;
; REJECTNONAFFINELOOPS: Valid Region for Scop: bb15 => bb13 ; REJECTNONAFFINELOOPS: Valid Region for Scop: bb15 => bb13
; REJECTNONAFFINELOOPS-NOT: Valid ; REJECTNONAFFINELOOPS-NOT: Valid
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always detect the ; and also a non-affine access (A[k]). While we can always detect the
; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not ; innermost loop as a SCoP of depth 1, we have to reject the loop nest if not
; both, non-affine loops as well as non-affine accesses are allowed. ; both, non-affine loops as well as non-affine accesses are allowed.
; ;
; REJECTNONAFFINELOOPS: Valid Region for Scop: bb15 => bb13 ; REJECTNONAFFINELOOPS: Valid Region for Scop: bb15 => bb13
; REJECTNONAFFINELOOPS-NOT: Valid ; REJECTNONAFFINELOOPS-NOT: Valid
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

polly/test/ScopDetect/non-affine-loop.ll

; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: -analyze < %s | FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=false -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINEREGIONSANDACCESSES
; RUN: opt %loadPolly -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALLOWNONAFFINELOOPSANDACCESSES
; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true -polly-allow-nonaffine \
; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=PROFIT
; ;
; This function/region does contain a loop, however it is non-affine, hence the access ; This function/region does contain a loop, however it is non-affine, hence the access
; A[i] is also. Furthermore, it is the only loop, thus when we over approximate ; A[i] is also. Furthermore, it is the only loop, thus when we over approximate
; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will ; non-affine loops __and__ accesses __and__ allow regins without a (affine) loop we will
; detect it, otherwise we won't. ; detect it, otherwise we won't.
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < A[i]; i++) ; for (int i = 0; i < A[i]; i++)
Show All 37 Lines

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

; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-detect \ ; RUN: opt %loadPolly -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; CHECK-NOT: Valid ; CHECK-NOT: Valid
; ;
; Do not consider this a SCoP as we do not perform any optimizations for ; Do not consider this a SCoP as we do not perform any optimizations for
; loops with a small trip count. ; loops with a small trip count.
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 4; i++) ; for (int i = 0; i < 4; i++)
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -\ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; CHECK: Valid Region for Scop: bb11 => bb25 ; CHECK: Valid Region for Scop: bb11 => bb25
; Ensure that this test case does not trigger an assertion. At some point, ; Ensure that this test case does not trigger an assertion. At some point,
; we asserted on scops containing accesses where the access function contained ; we asserted on scops containing accesses where the access function contained
; an AddRec expression with a non-constant step expression. This got missed, as ; an AddRec expression with a non-constant step expression. This got missed, as
; this very specific pattern does not seem too common. Even in this test case, ; this very specific pattern does not seem too common. Even in this test case,
; it disappears as soon as we turn the infinite loop into a finite loop. ; it disappears as soon as we turn the infinite loop into a finite loop.
Show All 40 Lines

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

; RUN: opt %loadPolly -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; Verify that we do not model atomic memory accesses. We did not reason about ; Verify that we do not model atomic memory accesses. We did not reason about
; how to handle them correctly and the Alias Set Tracker models some of them ; how to handle them correctly and the Alias Set Tracker models some of them
; only as Unknown Instructions, which we do not know how to handle either.; ; only as Unknown Instructions, which we do not know how to handle either.;
; ;
; CHECK-NOT: Valid ; CHECK-NOT: Valid
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 20 Lines

polly/test/ScopDetect/non_affine_loop_condition.ll

; RUN: opt %loadPolly \ ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \ ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-process-unprofitable=false -polly-print-detect -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: < %s | FileCheck %s
; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect -polly-allow-nonaffine-loops -analyze \
; RUN: < %s | FileCheck %s --check-prefix=PROFIT
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; while (A[i]) ; while (A[i])
; A[i]--; ; A[i]--;
; } ; }
; } ; }
; ;
Show All 40 Lines

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

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

polly/test/ScopDetect/only_func_flag.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-only-func=f,g < %s | FileCheck %s ; RUN: opt %loadPolly -polly-only-func=f,g -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the flag `-polly-only-func` limits analysis to `f` and `g`. ; Check that the flag `-polly-only-func` limits analysis to `f` and `g`.
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
; ;
; CHECK: Function: g ; CHECK: Function: g
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/test/ScopDetect/only_func_flag_regex.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-only-func=f.*,g.* < %s | FileCheck %s ; RUN: opt %loadPolly -polly-only-func=f.*,g.* -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the flag `-polly-only-func` works with regexes. ; Check that the flag `-polly-only-func` works with regexes.
; ;
; CHECK: Function: f1 ; CHECK: Function: f1
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
; ;
; CHECK: Function: f2 ; CHECK: Function: f2
; CHECK-NEXT: Region: %for.cond---%for.end ; CHECK-NEXT: Region: %for.cond---%for.end
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; CHECK-NOT: Valid Region ; CHECK-NOT: Valid Region
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define void @blam(float* %A, float* %B) { define void @blam(float* %A, float* %B) {
bb: bb:
%tmp1 = alloca i64 %tmp1 = alloca i64
Show All 19 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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"
define void @foo(float* %A, i64 %n, i64 %k) { define void @foo(float* %A, i64 %n, i64 %k) {
Show All 17 Lines

polly/test/ScopDetect/phi_with_multi_exiting_edges.ll

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

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

; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: -polly-detect-profitability-min-per-loop-insts=40 \ ; RUN: -polly-detect-profitability-min-per-loop-insts=40 \
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE ; RUN: -polly-print-detect -disable-output < %s | FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=true \ ; RUN: opt %loadPolly -polly-process-unprofitable=true \
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=PROFITABLE ; RUN: -polly-print-detect -disable-output < %s | FileCheck %s -check-prefix=PROFITABLE
; RUN: opt %loadPolly -polly-process-unprofitable=false \ ; RUN: opt %loadPolly -polly-process-unprofitable=false \
; RUN: \ ; RUN: -polly-print-detect -disable-output < %s | FileCheck %s -check-prefix=UNPROFITABLE
; RUN: -polly-detect -analyze < %s | FileCheck %s -check-prefix=UNPROFITABLE
; UNPROFITABLE-NOT: Valid Region for Scop: ; UNPROFITABLE-NOT: Valid Region for Scop:
; PROFITABLE: Valid Region for Scop: ; PROFITABLE: Valid Region for Scop:
; void foo(float *A, float *B, long N) { ; void foo(float *A, float *B, long N) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] += .... / * a lot of compute */ ; A[i] += .... / * a lot of compute */
; } ; }
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/ScopDetect/profitability-two-nested-loops.ll

; RUN: opt %loadPolly -polly-detect -analyze \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; RUN: -polly-process-unprofitable=false < %s | FileCheck %s
; CHECK: Valid Region for Scop: next => bb3 ; CHECK: Valid Region for Scop: next => bb3
; ;
; void foo(float A[], long p) { ; void foo(float A[], long p) {
; for (long x = 0; x < 1024; x++) { ; for (long x = 0; x < 1024; x++) {
; __sync_synchronize(); ; __sync_synchronize();
; if (p >= 0) { ; if (p >= 0) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/test/ScopDetect/remove_all_children.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define void @remove_all_children(i32* %eclass) { define void @remove_all_children(i32* %eclass) {
entry: entry:
br label %while.body br label %while.body
while.cond.loopexit: ; preds = %while.body50, %while.end44 while.cond.loopexit: ; preds = %while.body50, %while.end44
Show All 35 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.bar = type { i32, [4 x i32] } %struct.bar = type { i32, [4 x i32] }
define void @f(%struct.bar* %arg) { define void @f(%struct.bar* %arg) {
bb: bb:
Show All 24 Lines

polly/test/ScopDetect/run_time_alias_check.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
declare float* @getNextBasePtr(float*) readnone nounwind declare float* @getNextBasePtr(float*) readnone nounwind
define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) { define void @base_pointer_is_inst_inside_invariant_1(i64 %n, float* %A, float* %B) {
entry: entry:
br label %for.i br label %for.i
Show All 26 Lines

polly/test/ScopDetect/sequential_loops.ll

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

polly/test/ScopDetect/simple_loop.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 20 Lines

polly/test/ScopDetect/simple_loop_non_single_entry.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 35 Lines

polly/test/ScopDetect/simple_loop_non_single_exit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 24 Lines

polly/test/ScopDetect/simple_loop_non_single_exit_2.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 25 Lines

polly/test/ScopDetect/simple_loop_two_phi_nodes.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 24 Lines

polly/test/ScopDetect/simple_loop_with_param.ll

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

polly/test/ScopDetect/simple_loop_with_param_2.ll

; RUN: opt %loadPolly -basic-aa -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-detect -disable-output < %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 37 Lines

polly/test/ScopDetect/simple_non_single_entry.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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 58 Lines • Show Last 20 Lines

polly/test/ScopDetect/skip_function_attribute.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %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/test/ScopDetect/srem_with_parametric_divisor.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop: ; CHECK-NOT: Valid Region for Scop:
; ;
; void foo(float *A, long n, long p) { ; void foo(float *A, long n, long p) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[n % p] += 1; ; A[n % p] += 1;
; } ; }
; ;
Show All 26 Lines

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | FileCheck %s
; CHECK-NOT: Valid ; CHECK-NOT: Valid
; Verify that we do not detect loops where the loop latch is a switch statement. ; Verify that we do not detect loops where the loop latch is a switch statement.
; Such loops are not yet supported by Polly. ; Such loops are not yet supported by Polly.
define void @f() { define void @f() {
b: b:
Show All 12 Lines

polly/test/ScopDetect/tlr_is_hoistable_load.ll

; RUN: opt %loadPolly -analyze -polly-scops -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting -polly-detect-full-functions -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-detect-full-functions < %s | FileCheck %s
; ;
; This testcase checks for compatibility of the -detect-full-functions ; This testcase checks for compatibility of the -detect-full-functions
; flag in combination with the -invariant-load-hoisting option. More ; flag in combination with the -invariant-load-hoisting option. More
; specifically, ScopHelper.cpp::isHoistableLoad only gets called if ; specifically, ScopHelper.cpp::isHoistableLoad only gets called if
; -invariant-load-hoisting is enabled. This function, however, had a bug ; -invariant-load-hoisting is enabled. This function, however, had a bug
; which caused a crash if the region argument was top-level. This test ; which caused a crash if the region argument was top-level. This test
; is a minimal example that hits this specific code path. ; is a minimal example that hits this specific code path.
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/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-use-runtime-alias-checks=false -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %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 59 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportEntry.ll

; RUN: opt %loadPolly -analyze -polly-detect \ ; RUN: opt %loadPolly -polly-detect -pass-remarks-missed="polly-detect" -disable-output < %s 2>&1| FileCheck %s
; RUN: -pass-remarks-missed="polly-detect" \
; RUN: < %s 2>&1| FileCheck %s
; CHECK: remark: <unknown>:0:0: Scop contains function entry (not yet supported). ; CHECK: remark: <unknown>:0:0: Scop contains function entry (not yet supported).
define void @hoge(i8* %arg) { define void @hoge(i8* %arg) {
bb1: bb1:
br i1 false, label %bb2, label %bb3 br i1 false, label %bb2, label %bb3
bb2: bb2:
Show All 15 Lines

polly/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 -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %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 56 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportIrreducibleRegion.ll

; RUN: opt %loadPolly -analyze -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -pass-remarks-missed="polly-detect" -disable-output < %s 2>&1| FileCheck %s
; RUN: -pass-remarks-missed="polly-detect" \
; RUN: < %s 2>&1| 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"
;void foo(int a, int b) { ;void foo(int a, int b) {
; if(b == 42) { ; if(b == 42) {
; if (a > 0) { ; if (a > 0) {
; LABEL1: ; LABEL1:
; a--; ; a--;
; } ; }
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportIrreducibleRegionWithoutDebugLoc.ll

; RUN: opt %loadPolly -analyze -polly-detect \ ; RUN: opt %loadPolly -polly-detect -pass-remarks-missed="polly-detect" -disable-output < %s 2>&1| FileCheck %s
; RUN: -pass-remarks-missed="polly-detect" \
; RUN: < %s 2>&1| FileCheck %s
; CHECK: remark: <unknown>:0:0: Irreducible region encountered in control flow. ; CHECK: remark: <unknown>:0:0: Irreducible region encountered in control flow.
define void @hoge(i8* %arg) { define void @hoge(i8* %arg) {
bb1: bb1:
br i1 false, label %bb2, label %bb3 br i1 false, label %bb2, label %bb3
bb2: bb2:
Show All 15 Lines

polly/test/ScopDetectionDiagnostics/ReportLoopBound-01.ll

; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -pass-remarks-missed="polly-detect" -polly-detect-track-failures \ ; RUN: -pass-remarks-missed="polly-detect" -polly-detect-track-failures \
; RUN: -polly-allow-nonaffine-loops=false -polly-detect -analyze \ ; RUN: -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output \
; RUN: < %s 2>&1| FileCheck %s --check-prefix=REJECTNONAFFINELOOPS ; RUN: < %s 2>&1| FileCheck %s --check-prefix=REJECTNONAFFINELOOPS
; RUN: opt %loadPolly \ ; RUN: opt %loadPolly \
; RUN: -pass-remarks-missed="polly-detect" -polly-detect-track-failures \ ; RUN: -pass-remarks-missed="polly-detect" -polly-detect-track-failures \
; RUN: -polly-allow-nonaffine-loops=true -polly-detect -analyze \ ; RUN: -polly-allow-nonaffine-loops=true -polly-print-detect -disable-output \
; RUN: < %s 2>&1| FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS ; RUN: < %s 2>&1| FileCheck %s --check-prefix=ALLOWNONAFFINELOOPS
; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \ ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \
; RUN: -polly-process-unprofitable=false \ ; RUN: -polly-process-unprofitable=false \
; RUN: -polly-detect-track-failures -polly-allow-nonaffine-loops=true \ ; RUN: -polly-detect-track-failures -polly-allow-nonaffine-loops=true \
; RUN: -polly-allow-nonaffine -polly-detect -analyze < %s 2>&1 \ ; RUN: -polly-allow-nonaffine -polly-print-detect -disable-output < %s 2>&1 \
; RUN: | FileCheck %s --check-prefix=ALLOWNONAFFINEALL ; RUN: | FileCheck %s --check-prefix=ALLOWNONAFFINEALL
; void f(int A[], int n) { ; void f(int A[], int n) {
; for (int i = 0; i < A[n+i]; i++) ; for (int i = 0; i < A[n+i]; i++)
; A[i] = 0; ; A[i] = 0;
; } ; }
; If we reject non-affine loops the non-affine loop bound will be reported: ; If we reject non-affine loops the non-affine loop bound will be reported:
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportLoopHasNoExit.ll

; XFAIL: * ; XFAIL: *
; The test case stopped making sense after r310940 that added infinite loops to ; The test case stopped making sense after r310940 that added infinite loops to
; the PostDominatorTree. Infinite loops are postdominated ony by the virtual ; the PostDominatorTree. Infinite loops are postdominated ony by the virtual
; root, which causes them not to appear in regions in ScopDetection anymore. ; root, which causes them not to appear in regions in ScopDetection anymore.
; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-allow-nonaffine-loops -analyze -polly-detect < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-allow-nonaffine-loops -polly-print-detect -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-allow-nonaffine-loops=false -analyze -polly-detect < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" -polly-allow-nonaffine-loops=false -polly-print-detect -disable-output < %s 2>&1 | FileCheck %s
; void func (int param0, int N, int *A) ; void func (int param0, int N, int *A)
; { ; {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; if (param0) ; if (param0)
; while (1) ; while (1)
; A[i] = 1; ; A[i] = 1;
; else ; else
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportMultipleNonAffineAccesses.ll

; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s ; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %s 2>&1| FileCheck %s
; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-delinearize=false -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=ALL ; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -polly-delinearize=false -polly-detect-keep-going -disable-output < %s 2>&1| FileCheck %s -check-prefix=ALL
; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN ; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %s 2>&1| FileCheck %s -check-prefix=DELIN
; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-detect -polly-detect-keep-going -analyze < %s 2>&1| FileCheck %s -check-prefix=DELIN-ALL ; RUN: opt %loadPolly -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -polly-detect-keep-going -disable-output < %s 2>&1| FileCheck %s -check-prefix=DELIN-ALL
; RUN: opt %loadPolly -basic-aa -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 -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -polly-allow-nonaffine -disable-output < %s 2>&1| FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -basic-aa -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 -basic-aa -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -polly-allow-nonaffine -disable-output < %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 139 Lines • Show Last 20 Lines

polly/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 -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %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 62 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportUnprofitable.ll

; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \ ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \
; RUN: -polly-detect-track-failures -polly-detect -analyze \ ; RUN: -polly-detect-track-failures -polly-print-detect -disable-output \
; RUN: -polly-process-unprofitable=false < %s 2>&1| FileCheck %s ; RUN: -polly-process-unprofitable=false < %s 2>&1| FileCheck %s
; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \ ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \
; RUN: -polly-detect-track-failures -polly-detect -analyze \ ; RUN: -polly-detect-track-failures -polly-print-detect -disable-output \
; RUN: -polly-process-unprofitable=false < %s 2>&1 -pass-remarks-output=%t.yaml ; RUN: -polly-process-unprofitable=false < %s 2>&1 -pass-remarks-output=%t.yaml
; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s ; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
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 onlyWrite(float *A) { ; void onlyWrite(float *A) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[i] = 0; ; A[i] = 0;
; } ; }
▲ Show 20 Lines • Show All 169 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/ReportUnreachableInExit.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s \
; RUN: -pass-remarks-missed="polly-detect" 2>&1 | FileCheck %s ; RUN: -pass-remarks-missed="polly-detect" 2>&1 | 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;
; unreachable() ; unreachable()
; } ; }
Show All 22 Lines

polly/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 -pass-remarks-missed="polly-detect" -polly-detect-track-failures -polly-print-detect -disable-output < %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[i].b[i] = 0; ; A[i].b[i] = 0;
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

polly/test/ScopDetectionDiagnostics/loop_partially_in_scop-2.ll

; RUN: opt %loadPolly -analyze -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -pass-remarks-missed="polly-detect" -disable-output < %s 2>&1| FileCheck %s
; RUN: -pass-remarks-missed="polly-detect" \
; RUN: < %s 2>&1| FileCheck %s
; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region. ; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region.
define void @foo(i8* %str0) { define void @foo(i8* %str0) {
if.end32: if.end32:
br label %while.cond br label %while.cond
while.cond: while.cond:
Show All 13 Lines

polly/test/ScopDetectionDiagnostics/loop_partially_in_scop.ll

; RUN: opt %loadPolly -analyze -polly-detect \ ; RUN: opt %loadPolly -polly-print-detect -pass-remarks-missed="polly-detect" -disable-output < %s 2>&1| FileCheck %s
; RUN: -pass-remarks-missed="polly-detect" \
; RUN: < %s 2>&1| FileCheck %s
; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region. ; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region.
; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region. ; CHECK: remark: <unknown>:0:0: Loop cannot be handled because not all latches are part of loop region.
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 @baz(i32 %before) { define void @baz(i32 %before) {
Show All 23 Lines

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

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

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
declare void @foo() declare void @foo()
define i32 @main(i8* %A) nounwind uwtable { define i32 @main(i8* %A) nounwind uwtable {
entry: entry:
br label %for.cond br label %for.cond
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/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-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32" target datalayout = "e-p:32:32:32-i64:64:64-i32:32:32-i16:16:16-i1:32:32-f64:64:64-f32:32:32-a0:0-n32"
@array = external global [64 x i8], align 8 @array = external global [64 x i8], align 8
define void @foo(i32* %A) nounwind { define void @foo(i32* %A) nounwind {
entry: entry:
br label %if.then132 br label %if.then132
Show All 22 Lines

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

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -disable-output < %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @kernel_reg_detect([6 x i32]* %path) { define void @kernel_reg_detect([6 x i32]* %path) {
entry: entry:
br label %for.body.6 br label %for.body.6
Show All 23 Lines

polly/test/ScopInfo/Alias-0.ll

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

polly/test/ScopInfo/Alias-1.ll

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

polly/test/ScopInfo/Alias-2.ll

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

polly/test/ScopInfo/Alias-3.ll

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

polly/test/ScopInfo/Alias-4.ll

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

polly/test/ScopInfo/BoundChecks/single-loop.ll

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

polly/test/ScopInfo/BoundChecks/two-loops.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output< %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; This only works after the post-dominator tree has fixed. ; This only works after the post-dominator tree has fixed.
; XFAIL: * ; XFAIL: *
; ;
; void exception() __attribute__((noreturn)); ; void exception() __attribute__((noreturn));
; ;
; void foo(long n, float A[100]) { ; void foo(long n, float A[100]) {
; for (long j = 0; j < n; j++) { ; for (long j = 0; j < n; j++) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/div_backedge.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 1;; i++) { ; for (long i = 1;; i++) {
; A[i] += 1; ; A[i] += 1;
; if (i / 7 == 4) ; if (i / 7 == 4)
; break; ; break;
; } ; }
; } ; }
Show All 33 Lines

polly/test/ScopInfo/NonAffine/div_domain.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 0; i < 16; i++) { ; for (long i = 0; i < 16; i++) {
; A[i] += 1; ; A[i] += 1;
; if (i / 2 == 3) ; if (i / 2 == 3)
; A[i] += 2; ; A[i] += 2;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/invariant_loads_dependent_in_non_affine_region.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(int *A, int *B, int *C) { ; void f(int *A, int *B, int *C) {
; for (int i = 0; i < 1000; i++) ; for (int i = 0; i < 1000; i++)
; if (A[i] == *B) ; if (A[i] == *B)
; A[i] = *C; ; A[i] = *C;
; } ; }
; ;
; Check that only the access to *B is hoisted but not the one to *C. ; Check that only the access to *B is hoisted but not the one to *C.
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/modulo_backedge.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 6 }; ; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 6 };
; ;
; void foo(float *A) { ; void foo(float *A) {
; for (long i = 1;; i++) { ; for (long i = 1;; i++) {
; A[i] += 1; ; A[i] += 1;
; if (i % 7 == 0) ; if (i % 7 == 0)
Show All 33 Lines

polly/test/ScopInfo/NonAffine/modulo_domain.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; TODO: The new domain generation cannot handle modulo domain constraints, ; TODO: The new domain generation cannot handle modulo domain constraints,
; hence modulo handling has been disabled completely. Once this is ; hence modulo handling has been disabled completely. Once this is
; resolved this test should work again. Until then we approximate the ; resolved this test should work again. Until then we approximate the
; whole loop body. ; whole loop body.
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 15 }; ; CHECK: { Stmt_for_body[i0] : 0 <= i0 <= 15 };
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basic-aa -polly-scops \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCALAR
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-process-unprofitable=false -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=PROFIT
; RUN: -polly-allow-nonaffine-loops=true -analyze < %s | FileCheck %s \
; RUN: -check-prefix=SCALAR
; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine \
; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s -check-prefix=PROFIT
; ;
; SCALAR: Function: f ; SCALAR: Function: f
; SCALAR-NEXT: Region: %bb1---%bb13 ; SCALAR-NEXT: Region: %bb1---%bb13
; SCALAR-NEXT: Max Loop Depth: 1 ; SCALAR-NEXT: Max Loop Depth: 1
; SCALAR-NEXT: Invariant Accesses: { ; SCALAR-NEXT: Invariant Accesses: {
; SCALAR-NEXT: } ; SCALAR-NEXT: }
; SCALAR-NEXT: Context: ; SCALAR-NEXT: Context:
; SCALAR-NEXT: { : } ; SCALAR-NEXT: { : }
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=ALL
; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s \
; RUN: --check-prefix=ALL
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always model the ; and also a non-affine access (A[k]). While we can always model the
; innermost loop as a SCoP of depth 1, we can overapproximate the ; innermost loop as a SCoP of depth 1, we can overapproximate the
; innermost loop in the whole loop nest and model A[k] as a non-affine ; innermost loop in the whole loop nest and model A[k] as a non-affine
; access. ; access.
; ;
; INNERMOST: Function: f ; INNERMOST: Function: f
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=false -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: -polly-allow-nonaffine-loops=false \ ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=ALL
; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -basic-aa -polly-scops -polly-allow-nonaffine \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALL
; ;
; Here we have a non-affine loop (in the context of the loop nest) ; Here we have a non-affine loop (in the context of the loop nest)
; and also a non-affine access (A[k]). While we can always model the ; and also a non-affine access (A[k]). While we can always model the
; innermost loop as a SCoP of depth 1, we can overapproximate the ; innermost loop as a SCoP of depth 1, we can overapproximate the
; innermost loop in the whole loop nest and model A[k] as a non-affine ; innermost loop in the whole loop nest and model A[k] as a non-affine
; access. ; access.
; ;
; INNERMOST: Function: f ; INNERMOST: Function: f
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_access_with_range_2.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 128; i++) ; for (int i = 0; i < 128; i++)
; for (int j = 0; j < 16; j++) ; for (int j = 0; j < 16; j++)
; A[i * j]++; ; A[i * j]++;
; } ; }
; ;
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_but_sdiv.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : 0 <= i0 < N }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] : 0 <= i0 < N };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0] }; ; CHECK-NEXT: [N] -> { Stmt_for_body[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_but_srem.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; void pos(float *A, long n) { ; void pos(float *A, long n) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; A[n % 42] += 1; ; A[n % 42] += 1;
; } ; }
; ;
; ;
; void neg(float *A, long n) { ; void neg(float *A, long n) {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_conditional_nested.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i]) ; if (A[i])
; if (A[i - 1]) ; if (A[i - 1])
; A[i] = A[i - 2]; ; A[i] = A[i - 2];
; } ; }
; ;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_conditional_surrounding_affine_loop.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s \ ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s \
; RUN: --check-prefix=ALL ; RUN: --check-prefix=ALL
; ;
; Negative test for INNERMOST. ; Negative test for INNERMOST.
; At the moment we will optimistically assume A[i] in the conditional before the inner ; At the moment we will optimistically assume A[i] in the conditional before the inner
; loop might be invariant and expand the SCoP from the loop to include the conditional. However, ; loop might be invariant and expand the SCoP from the loop to include the conditional. However,
; during SCoP generation we will realize that A[i] is in not always invariant. ; during SCoP generation we will realize that A[i] is in not always invariant.
; ;
; Possible solutions could be: ; Possible solutions could be:
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_conditional_surrounding_non_affine_loop.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=INNERMOST ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=INNERMOST
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=ALL ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=ALL
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \ ; RUN: opt %loadPolly -polly-allow-nonaffine \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -polly-process-unprofitable=false \ ; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \ ; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops=true \
; RUN: -analyze < %s | FileCheck %s --check-prefix=PROFIT ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; ;
; Negative test for INNERMOST. ; Negative test for INNERMOST.
; At the moment we will optimistically assume A[i] in the conditional before the inner ; At the moment we will optimistically assume A[i] in the conditional before the inner
; loop might be invariant and expand the SCoP from the loop to include the conditional. However, ; loop might be invariant and expand the SCoP from the loop to include the conditional. However,
; during SCoP generation we will realize that A[i] is only sometimes invariant. ; during SCoP generation we will realize that A[i] is only sometimes invariant.
; ;
; Possible solutions could be: ; Possible solutions could be:
; - Do not optimistically assume it to be invariant (as before this commit), however we would loose ; - Do not optimistically assume it to be invariant (as before this commit), however we would loose
▲ Show 20 Lines • Show All 143 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_float_compare.ll

; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; void f(float *A) { ; void f(float *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (A[i] == A[i - 1]) ; if (A[i] == A[i - 1])
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Function: f ; CHECK: Function: f
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_loop_condition.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \ ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops -polly-process-unprofitable=false -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops -polly-detect-reductions=false -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=NO-REDUCTION
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine-branches \
; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s \
; RUN: --check-prefix=PROFIT
; RUN: opt %loadPolly -polly-scops -polly-detect-reductions \
; RUN: -polly-allow-nonaffine-branches \
; RUN: \
; RUN: -polly-allow-nonaffine-loops -analyze < %s \
; RUN: -polly-detect-reductions=false \
; RUN: | FileCheck %s -check-prefix=NO-REDUCTION
; ;
; void f(int *A, int *C) { ; void f(int *A, int *C) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; while (C[i]) ; while (C[i])
; A[i]++; ; A[i]++;
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_loop_used_later.ll

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-allow-nonaffine -polly-allow-nonaffine-branches \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops -polly-unprofitable-scalar-accs=true -polly-process-unprofitable=false -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=PROFIT
; RUN: -polly-allow-nonaffine-loops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine \
; RUN: -polly-unprofitable-scalar-accs=true \
; RUN: -polly-process-unprofitable=false \
; RUN: -polly-allow-nonaffine-branches -polly-allow-nonaffine-loops \
; RUN: -analyze < %s | FileCheck %s --check-prefix=PROFIT
; ;
; Verify that we over approximate the read acces of A[j] in the last statement as j is ; Verify that we over approximate the read acces of A[j] in the last statement as j is
; computed in a non-affine loop we do not model. ; computed in a non-affine loop we do not model.
; ;
; CHECK: Function: f ; CHECK: Function: f
; CHECK-NEXT: Region: %bb2---%bb24 ; CHECK-NEXT: Region: %bb2---%bb24
; CHECK-NEXT: Max Loop Depth: 1 ; CHECK-NEXT: Max Loop Depth: 1
; CHECK-NEXT: Invariant Accesses: { ; CHECK-NEXT: Invariant Accesses: {
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

polly/test/ScopInfo/NonAffine/non_affine_parametric_loop.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze -polly-allow-nonaffine < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-allow-nonaffine -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, double A[], int INDEX[]) { ; void foo(long n, double A[], int INDEX[]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[INDEX[i]] = i; ; A[INDEX[i]] = i;
; } ; }
define void @foo(i64 %n, double* noalias %A, i64* noalias %INDEX) { define void @foo(i64 %n, double* noalias %A, i64* noalias %INDEX) {
Show All 30 Lines

polly/test/ScopInfo/NonAffine/non_affine_region_guaranteed_non-entry.ll

; RUN: opt %loadPolly -polly-detect -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-detect -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-allow-nonaffine-loops < %s | FileCheck %s
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; The BasicBlock "guaranteed" is always executed inside the non-affine subregion ; The BasicBlock "guaranteed" is always executed inside the non-affine subregion
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
; ;
; Regression test that triggered a memory leak at some point (24947). ; Regression test that triggered a memory leak at some point (24947).
; ;
define void @snrm2() { define void @snrm2() {
entry: entry:
br label %for.body.56.lr.ph br label %for.body.56.lr.ph
for.body.56.lr.ph: ; preds = %entry for.body.56.lr.ph: ; preds = %entry
Show All 21 Lines

polly/test/ScopInfo/aliasing_conditional_alias_groups_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/aliasing_conditional_alias_groups_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/aliasing_dead_access.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that we do not create a SCoP if there is no statement executed. ; Check that we do not create a SCoP if there is no statement executed.
; ;
; CHECK-NOT: Context ; CHECK-NOT: Context
; ;
; void jd(int *A, int *B) { ; void jd(int *A, int *B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; 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/test/ScopInfo/aliasing_many_arrays_to_compare.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: < %s | FileCheck %s --check-prefix=FOUND ; RUN: < %s | FileCheck %s --check-prefix=FOUND
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-rtc-max-arrays-per-group=3 < %s | FileCheck %s \ ; RUN: -polly-rtc-max-arrays-per-group=3 < %s | FileCheck %s \
; RUN: --check-prefix=IGNORED ; RUN: --check-prefix=IGNORED
; ;
; FOUND: Function: foo ; FOUND: Function: foo
; IGNORED-NOT: Function: foo ; IGNORED-NOT: Function: foo
; ;
; void foo(float *A, float *B, float *C, float *D) { ; void foo(float *A, float *B, float *C, float *D) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-scops -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=8 -disable-output < %s | FileCheck %s --check-prefix=MAX8
; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-scops -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7 ; RUN: opt %loadPolly -polly-analysis-computeout=0 -polly-print-scops -polly-rtc-max-parameters=7 -disable-output < %s | FileCheck %s --check-prefix=MAX7
; ;
; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses. ; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A. ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
; ;
; MAX8-LABEL: Function: jd ; MAX8-LABEL: Function: jd
; MAX8-NEXT: Region: %for.cond---%for.end ; MAX8-NEXT: Region: %for.cond---%for.end
; MAX7: Invalid Scop! ; MAX7: Invalid Scop!
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

polly/test/ScopInfo/aliasing_many_read_only_acesses.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; ;
; Make sure the large number of read-only accesses does not cause make us ; Make sure the large number of read-only accesses does not cause make us
; invalidate the scop. ; invalidate the scop.
; ;
; void many_read_only_accesses(float A[], float B[]) { ; void many_read_only_accesses(float A[], float B[]) {
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

polly/test/ScopInfo/aliasing_multiple_alias_groups.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=NOAA ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=NOAA
; RUN: opt %loadPolly -polly-scops -analyze -tbaa < %s | FileCheck %s --check-prefix=TBAA ; RUN: opt %loadPolly -polly-print-scops -disable-output -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/test/ScopInfo/aliasing_with_non_affine_access.ll

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

polly/test/ScopInfo/allow-all-parameters-dereferencable.ll

; RUN: opt %loadPolly -analyze -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -disable-output -polly-invariant-load-hoisting \
; RUN: -polly-allow-dereference-of-all-function-parameters \ ; RUN: -polly-allow-dereference-of-all-function-parameters \
; RUN: -polly-scops < %s | FileCheck %s --check-prefix=SCOP ; RUN: -polly-print-scops < %s | FileCheck %s --check-prefix=SCOP
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -S -polly-invariant-load-hoisting \
; RUN: -polly-codegen < %s | FileCheck %s --check-prefix=CODE-RTC ; RUN: -polly-codegen < %s | FileCheck %s --check-prefix=CODE-RTC
; RUN: opt %loadPolly -S -polly-invariant-load-hoisting \ ; RUN: opt %loadPolly -S -polly-invariant-load-hoisting \
; RUN: -polly-allow-dereference-of-all-function-parameters \ ; RUN: -polly-allow-dereference-of-all-function-parameters \
; RUN: -polly-codegen < %s | FileCheck %s --check-prefix=CODE ; RUN: -polly-codegen < %s | FileCheck %s --check-prefix=CODE
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

polly/test/ScopInfo/assume_gep_bounds.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %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 71 Lines • Show Last 20 Lines

polly/test/ScopInfo/assume_gep_bounds_2.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %s \
; RUN: -polly-precise-inbounds | FileCheck %s ; RUN: -polly-precise-inbounds | FileCheck %s
; ;
; void foo(float A[restrict][20], float B[restrict][20], long n, long m, ; void foo(float A[restrict][20], float B[restrict][20], long n, long m,
; long p) { ; long p) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; A[i][j] = i + j; ; A[i][j] = i + j;
; for (long i = 0; i < m; i++) ; for (long i = 0; i < m; i++)
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

polly/test/ScopInfo/assume_gep_bounds_many.ll

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

polly/test/ScopInfo/avoid_new_parameters_from_geps.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that we do no introduce a parameter here that is actually not needed. ; Check that we do no introduce a parameter here that is actually not needed.
; ;
; CHECK: Region: %for.body58---%land.lhs.true ; CHECK: Region: %for.body58---%land.lhs.true
; CHECK-NEXT: Max Loop Depth: 0 ; CHECK-NEXT: Max Loop Depth: 0
; CHECK-NEXT: Invariant Accesses: { ; CHECK-NEXT: Invariant Accesses: {
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: Context: ; CHECK-NEXT: Context:
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScopInfo/bool-addrec.ll

; RUN: opt %loadPolly -analyze -polly-ast -polly-process-unprofitable < %s | FileCheck %s ; RUN: opt %loadPolly -disable-output -polly-print-ast -polly-process-unprofitable < %s | FileCheck %s
; CHECK: for (int c0 = 0; c0 <= 19999; c0 += 1) { ; CHECK: for (int c0 = 0; c0 <= 19999; c0 += 1) {
; CHECK-NEXT: if (c0 % 2 == 0) ; CHECK-NEXT: if (c0 % 2 == 0)
; CHECK-NEXT: Stmt_if_then(c0); ; CHECK-NEXT: Stmt_if_then(c0);
; CHECK-NEXT: Stmt_if_end(c0); ; CHECK-NEXT: Stmt_if_end(c0);
; CHECK-NEXT: if (c0 % 2 == 0) ; CHECK-NEXT: if (c0 % 2 == 0)
; CHECK-NEXT: Stmt_if_then5(c0); ; CHECK-NEXT: Stmt_if_then5(c0);
; CHECK-NEXT: } ; CHECK-NEXT: }
Show All 40 Lines

polly/test/ScopInfo/bounded_loop_assumptions.ll

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

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

; RUN: opt %loadPolly -polly-detect -analyze < %s | \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s | \
; RUN: FileCheck %s -check-prefix=DETECT ; RUN: FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | \
; RUN: FileCheck %s -check-prefix=SCOP ; RUN: FileCheck %s -check-prefix=SCOP
; DETECT: Valid Region for Scop: loop => barrier ; DETECT: Valid Region for Scop: loop => barrier
; DETECT-NEXT: Valid Region for Scop: branch => end ; DETECT-NEXT: Valid Region for Scop: branch => end
; SCOP: Statements { ; SCOP: Statements {
; SCOP-NEXT: Stmt_then ; SCOP-NEXT: Stmt_then
; SCOP-NEXT: Domain := ; SCOP-NEXT: Domain :=
Show All 35 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | \
; RUN: FileCheck %s -check-prefix=NONAFFINE ; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output \
; RUN: -polly-allow-nonaffine-branches=false < %s | \ ; RUN: -polly-allow-nonaffine-branches=false < %s | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE ; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
; NONAFFINE: Statements { ; NONAFFINE: Statements {
; NONAFFINE-NEXT: Stmt_loop ; NONAFFINE-NEXT: Stmt_loop
; NONAFFINE-NEXT: Domain := ; NONAFFINE-NEXT: Domain :=
; NONAFFINE-NEXT: [p] -> { Stmt_loop[0] : p = 100 }; ; NONAFFINE-NEXT: [p] -> { Stmt_loop[0] : p = 100 };
; NONAFFINE-NEXT: Schedule := ; NONAFFINE-NEXT: Schedule :=
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | \
; RUN: FileCheck %s -check-prefix=NONAFFINE ; RUN: FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-allow-nonaffine-branches=false < %s | \ ; RUN: -polly-allow-nonaffine-branches=false < %s | \
; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE ; RUN: FileCheck %s -check-prefix=NO-NONEAFFINE
; NONAFFINE-NOT: Statements ; NONAFFINE-NOT: Statements
; NO-NONEAFFINE: Statements { ; NO-NONEAFFINE: Statements {
; NO-NONEAFFINE-NEXT: Stmt_then ; NO-NONEAFFINE-NEXT: Stmt_then
; NO-NONEAFFINE-NEXT: Domain := ; NO-NONEAFFINE-NEXT: Domain :=
Show All 39 Lines

polly/test/ScopInfo/bug_2010_10_22.ll

; RUN: opt %loadPolly -polly-scops < %s ; RUN: opt %loadPolly -polly-scops -disable-output < %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
define fastcc void @_Z8wavModelR5Mixer() { define fastcc void @_Z8wavModelR5Mixer() {
entry: entry:
br label %bb230 br label %bb230
bb230: ; preds = %bb233, %bb.nph433 bb230: ; preds = %bb233, %bb.nph433
Show All 36 Lines

polly/test/ScopInfo/bug_2011_1_5.ll

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

polly/test/ScopInfo/bug_scev_not_fully_eval.ll

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

polly/test/ScopInfo/cfg_consequences.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void consequences(int *A, int bool_cond, int lhs, int rhs) { ; void consequences(int *A, int bool_cond, int lhs, int rhs) {
; ;
; BC: *A = 0; ; BC: *A = 0;
; if (bool_cond) ; if (bool_cond)
; S_BC: *A = 0; ; S_BC: *A = 0;
; M_BC: *A = 0; ; M_BC: *A = 0;
; ;
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

polly/test/ScopInfo/complex-branch-structure.ll

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

polly/test/ScopInfo/complex-condition.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
; ;
; The IR is a modified version of the following C: ; The IR is a modified version of the following C:
; ;
; void f(int *A) { ; void f(int *A) {
; Begin: ; Begin:
; if (A[0] == 1 | A[1] == 1 | A[2] == 1 | A[3] == 1 | A[4] == 1 | A[5] == 1 | ; if (A[0] == 1 | A[1] == 1 | A[2] == 1 | A[3] == 1 | A[4] == 1 | A[5] == 1 |
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

polly/test/ScopInfo/complex-expression.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; ;
; This test case has an SCEVSMax expression with a very high arity. The ; This test case has an SCEVSMax expression with a very high arity. The
; piecewise affine function we would create for it would have a huge amount of ; piecewise affine function we would create for it would have a huge amount of
; conjuncts, thus it would take a lot of time creating and handling it. ; conjuncts, thus it would take a lot of time creating and handling it.
; ;
; This ensures we bail out for really complex expressions: ; This ensures we bail out for really complex expressions:
; ;
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; We build a scop for the region for.body->B13. The CFG is of the following ; We build a scop for the region for.body->B13. The CFG is of the following
; form and the branch conditions are build from "smax" SCEVs. However, in ; form and the branch conditions are build from "smax" SCEVs. However, in
; contrast to complex-success-structure.ll the smax constraints do not grow ; contrast to complex-success-structure.ll the smax constraints do not grow
; anymore after B3. This will keep the condition construction bounded. ; anymore after B3. This will keep the condition construction bounded.
; Since we propagate the domains from one B(X) to the B(X+1) we can also keep ; Since we propagate the domains from one B(X) to the B(X+1) we can also keep
; the domains simple. We will bail anyway due to invalid required invariant ; the domains simple. We will bail anyway due to invalid required invariant
; loads. ; loads.
▲ Show 20 Lines • Show All 528 Lines • Show Last 20 Lines

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

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

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

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; We build a scop from the region for.body->B13. The CFG is of the ; We build a scop from the region for.body->B13. The CFG is of the
; following form. The test checks that the condition construction does not take ; following form. The test checks that the condition construction does not take
; a huge amount of time. While we can propagate the domain constraints from ; a huge amount of time. While we can propagate the domain constraints from
; B(X) to B(X+1) the conditions in B(X+1) will exponentially grow the number ; B(X) to B(X+1) the conditions in B(X+1) will exponentially grow the number
; of needed constraints (it is basically the condition of B(X) + one smax), ; of needed constraints (it is basically the condition of B(X) + one smax),
; thus we should bail out at some point. ; thus we should bail out at some point.
; ;
▲ Show 20 Lines • Show All 527 Lines • Show Last 20 Lines

polly/test/ScopInfo/complex_domain_binary_condition.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.bc_struct.0.2.4.6.13.20.27.43.44.46.50.52.58.60.81.89.90.99.107.108.109.111.116.118.149 = type { i32, i32, i32, i32, [1024 x i8] } %struct.bc_struct.0.2.4.6.13.20.27.43.44.46.50.52.58.60.81.89.90.99.107.108.109.111.116.118.149 = type { i32, i32, i32, i32, [1024 x i8] }
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScopInfo/complex_execution_context.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \ ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; ;
; CHECK: Low complexity assumption: ; CHECK: Low complexity assumption:
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@board = external global [421 x i8], align 16 @board = external global [421 x i8], align 16
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
Show All 37 Lines

polly/test/ScopInfo/cond_constant_in_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 All 40 Lines

polly/test/ScopInfo/cond_in_loop.ll

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

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

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

polly/test/ScopInfo/condition-after-error-block-before-scop.ll

; RUN: opt %loadPolly -polly-scops -polly-codegen -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%class.node = type { i32 (...)**, %class.node* } %class.node = type { i32 (...)**, %class.node* }
define void @foobar(double* %A) { define void @foobar(double* %A) {
if.end: if.end:
Show All 39 Lines

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

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

polly/test/ScopInfo/const_srem_sdiv.ll

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

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

; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; At some point this caused a problem in the domain generation as we ; At some point this caused a problem in the domain generation as we
; assumed any constant branch condition to be valid. However, only constant ; assumed any constant branch condition to be valid. However, only constant
; integers are interesting and can be handled. ; integers are interesting and can be handled.
; ;
; CHECK: Stmt_entry_split__TO__cleanup ; CHECK: Stmt_entry_split__TO__cleanup
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 18 Lines

polly/test/ScopInfo/constant_factor_in_parameter.ll

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

polly/test/ScopInfo/constant_functions_outside_scop_as_unknown.ll

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

polly/test/ScopInfo/constant_start_integer.ll

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

polly/test/ScopInfo/debug_call.ll

; RUN: opt %loadPolly -polly-debug-func=dbg_printf -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-debug-func=dbg_printf -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Check that the call to dbg_printf is accepted as a debug-function. ; Check that the call to dbg_printf is accepted as a debug-function.
; ;
declare void @dbg_printf(i8*, ...) declare void @dbg_printf(i8*, ...)
define void @func(i32 %n) { define void @func(i32 %n) {
entry: entry:
br label %for br label %for
Show All 28 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; for (long i = 0; i < n-3; i++) ; for (long i = 0; i < n-3; i++)
; for (long j = 4; j < m; j++) ; for (long j = 4; j < m; j++)
; for (long k = 0; k < o-7; k++) { ; for (long k = 0; k < o-7; k++) {
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
; A[i][0][k] = 2.0; ; A[i][0][k] = 2.0;
; } ; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/test/ScopInfo/div_by_zero.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i / 0]++; ; A[i / 0]++;
; } ; }
; ;
; CHECK-NOT: Statement ; CHECK-NOT: Statement
; ;
Show All 27 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
; Check that we do not crash on this input. Earlier this indeed crashed as ; Check that we do not crash on this input. Earlier this indeed crashed as
; we tried to model the access functions in an error block. ; we tried to model the access functions in an error block.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @FORMAT3_4() #0 { define void @FORMAT3_4() #0 {
Show All 24 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output< %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %s
; ;
; void or(float *A, long n, long m) { ; void or(float *A, long n, long m) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; if (i < n || i < m) ; if (i < n || i < m)
; A[i] += i; ; A[i] += i;
; } ; }
; } ; }
; ;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

polly/test/ScopInfo/error-blocks-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 } ; CHECK-NEXT: [N] -> { : -2147483648 <= N <= 2147483647 }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 514 } ; CHECK-NEXT: [N] -> { : N >= 514 }
; ;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

polly/test/ScopInfo/error-blocks-2.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, valid_val] -> { Stmt_for_body[i0] -> MemRef_valid[0] }; ; CHECK-NEXT: [N, valid_val] -> { Stmt_for_body[i0] -> MemRef_valid[0] };
; CHECK-NEXT: Execution Context: [N, valid_val] -> { : N > 0 } ; CHECK-NEXT: Execution Context: [N, valid_val] -> { : N > 0 }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N, valid_val] -> { Stmt_S[i0] -> MemRef_ptr_addr[0] }; ; CHECK-NEXT: [N, valid_val] -> { Stmt_S[i0] -> MemRef_ptr_addr[0] };
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/ScopInfo/error-blocks-3.ll

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

polly/test/ScopInfo/escaping_empty_scop.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %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/test/ScopInfo/exit-phi-1.ll

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

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that there is no MK_ExitPHI READ access. ; Check that there is no MK_ExitPHI READ access.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @local_book_besterror() { define void @local_book_besterror() {
entry: entry:
%0 = load i64, i64* undef, align 8 %0 = load i64, i64* undef, align 8
Show All 33 Lines

polly/test/ScopInfo/exit_phi_accesses-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_body ; CHECK-NEXT: Stmt_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_body[i0] : 0 <= i0 <= 100 }; ; CHECK-NEXT: { Stmt_body[i0] : 0 <= i0 <= 100 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
Show All 39 Lines

polly/test/ScopInfo/exit_phi_accesses.ll

; RUN: opt %loadPolly -analyze -polly-scops %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; Check that PHI nodes only create PHI access and nothing else (e.g. unnecessary ; Check that PHI nodes only create PHI access and nothing else (e.g. unnecessary
; SCALAR accesses). In this case, for a PHI in the exit node, hence there is no ; SCALAR accesses). In this case, for a PHI in the exit node, hence there is no
; PHI ReadAccess. ; PHI ReadAccess.
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
; ;
; CHECK: Statements { ; CHECK: Statements {
Show All 36 Lines

polly/test/ScopInfo/expensive-boundary-context.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK-NOT: Assumed Context: ; CHECK-NOT: Assumed Context:
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.hoge = type { i32, %struct.widget*, %struct.ham*, %struct.ham*, i32, %struct.wombat*, double*, i32, i32, i32**, i32, i32*, [6 x i32], i32, %struct.foo*, i32 } %struct.hoge = type { i32, %struct.widget*, %struct.ham*, %struct.ham*, i32, %struct.wombat*, double*, i32, i32, i32**, i32, i32*, [6 x i32], i32, %struct.foo*, i32 }
%struct.widget = type { i32, i32, %struct.wombat*, i32*, %struct.quux*, i32, %struct.barney*, i32, i32, [3 x i32], i32 } %struct.widget = type { i32, i32, %struct.wombat*, i32*, %struct.quux*, i32, %struct.barney*, i32, i32, [3 x i32], i32 }
%struct.quux = type { %struct.wombat*, i32*, i32*, i32, i32, i32, [3 x [3 x [3 x %struct.hoge.0*]]]* } %struct.quux = type { %struct.wombat*, i32*, i32*, i32, i32, i32, [3 x [3 x [3 x %struct.hoge.0*]]]* }
▲ Show 20 Lines • Show All 291 Lines • Show Last 20 Lines

polly/test/ScopInfo/extract_constant_factor_introduces_new_parameter.ll

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

polly/test/ScopInfo/full-function.ll

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

polly/test/ScopInfo/granularity_same_name.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-use-llvm-names=0 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=IDX ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-use-llvm-names=0 -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines -check-prefix=IDX
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-use-llvm-names=1 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=BB ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-use-llvm-names=1 -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines -check-prefix=BB
; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=0 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=IDX ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=0 -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines -check-prefix=IDX
; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=1 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=BB ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=1 -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines -check-prefix=BB
; ;
; Check that the statement has the same name, regardless of how the ; Check that the statement has the same name, regardless of how the
; basic block is split into multiple statements. ; basic block is split into multiple statements.
; Note that %unrelatedA and %unrelatedB can be put into separate ; Note that %unrelatedA and %unrelatedB can be put into separate
; statements, but are removed because those have no side-effects. ; statements, but are removed because those have no side-effects.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
Show All 37 Lines

polly/test/ScopInfo/granularity_scalar-indep.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Split a block into two independent statements that share no scalar. ; Split a block into two independent statements that share no scalar.
; This case has the instructions of the two statements interleaved, such that ; This case has the instructions of the two statements interleaved, such that
; splitting the BasicBlock in the middle would cause a scalar dependency. ; splitting the BasicBlock in the middle would cause a scalar dependency.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; double valA = A[0]; ; double valA = A[0];
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_cross-referencing-phi1.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Two PHIs, cross-referencing each other. The PHI READs must be carried-out ; Two PHIs, cross-referencing each other. The PHI READs must be carried-out
; before the PHI WRITEs to ensure that the value when entering the block is ; before the PHI WRITEs to ensure that the value when entering the block is
; read. ; read.
; This means that either both PHIs have to be in the same statement, or the ; This means that either both PHIs have to be in the same statement, or the
; PHI WRITEs located in a statement after the PHIs. ; PHI WRITEs located in a statement after the PHIs.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_cross-referencing-phi2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Two PHIs, cross-referencing each other. The PHI READs must be carried-out ; Two PHIs, cross-referencing each other. The PHI READs must be carried-out
; before the PHI WRITEs to ensure that the value when entering the block is ; before the PHI WRITEs to ensure that the value when entering the block is
; read. ; read.
; This means that either both PHIs have to be in the same statement, or the ; This means that either both PHIs have to be in the same statement, or the
; PHI WRITEs located in a statement after the PHIs. ; PHI WRITEs located in a statement after the PHIs.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_epilogue.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Split a block into two independent statements that share no scalar. ; Split a block into two independent statements that share no scalar.
; This case has an independent statement just for PHI writes. ; This case has an independent statement just for PHI writes.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double valA = A[0]; ; double valA = A[0];
; A[0] = valA; ; A[0] = valA;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_epilogue_last.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Check that the PHI Write of value that is defined in the same basic ; Check that the PHI Write of value that is defined in the same basic
; block is in the statement where it is defined. ; block is in the statement where it is defined.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double valA = A[0]; ; double valA = A[0];
; A[0] = valA; ; A[0] = valA;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_noepilogue.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; This case has no explicit epilogue for PHI writes because it would ; This case has no explicit epilogue for PHI writes because it would
; have a scalar dependency to the previous statement. ; have a scalar dependency to the previous statement.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double valA = A[0]; ; double valA = A[0];
; A[0] = valA; ; A[0] = valA;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_ordered-2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; This case should be split into two statements because {X[0], Y[0]} ; This case should be split into two statements because {X[0], Y[0]}
; and {A[0], B[0]} do not intersect. ; and {A[0], B[0]} do not intersect.
; ;
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; double valX = X[0]; ; double valX = X[0];
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/ScopInfo/granularity_scalar-indep_ordered.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; ;
; This case cannot be split into two statements because the order of ; This case cannot be split into two statements because the order of
; loads and store would be violated. ; loads and store would be violated.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; double valA = A[0]; ; double valA = A[0];
; double valB = B[0]; ; double valB = B[0];
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ScopInfo/i1_params.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that both a signed as well as an unsigned extended i1 parameter ; Check that both a signed as well as an unsigned extended i1 parameter
; is represented correctly. ; is represented correctly.
; ;
; void f(signed i1 p0, unsigned i1 p1, int *A) { ; void f(signed i1 p0, unsigned i1 p1, int *A) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; A[i + p0] = A[i + p1]; ; A[i + p0] = A[i + p1];
; } ; }
Show All 38 Lines

polly/test/ScopInfo/infeasible-rtc.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s \
; RUN: | FileCheck %s -check-prefix=DETECT ; RUN: | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: | FileCheck %s -check-prefix=SCOPS ; RUN: | FileCheck %s -check-prefix=SCOPS
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; DETECT: Valid Region for Scop: test1.header => test1.exit ; DETECT: Valid Region for Scop: test1.header => test1.exit
; SCOPS-NOT: Region: %test1.header---%test1.exit ; SCOPS-NOT: Region: %test1.header---%test1.exit
; Verify that we detect this scop, but that, due to an infeasible run-time ; Verify that we detect this scop, but that, due to an infeasible run-time
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/ScopInfo/infeasible_invalid_context.ll

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

polly/test/ScopInfo/int2ptr_ptr2int.ll

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

polly/test/ScopInfo/int2ptr_ptr2int_2.ll

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

polly/test/ScopInfo/integers.ll

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

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

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -analyze < %s 2>&1 > /dev/null | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-print-scops -disable-output < %s 2>&1 > /dev/null | FileCheck %s
; ;
; Error statements (%bb33) do not require their uses to be verified. ; Error statements (%bb33) do not require their uses to be verified.
; In this case it uses %tmp32 from %bb31 which is not available because ; In this case it uses %tmp32 from %bb31 which is not available because
; %bb31 is an error statement as well. ; %bb31 is an error statement as well.
target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
declare noalias i8* @widget() declare noalias i8* @widget()
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/ScopInfo/inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basic-aa -polly-scops \ ; RUN: opt %loadPolly -basic-aa -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -disable-output < %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 48 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -S < %s | FileCheck %s ; RUN: < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_loop__TO__backedge ; CHECK-NEXT: Stmt_loop__TO__backedge
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] : 0 <= i0 <= 100 }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] : 0 <= i0 <= 100 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_loop__TO__backedge[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
Show All 39 Lines

polly/test/ScopInfo/intra_and_inter_bb_scalar_dep.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze \ ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/ScopInfo/intra_bb_scalar_dep.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze \ ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ScopInfo/intrinsics.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-print-instructions -disable-output < %s | FileCheck %s
; ;
; Verify that we remove the ignored intrinsics from the instruction list. ; Verify that we remove the ignored intrinsics from the instruction list.
; ;
; CHECK: Instructions { ; CHECK: Instructions {
; CHECK-NEXT: store i32 %i.0, i32* %arrayidx, align 4 ; CHECK-NEXT: store i32 %i.0, i32* %arrayidx, align 4
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; int A[1024]; ; int A[1024];
Show All 37 Lines

polly/test/ScopInfo/invalid_add_rec_after_invariant_load_remapping.ll

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

polly/test/ScopInfo/invalidate_iterator_during_MA_removal.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
; ;
; Check that no invalidated iterator is accessed while elements from ; Check that no invalidated iterator is accessed while elements from
; the list of MemoryAccesses are removed. ; the list of MemoryAccesses are removed.
; No CHECK-line because the with no MemoryAccesses left, ; No CHECK-line because the with no MemoryAccesses left,
; we cannot model a SCoP. ; we cannot model a SCoP.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant-load-instlist.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s
; The load is a required invariant load and at the same time used in a store. ; The load is a required invariant load and at the same time used in a store.
; Polly used to add two MemoryAccesses for it which caused an assertion to fail. ; Polly used to add two MemoryAccesses for it which caused an assertion to fail.
; llvm.org/PR48059 ; llvm.org/PR48059
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.27.29112" target triple = "x86_64-pc-windows-msvc19.27.29112"
Show All 23 Lines

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

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -disable-output < %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_L_4 ; CHECK-NEXT: Stmt_L_4
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] : 0 <= i0 < tmp8 and 0 <= i1 < tmp8 and 0 <= i2 < tmp8 }; ; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] : 0 <= i0 < tmp8 and 0 <= i1 < tmp8 and 0 <= i2 < tmp8 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] -> [i0, i1, i2] }; ; CHECK-NEXT: [tmp8, tmp22, tmp15] -> { Stmt_L_4[i0, i1, i2] -> [i0, i1, i2] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 107 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] };
; ;
; void f(int *restrict A, int *restrict B) { ; void f(int *restrict A, int *restrict B) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i] = *B; ; A[i] = *B;
Show All 26 Lines

polly/test/ScopInfo/invariant_load_access_classes_different_base_type.ll

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

polly/test/ScopInfo/invariant_load_access_classes_different_base_type_escaping.ll

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

polly/test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; int U; ; int U;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1000; i++) ; for (int i = 0; i < 1000; i++)
; A[i] = (*(int *)&U) + (int)(*(float *)&U); ; A[i] = (*(int *)&U) + (int)(*(float *)&U);
; } ; }
; ;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_access_classes_different_base_type_same_pointer_escaping.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -S < %s | FileCheck %s --check-prefix=CODEGEN
; ;
; int U; ; int U;
; int f(int *A) { ; int f(int *A) {
; int i = 0, x, y; ; int i = 0, x, y;
; do { ; do {
; x = (*(int *)&U); ; x = (*(int *)&U);
; y = (int)(*(float *)&U); ; y = (int)(*(float *)&U);
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_addrec_sum.ll

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

polly/test/ScopInfo/invariant_load_base_pointer.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_BPLoc[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_BPLoc[0] };
; ;
; void f(int **BPLoc) { ; void f(int **BPLoc) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; (*BPLoc)[i] = 0; ; (*BPLoc)[i] = 0;
Show All 26 Lines

polly/test/ScopInfo/invariant_load_base_pointer_conditional.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -polly-process-unprofitable -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BPLoc[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BPLoc[0] };
; ;
; void f(int **BPLoc, int *A, int N) { ; void f(int **BPLoc, int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; if (i > 512) ; if (i > 512)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_base_pointer_in_conditional.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BP[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb5[i0] -> MemRef_BP[0] };
; CHECK-NEXT: Execution Context: [N] -> { : N >= 514 } ; CHECK-NEXT: Execution Context: [N] -> { : N >= 514 }
; ;
; void f(int *BP, int *A, int N) { ; void f(int *BP, int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_branch_condition.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting < %s | FileCheck %s
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [val] -> { Stmt_next[] -> MemRef_ptr[0] }; ; CHECK-NEXT: [val] -> { Stmt_next[] -> MemRef_ptr[0] };
; CHECK-NEXT: Execution Context: [val] -> { : } ; CHECK-NEXT: Execution Context: [val] -> { : }
; CHECK-NEXT: } ; CHECK-NEXT: }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_body1[i0] : 0 <= i0 <= 1022 }; ; CHECK-NEXT: { Stmt_body1[i0] : 0 <= i0 <= 1022 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_body1[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_body1[i0] -> [i0, 0] };
Show All 37 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Make sure we choose a canonical element that is not the first invariant load, ; Make sure we choose a canonical element that is not the first invariant load,
; but the first that is an array base pointer. ; but the first that is an array base pointer.
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_body0 ; CHECK-NEXT: Stmt_body0
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that we canonicalize accesses even tough one of the accesses (even ; Verify that we canonicalize accesses even tough one of the accesses (even
; the canonical base) has a partial execution context. This is correct as ; the canonical base) has a partial execution context. This is correct as
; the combined execution context still coveres both accesses. ; the combined execution context still coveres both accesses.
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that a delinearized and a not delinearized access are not ; Verify that a delinearized and a not delinearized access are not
; canonizalized. ; canonizalized.
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4b.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that two arrays delinearized with different sizes are not coalesced. ; Verify that two arrays delinearized with different sizes are not coalesced.
; CHECK: Stmt_body1 ; CHECK: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [m, n] -> { Stmt_body1[i0] : 0 <= i0 <= 1022 }; ; CHECK-NEXT: [m, n] -> { Stmt_body1[i0] : 0 <= i0 <= 1022 };
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_4c.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that arrays with different element types are not coalesced. ; Verify that arrays with different element types are not coalesced.
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_body1 ; CHECK-NEXT: Stmt_body1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_canonicalize_array_baseptrs_5.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s \
; RUN: -polly-invariant-load-hoisting \ ; RUN: -polly-invariant-load-hoisting \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; Verify that nested arrays with invariant base pointers are handled correctly. ; Verify that nested arrays with invariant base pointers are handled correctly.
; Specifically, we currently do not canonicalize arrays where some accesses are ; Specifically, we currently do not canonicalize arrays where some accesses are
; hoisted as invariant loads. If we would, we need to update the access function ; hoisted as invariant loads. If we would, we need to update the access function
; of the invariant loads as well. However, as this is not a very common ; of the invariant loads as well. However, as this is not a very common
; situation, we leave this for now to avoid further complexity increases. ; situation, we leave this for now to avoid further complexity increases.
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_complex_condition.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -S -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.IP = type { i32****, i32***, %struct.P, %struct.S, %struct.m } %struct.IP = type { i32****, i32***, %struct.P, %struct.S, %struct.m }
%struct.P = type { i32 } %struct.P = type { i32 }
%struct.S = type { i32 } %struct.S = type { i32 }
%struct.D = type { i32 } %struct.D = type { i32 }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_condition.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_C[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_C[0] };
; ;
; void f(int *A, int *C) { ; void f(int *A, int *C) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; if (*C) ; if (*C)
Show All 34 Lines

polly/test/ScopInfo/invariant_load_dereferenceable.ll

; RUN: opt %loadPolly -polly-detect -polly-scops \ ; RUN: opt %loadPolly -polly-print-detect -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -analyze < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; CHECK-NOT: Function: foo_undereferanceable ; CHECK-NOT: Function: foo_undereferanceable
; CHECK: Function: foo_dereferanceable ; CHECK: Function: foo_dereferanceable
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [sizeA] -> { Stmt_for_body_j__TO__for_latch_j[i0, i1] -> MemRef_sizeA_ptr[0] }; ; CHECK-NEXT: [sizeA] -> { Stmt_for_body_j__TO__for_latch_j[i0, i1] -> MemRef_sizeA_ptr[0] };
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_distinct_parameter_valuations.ll

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

polly/test/ScopInfo/invariant_load_in_non_affine.ll

; RUN: opt %loadPolly -polly-detect -analyze \ ; RUN: opt %loadPolly -polly-print-detect -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; CHECK-NOT: Valid Region for Scop ; CHECK-NOT: Valid Region for Scop
; ;
; void foo(float A[], float B[], long *p) { ; void foo(float A[], float B[], long *p) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; for (long j = 0; j < 1024; j++) ; for (long j = 0; j < 1024; j++)
; if (B[i]) ; if (B[i])
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_loop_ub.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -polly-invariant-load-hoisting=true -polly-process-unprofitable -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_UB[0] }; ; CHECK-NEXT: { Stmt_bb1[i0] -> MemRef_UB[0] };
; ;
; void f(int *A, int *UB) { ; void f(int *A, int *UB) {
; for (int i = 0; i < *UB; i++) ; for (int i = 0; i < *UB; i++)
; A[i] = 0; ; A[i] = 0;
Show All 27 Lines

polly/test/ScopInfo/invariant_load_ptr_ptr_noalias.ll

; RUN: opt %loadPolly -tbaa -polly-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing \ ; RUN: opt %loadPolly -tbaa -polly-print-scops -polly-invariant-load-hoisting=true -polly-ignore-aliasing \
; RUN: -analyze < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; ;
; Note: The order of the invariant accesses is important because A is the ; Note: The order of the invariant accesses is important because A is the
; base pointer of tmp3 and we will generate code in the same order as ; base pointer of tmp3 and we will generate code in the same order as
; the invariant accesses are listed here. ; the invariant accesses are listed here.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK: MemRef_A[42] ; CHECK: MemRef_A[42]
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_scalar_dep.ll

; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: ; CHECK: Invariant Accesses:
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] }; ; CHECK-NEXT: { Stmt_bb2[i0] -> MemRef_B[0] };
; CHECK-NOT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NOT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NOT: { Stmt_bb2[i0] -> MemRef_tmp[] }; ; CHECK-NOT: { Stmt_bb2[i0] -> MemRef_tmp[] };
; ;
; void f(int *restrict A, int *restrict B) { ; void f(int *restrict A, int *restrict B) {
Show All 33 Lines

polly/test/ScopInfo/invariant_load_stmt_domain.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; This test case verifies that the statement domain of the invariant access ; This test case verifies that the statement domain of the invariant access
; is the universe. In earlier versions of Polly, we accidentally computed an ; is the universe. In earlier versions of Polly, we accidentally computed an
; empty access domain which resulted in invariant accesses not being executed ; empty access domain which resulted in invariant accesses not being executed
; and consequently undef values being used. ; and consequently undef values being used.
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_load_zext_parameter-2.ll

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

polly/test/ScopInfo/invariant_load_zext_parameter.ll

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

polly/test/ScopInfo/invariant_load_zextended_in_own_execution_context.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -analyze < %s ; RUN: opt %loadPolly -polly-codegen -polly-invariant-load-hoisting=true -disable-output < %s
; ;
; CHECK: Execution Context: [p_0_loaded_from_currpc] -> { : } ; CHECK: Execution Context: [p_0_loaded_from_currpc] -> { : }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@currpc = external global i32, align 4 @currpc = external global i32, align 4
@inbuff = external global i8*, align 8 @inbuff = external global i8*, align 8
Show All 21 Lines

polly/test/ScopInfo/invariant_loads_complicated_dependences.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_for_body[i0] -> MemRef_LBptr[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_for_body[i0] -> MemRef_LBptr[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [LB, UB] -> { Stmt_do_cond[i0, i1] -> MemRef_UBptr[0] }; ; CHECK-NEXT: [LB, UB] -> { Stmt_do_cond[i0, i1] -> MemRef_UBptr[0] };
; CHECK-NEXT: Execution Context: [LB, UB] -> { : } ; CHECK-NEXT: Execution Context: [LB, UB] -> { : }
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_loads_cyclic_dependences.ll

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

polly/test/ScopInfo/invariant_loop_bounds.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond[i0] -> MemRef_bounds[2] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond[i0] -> MemRef_bounds[2] };
; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : } ; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_1[i0, i1] -> MemRef_bounds[1] }; ; CHECK-NEXT: [bounds2, bounds1, bounds0] -> { Stmt_for_cond_1[i0, i1] -> MemRef_bounds[1] };
; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : } ; CHECK-NEXT: Execution Context: [bounds2, bounds1, bounds0] -> { : }
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_same_loop_bound_multiple_times-1.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; Verify that we only have one parameter and one invariant load for all ; Verify that we only have one parameter and one invariant load for all
; three loads that occure in the region but actually access the same ; three loads that occure in the region but actually access the same
; location. Also check that the execution context is the most generic ; location. Also check that the execution context is the most generic
; one, e.g., here the universal set. ; one, e.g., here the universal set.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

polly/test/ScopInfo/invariant_same_loop_bound_multiple_times-2.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; Verify that we only have one parameter and one invariant load for all ; Verify that we only have one parameter and one invariant load for all
; three loads that occure in the region but actually access the same ; three loads that occure in the region but actually access the same
; location. Also check that the execution context is the most generic ; location. Also check that the execution context is the most generic
; one, e.g., here the universal set. ; one, e.g., here the universal set.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

polly/test/ScopInfo/isl_trip_count_01.ll

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

polly/test/ScopInfo/isl_trip_count_02.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; TODO: We do not allow unbounded loops at the moment. ; TODO: We do not allow unbounded loops at the moment.
; ;
; CHECK-NOT: Stmt_for_body ; CHECK-NOT: Stmt_for_body
; ;
; void f(int *A, int N, int M) { ; void f(int *A, int N, int M) {
; for (int i = M; i > N; i++) ; for (int i = M; i > N; i++)
; A[i] = i; ; A[i] = i;
Show All 26 Lines

polly/test/ScopInfo/isl_trip_count_03.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Test comes from a bug (15771) or better a feature request. It was not allowed ; Test comes from a bug (15771) or better a feature request. It was not allowed
; in Polly in the old domain generation as ScalarEvolution cannot figure out the ; in Polly in the old domain generation as ScalarEvolution cannot figure out the
; loop bounds. However, the new domain generation will detect the SCoP. ; loop bounds. However, the new domain generation will detect the SCoP.
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n] -> { : -2147483648 <= n <= 2147483647 } ; CHECK-NEXT: [n] -> { : -2147483648 <= n <= 2147483647 }
; ;
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

polly/test/ScopInfo/isl_trip_count_multiple_exiting_blocks.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
; CHECK: Domain := ; CHECK: Domain :=
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ScopInfo/licm_load.ll

; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare \ ; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare \
; RUN: -polly-invariant-load-hoisting=true -polly-scops -analyze < %s \ ; RUN: -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare \ ; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare \
; RUN: -polly-invariant-load-hoisting=true -polly-scops -analyze < %s \ ; RUN: -polly-invariant-load-hoisting=true -polly-print-scops --disable-output< %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; void foo(int n, float A[static const restrict n], ; void foo(int n, float A[static const restrict n],
; float B[static const restrict n], int j) { ; float B[static const restrict n], int j) {
; for (int i = 0; i < n; i++) ; for (int i = 0; i < n; i++)
; A[i] = B[j]; ; A[i] = B[j];
; } ; }
; ;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

polly/test/ScopInfo/licm_potential_store.ll

; RUN: opt %loadPolly -basic-aa -sroa -instcombine -simplifycfg -tailcallopt \ ; RUN: opt %loadPolly -basic-aa -sroa -instcombine -simplifycfg -tailcallopt \
; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars \ ; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars \
; RUN: -polly-prepare -polly-scops -analyze < %s \ ; RUN: -polly-prepare -polly-print-scops -disable-output < %s \
; RUN: \
; RUN: | FileCheck %s --check-prefix=NOLICM ; RUN: | FileCheck %s --check-prefix=NOLICM
; RUN: opt %loadPolly -basic-aa -sroa -instcombine -simplifycfg -tailcallopt \ ; RUN: opt %loadPolly -basic-aa -sroa -instcombine -simplifycfg -tailcallopt \
; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars -licm \ ; RUN: -simplifycfg -reassociate -loop-rotate -instcombine -indvars -licm \
; RUN: -polly-prepare -polly-scops -analyze < %s \ ; RUN: -polly-prepare -polly-print-scops -disable-output < %s \
; RUN: \
; RUN: | FileCheck %s --check-prefix=LICM ; RUN: | FileCheck %s --check-prefix=LICM
; void foo(int n, float A[static const restrict n], float x) { ; void foo(int n, float A[static const restrict n], float x) {
; // (0) ; // (0)
; for (int i = 0; i < 5; i += 1) { ; for (int i = 0; i < 5; i += 1) {
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; x = 7; // (1) ; x = 7; // (1)
; } ; }
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/ScopInfo/licm_reduction.ll

  • This file was deleted.
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s
;
; XFAIL: *
;
; void test(int n, double B[static const restrict n], int j) {
; for (int i = 0; i < n; i += 1) {
; B[j] += i;
; }
; }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @test(i32 %n, double* noalias nonnull %B, i32 %j) {
entry:
br label %for.cond
for.cond: ; preds = %for.inc, %entry
%i.0 = phi i32 [ 0, %entry ], [ %add1, %for.inc ]
%cmp = icmp slt i32 %i.0, %n
br i1 %cmp, label %for.body, label %for.end
for.body: ; preds = %for.cond
%conv = sitofp i32 %i.0 to double
%idxprom = sext i32 %j to i64
%arrayidx = getelementptr inbounds double, double* %B, i64 %idxprom
%tmp = load double, double* %arrayidx, align 8
%add = fadd double %tmp, %conv
store double %add, double* %arrayidx, align 8
br label %for.inc
for.inc: ; preds = %for.body
%add1 = add nuw nsw i32 %i.0, 1
br label %for.cond
for.end: ; preds = %for.cond
ret void
}
; CHECK: Statements {
; CHECK: Stmt_for_body
; CHECK-DAG: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n, j] -> { Stmt_for_body[i0] -> MemRef_B[j] };
; CHECK-DAG: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [n, j] -> { Stmt_for_body[i0] -> MemRef_B[j] };
; CHECK: }

polly/test/ScopInfo/licm_reduction_nested.ll

; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare -polly-scops -disable-output < %s | FileCheck %s
; ;
; XFAIL: * ; XFAIL: *
; ;
; Even ScopDetection fails here after LICM because of PHI in exit node. ; Even ScopDetection fails here after LICM because of PHI in exit node.
; ;
; void foo(unsigned long *restrict A, unsigned long *restrict B, ; void foo(unsigned long *restrict A, unsigned long *restrict B,
; unsigned long j) { ; unsigned long j) {
; for (unsigned long i = 0; i < 100; i++) ; for (unsigned long i = 0; i < 100; i++)
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/ScopInfo/licm_store.ll

  • This file was deleted.
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -polly-prepare -polly-scops -analyze < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -loop-rotate -indvars -licm -polly-prepare -polly-scops -analyze < %s | FileCheck %s
;
; XFAIL: *
;
; void foo(float *restrict A, float *restrict B, long j) {
; for (long i = 0; i < 100; i++)
; A[j] = B[i];
; }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(float* noalias %A, float* noalias %B, i64 %j) {
entry:
br label %for.cond
for.cond: ; preds = %for.inc, %entry
%i.0 = phi i64 [ 0, %entry ], [ %inc, %for.inc ]
%exitcond = icmp ne i64 %i.0, 100
br i1 %exitcond, label %for.body, label %for.end
for.body: ; preds = %for.cond
%arrayidx = getelementptr inbounds float, float* %B, i64 %i.0
%tmp = bitcast float* %arrayidx to i32*
%tmp1 = load i32, i32* %tmp, align 4
%arrayidx1 = getelementptr inbounds float, float* %A, i64 %j
%tmp2 = bitcast float* %arrayidx1 to i32*
store i32 %tmp1, i32* %tmp2, align 4
br label %for.inc
for.inc: ; preds = %for.body
%inc = add nuw nsw i64 %i.0, 1
br label %for.cond
for.end: ; preds = %for.cond
ret void
}
; CHECK: Statements {
; CHECK: Stmt_for_body
; CHECK-DAG: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [j] -> { Stmt_for_body[i0] -> MemRef_B[i0] };
; CHECK-DAG: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [j] -> { Stmt_for_body[i0] -> MemRef_A[j] };
; CHECK: }

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

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

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 } %struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 }
; The execution context of invalid loads in this test case has at some point become very complex and we should bail. ; The execution context of invalid loads in this test case has at some point become very complex and we should bail.
; CHECK-NOT: Statements ; CHECK-NOT: Statements
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 } %struct.hoge = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [8 x [2 x i32]], [8 x [2 x i32]], [4 x [4 x i32]], i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, [500 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [1024 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], i32, i32, i32*, i32*, i8*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, [5 x double], i32, [8 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [6 x double], [6 x double], [256 x i8], i32, i32, i32, i32, [2 x [5 x i32]], [2 x [5 x i32]], i32, i32, i32, i32, i32, i32, i32, i32, i32, [3 x i32], i32 }
; This test case contains a long sequence of branch instructions together with ; This test case contains a long sequence of branch instructions together with
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s --check-prefix=IR
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

polly/test/ScopInfo/loop_affine_bound_0.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %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 56 Lines • Show Last 20 Lines

polly/test/ScopInfo/loop_affine_bound_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output< %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %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 55 Lines • Show Last 20 Lines

polly/test/ScopInfo/loop_affine_bound_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %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 66 Lines • Show Last 20 Lines

polly/test/ScopInfo/loop_carry.ll

; RUN: opt %loadPolly -basic-aa -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
;long f(long a[], long n) { ;long f(long a[], long n) {
; long i, k; ; long i, k;
; k = 1; ; k = 1;
; for (i = 1; i < n; ++i) { ; for (i = 1; i < n; ++i) {
; a[i] = k * a[i - 1]; ; a[i] = k * a[i - 1];
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(float a[100][100]) { ; void f(float a[100][100]) {
; float x; ; float x;
; ;
; for (int i = 0; i < 100; i++) { ; for (int i = 0; i < 100; i++) {
; for (int j = 0; j < 100; j++) { ; for (int j = 0; j < 100; j++) {
; for (int k = 0; k < 100; k++) { ; for (int k = 0; k < 100; k++) {
; if (k == 0) ; if (k == 0)
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 64 Lines • Show Last 20 Lines

polly/test/ScopInfo/memcpy-raw-source.ll

; RUN: opt %loadPolly -basic-aa -scoped-noalias-aa -tbaa -polly-scops -analyze < %s ; RUN: opt %loadPolly -basic-aa -scoped-noalias-aa -tbaa -polly-print-scops -disable-output < %s
; ;
; Ensure that ScopInfo's alias analysis llvm.memcpy for, ; Ensure that ScopInfo's alias analysis llvm.memcpy for,
; like the AliasSetTracker, preserves bitcasts. ; like the AliasSetTracker, preserves bitcasts.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@tonemasks = external global [17 x [6 x [56 x float]]], align 16 @tonemasks = external global [17 x [6 x [56 x float]]], align 16
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/memcpy.ll

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

polly/test/ScopInfo/memmove.ll

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

polly/test/ScopInfo/memset.ll

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

polly/test/ScopInfo/memset_null.ll

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

polly/test/ScopInfo/mismatching-array-dimensions.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK-NOT: AssumedContext ; CHECK-NOT: AssumedContext
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0" target triple = "x86_64-apple-macosx10.9.0"
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @hoge([38 x [64 x float]]* %arg, [32 x [2 x float]]* %arg5, i32 %arg6) #0 { define void @hoge([38 x [64 x float]]* %arg, [32 x [2 x float]]* %arg5, i32 %arg6) #0 {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/ScopInfo/mod_ref_access_pointee_arguments.ll

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

polly/test/ScopInfo/mod_ref_read_pointee_arguments.ll

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

polly/test/ScopInfo/mod_ref_read_pointer.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basic-aa -polly-allow-modref-calls -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-allow-modref-calls -polly-codegen -disable-output < %s
; RUN: opt %loadPolly -basic-aa -polly-codegen -disable-output \
; RUN: -polly-allow-modref-calls < %s
; ;
; Check that we assume the call to func has a read on the whole A array. ; Check that we assume the call to func has a read on the whole A array.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_for_body[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_for_body[i0] -> [i0] };
Show All 39 Lines

polly/test/ScopInfo/mod_ref_read_pointers.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze -polly-allow-modref-calls \ ; RUN: opt %loadPolly -basic-aa -polly-print-scops -polly-allow-modref-calls \
; RUN: < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-codegen -disable-output \ ; RUN: opt %loadPolly -basic-aa -polly-codegen -disable-output \
; RUN: -polly-allow-modref-calls < %s ; RUN: -polly-allow-modref-calls < %s
; ;
; Check that the call to func will "read" not only the A array but also the ; Check that the call to func will "read" not only the A array but also the
; B array. The reason is the readonly annotation of func. ; B array. The reason is the readonly annotation of func.
; ;
; CHECK: Stmt_for_body ; CHECK: Stmt_for_body
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_for_body[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/ScopInfo/modulo_zext_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : false } ; CHECK-NEXT: [N] -> { : false }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopInfo/modulo_zext_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : false } ; CHECK-NEXT: [N] -> { : false }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_if_then ; CHECK-NEXT: Stmt_if_then
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/modulo_zext_3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 4294967297 } ; CHECK-NEXT: [N] -> { : N >= 4294967297 }
; CHECK: p0: %N ; CHECK: p0: %N
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body ; CHECK-NEXT: Stmt_for_body
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopInfo/multi-scop.ll

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

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

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

polly/test/ScopInfo/multidim_2d_outer_parametric_offset.ll

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

polly/test/ScopInfo/multidim_2d_parametric_array_static_loop_bounds.ll

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

polly/test/ScopInfo/multidim_2d_with_modref_call.ll

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

polly/test/ScopInfo/multidim_2d_with_modref_call_2.ll

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

polly/test/ScopInfo/multidim_3d_parametric_array_static_loop_bounds.ll

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

polly/test/ScopInfo/multidim_fixedsize_different_dimensionality.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; #define N 400 ; #define N 400
; ;
; void first_higher_dimensional(float A[][N]) { ; void first_higher_dimensional(float A[][N]) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; for (long j = 0; j < N; j++) ; for (long j = 0; j < N; j++)
; A[i][j] += i + j; ; A[i][j] += i + j;
; ;
▲ Show 20 Lines • Show All 250 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_fixedsize_multi_offset.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_fold_constant_dim.ll

; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; struct com { ; struct com {
; double Real; ; double Real;
; double Img; ; double Img;
; }; ; };
; ;
; void foo(long n, struct com A[][n]) { ; void foo(long n, struct com A[][n]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_fold_constant_dim_zero.ll

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

polly/test/ScopInfo/multidim_fortran_2d.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; subroutine init_array(ni, nj, pi, pj, a) ; subroutine init_array(ni, nj, pi, pj, a)
; implicit none ; implicit none
; ;
; double precision, dimension(nj, ni) :: a ; double precision, dimension(nj, ni) :: a
; integer*8 :: ni, nj ; integer*8 :: ni, nj
; integer*8 :: pi, pj ; integer*8 :: pi, pj
; integer*8 :: i, j ; integer*8 :: i, j
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_fortran_2d_params.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-precise-fold-accesses \ ; RUN: -polly-precise-fold-accesses \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; subroutine init_array(ni, nj, pi, pj, a) ; subroutine init_array(ni, nj, pi, pj, a)
; implicit none ; implicit none
; double precision, dimension(nj, ni) :: a ; double precision, dimension(nj, ni) :: a
; integer*8 :: ni, nj ; integer*8 :: ni, nj
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_fortran_2d_with_modref_call.ll

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

polly/test/ScopInfo/multidim_fortran_srem.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_bb188 ; CHECK-NEXT: Stmt_bb188
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] : 0 <= i0 <= -3 + tmp183 }; ; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] : 0 <= i0 <= -3 + tmp183 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> [i0, 0, 0, 0] }; ; CHECK-NEXT: [tmp180, tmp177, tmp183, tmp162, tmp157, tmp150, tmp146, tmp140, tmp] -> { Stmt_bb188[i0] -> [i0, 0, 0, 0] };
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_gep_pointercast.ll

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

polly/test/ScopInfo/multidim_gep_pointercast2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verfy that we do not use the GetElementPtr information to delinearize A ; Verfy that we do not use the GetElementPtr information to delinearize A
; because of the cast in-between. Use the single-dimensional modeling instead. ; because of the cast in-between. Use the single-dimensional modeling instead.
; ;
; void f(short A[][2]) { ; void f(short A[][2]) {
; for (int i = 0; i < 100; i++) ; for (int i = 0; i < 100; i++)
; *((long *)&A[4 * i][0]) = 0; ; *((long *)&A[4 * i][0]) = 0;
; } ; }
Show All 40 Lines

polly/test/ScopInfo/multidim_invalid_dimension.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64-unknown-linux-gnueabi" target triple = "aarch64-unknown-linux-gnueabi"
; Make sure we don't crash trying delinearize the memory access ; Make sure we don't crash trying delinearize the memory access
; CHECK: region: 'bb4 => bb14' ; CHECK: region: 'bb4 => bb14'
; CHECK-NEXT: Invalid Scop! ; CHECK-NEXT: Invalid Scop!
define void @f(i8* %arg, i32 %arg1, i32 %arg2, i32 %arg3) { define void @f(i8* %arg, i32 %arg1, i32 %arg2, i32 %arg3) {
bb: bb:
Show All 18 Lines

polly/test/ScopInfo/multidim_ivs_and_integer_offsets_3d.ll

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

polly/test/ScopInfo/multidim_ivs_and_parameteric_offsets_3d.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-precise-fold-accesses -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-precise-fold-accesses | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) { ; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
; ;
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m; j++) ; for (long j = 0; j < m; j++)
; for (long k = 0; k < o; k++) ; for (long k = 0; k < o; k++)
; A[i+p][j+q][k+r] = 1.0; ; A[i+p][j+q][k+r] = 1.0;
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_many_references.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-ignore-aliasing < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-ignore-aliasing -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze -polly-ignore-aliasing < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -polly-ignore-aliasing -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; typedef struct Mat { ; typedef struct Mat {
; float* data; ; float* data;
; long rows; ; long rows;
; long cols; ; long cols;
; long deps; ; long deps;
▲ Show 20 Lines • Show All 510 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_nested_start_integer.ll

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

polly/test/ScopInfo/multidim_nested_start_share_parameter.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
; ;
; for (long i = 0; i < n-13; i++) ; for (long i = 0; i < n-13; i++)
; for (long j = 14; j < m; j++) ; for (long j = 14; j < m; j++)
; for (long k = 0; k < o-17; k++) { ; for (long k = 0; k < o-17; k++) {
; A[i+3][j-4][k+7] = 1.0; ; A[i+3][j-4][k+7] = 1.0;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_only_ivs_2d.ll

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

polly/test/ScopInfo/multidim_only_ivs_3d.ll

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

polly/test/ScopInfo/multidim_only_ivs_3d_cast.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 80 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_only_ivs_3d_reverse.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; This test case checks for array access functions where the order in which the ; This test case checks for array access functions where the order in which the
; loop ivs appear in the array subscript does not follow the order of the ; loop ivs appear in the array subscript does not follow the order of the
; the loops in which they are defined. This (very common) case caused problems ; the loops in which they are defined. This (very common) case caused problems
; in the delinearization pass. ; in the delinearization pass.
; ;
; void foo(long n, long m, long o, double A[n][m][o]) { ; void foo(long n, long m, long o, double A[n][m][o]) {
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_param_in_subscript-2.ll

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

polly/test/ScopInfo/multidim_param_in_subscript.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; ;
; void foo(long n, float A[][n]) { ; void foo(long n, float A[][n]) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < n; j++) ; for (long j = 0; j < n; j++)
; A[i][j] += A[i][n - j - 1]; ; A[i][j] += A[i][n - j - 1];
; } ; }
; ;
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_parameter_addrec_product.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void foo(float *A, long *p) { ; void foo(float *A, long *p) {
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; for (long j = 0; j < 100; j++) ; for (long j = 0; j < 100; j++)
; A[i * (*p) + j] += i + j; ; A[i * (*p) + j] += i + j;
; } ; }
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_single_and_multidim_array.ll

; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-delinearize=false -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-print-scops -polly-delinearize=false -polly-allow-nonaffine -disable-output < %s | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-print-scops -polly-allow-nonaffine -disable-output < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -polly-delinearize=false -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -polly-delinearize=false -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=NONAFFINE ; RUN: opt %loadPolly -polly-print-function-scops -polly-delinearize=false -polly-allow-nonaffine -disable-output < %s | FileCheck %s --check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %s | FileCheck %s --check-prefix=DELIN
; RUN: opt %loadPolly -polly-function-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s --check-prefix=DELIN ; RUN: opt %loadPolly -polly-print-function-scops -polly-allow-nonaffine -disable-output < %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 76 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_srem.ll

; RUN: opt %loadPolly -analyze -polly-scops -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void foo(long n, float A[][n][n]) { ; void foo(long n, float A[][n][n]) {
; for (long i = 0; i < 200; i++) ; for (long i = 0; i < 200; i++)
; for (long j = 0; j < n; j++) ; for (long j = 0; j < n; j++)
; for (long k = 0; k < n; k++) ; for (long k = 0; k < n; k++)
; A[i % 2][j][k] += 10; ; A[i % 2][j][k] += 10;
; } ; }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/test/ScopInfo/multidim_with_bitcast.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Verify that we can look through a bitcast when delinearizing multi-dimensional ; Verify that we can look through a bitcast when delinearizing multi-dimensional
; arrays. ; arrays.
; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] ; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1] ; CHECK: Stmt_bb7[i0, i1] -> MemRef_B[i0, i1]
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-codegen -disable-output < %s
; ;
; void or(float *A, long n, long m) { ; void or(float *A, long n, long m) {
; for (long i = 0; i < 100; i++) { ; for (long i = 0; i < 100; i++) {
; if (i < n || i < m || i > p) ; if (i < n || i < m || i > p)
; A[i] += i; ; A[i] += i;
; } ; }
; } ; }
; ;
Show All 37 Lines

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

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

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

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

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

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

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

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

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

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

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

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

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

; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis="polly-scops" \ ; RUN: opt %loadPolly -polly-print-scops -pass-remarks-analysis="polly-scops" \
; RUN: -polly-allow-differing-element-types \ ; RUN: -polly-allow-differing-element-types \
; RUN: -analyze < %s 2>&1 | FileCheck %s ; RUN: -disable-output < %s 2>&1 | FileCheck %s
; ;
; void foo(long n, long m, char A[][m]) { ; void foo(long n, long m, char A[][m]) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; for (long j = 0; j < m / 4; j++) ; for (long j = 0; j < m / 4; j++)
; A[i][j] = *(float *)&A[i][4 * j]; ; A[i][j] = *(float *)&A[i][4 * j];
; } ; }
; ;
; We do not yet correctly handle multi-dimensional arrays which are accessed ; We do not yet correctly handle multi-dimensional arrays which are accessed
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/multiple-types.ll

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

polly/test/ScopInfo/multiple_exiting_blocks.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
; CHECK: Domain := ; CHECK: Domain :=
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

polly/test/ScopInfo/multiple_exiting_blocks_two_loop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
; void foo(long n, float A[100]) { ; void foo(long n, float A[100]) {
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

polly/test/ScopInfo/multiple_latch_blocks.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: [N, P] -> { Stmt_if_end[i0] : 0 <= i0 < N and (i0 > P or i0 < P) }; ; CHECK: [N, P] -> { Stmt_if_end[i0] : 0 <= i0 < N and (i0 > P or i0 < P) };
; ;
; void f(int *A, int N, int P, int Q) { ; void f(int *A, int N, int P, int Q) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; if (i == P) ; if (i == P)
; continue; ; continue;
Show All 38 Lines

polly/test/ScopInfo/nested-loops.ll

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

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

; RUN: opt %loadPolly -polly-scops \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s
; ;
; Check that we do not generate any scalar dependences regarding x. It is ; Check that we do not generate any scalar dependences regarding x. It is
; defined and used on the non-affine subregion only, thus we do not need ; defined and used on the non-affine subregion only, thus we do not need
; to represent the definition and uses in the model. ; to represent the definition and uses in the model.
; ;
; CHECK: Stmt_bb2__TO__bb11 ; CHECK: Stmt_bb2__TO__bb11
; CHECK-NOT: [Scalar: 1] ; CHECK-NOT: [Scalar: 1]
; CHECK-NOT: MemRef_x ; CHECK-NOT: MemRef_x
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

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

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

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

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

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-codegen -analyze ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-codegen -disable-output
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: { Stmt_loop2__TO__loop[] }; ; CHECK-NEXT: { Stmt_loop2__TO__loop[] };
; ;
define void @foo(i64* %A, i64 %p) { define void @foo(i64* %A, i64 %p) {
entry: entry:
br label %loop br label %loop
Show All 31 Lines

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

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

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

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c] -> { Stmt_for_body[i0] -> MemRef_I[-1 + c] }; ; CHECK-NEXT: [c] -> { Stmt_for_body[i0] -> MemRef_I[-1 + c] };
; CHECK-NEXT: Execution Context: [c] -> { : c > 0 } ; CHECK-NEXT: Execution Context: [c] -> { : c > 0 }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: Context: ; CHECK-NEXT: Context:
Show All 40 Lines

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

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] }; ; CHECK-NEXT: [c] -> { Stmt_if_then[i0] -> MemRef_I[0] };
; CHECK-NEXT: Execution Context: [c] -> { : 0 <= c <= 126 } ; CHECK-NEXT: Execution Context: [c] -> { : 0 <= c <= 126 }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; void f(int *A, unsigned char c, int *I) { ; void f(int *A, unsigned char c, int *I) {
Show All 39 Lines

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

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

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

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

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

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

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [N] -> { : N >= 102 } ; CHECK-NEXT: [N] -> { : N >= 102 }
; ;
; void g(void); ; void g(void);
; void f(int *A, int N) { ; void f(int *A, int N) {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Error blocks are skipped during SCoP detection. We skip them during ; Error blocks are skipped during SCoP detection. We skip them during
; SCoP formation too as they might contain instructions we can not handle. ; SCoP formation too as they might contain instructions we can not handle.
; However statements / basic blocks that follow error blocks are modeled. ; However statements / basic blocks that follow error blocks are modeled.
; ;
; void timer_start(void); ; void timer_start(void);
; void timer_stop(void); ; void timer_stop(void);
; void kernel(int *A, int *B, int timeit, int N) { ; void kernel(int *A, int *B, int timeit, int N) {
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

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

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

polly/test/ScopInfo/non_affine_access.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-allow-nonaffine -disable-output < %s | FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
; RUN: opt %loadPolly -polly-scops -polly-allow-nonaffine -analyze < %s | FileCheck %s -check-prefix=NONAFFINE
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; void foo(long *A) { ; void foo(long *A) {
; for (i = 0; i < 1024; i++) ; for (i = 0; i < 1024; i++)
; A[i * i] = i; ; A[i * i] = i;
; ;
define void @foo(i64 *%A) nounwind uwtable ssp { define void @foo(i64 *%A) nounwind uwtable ssp {
Show All 21 Lines

polly/test/ScopInfo/non_affine_region_1.ll

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

polly/test/ScopInfo/non_affine_region_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify the scalar x defined in a non-affine subregion is written as it ; Verify the scalar x defined in a non-affine subregion is written as it
; escapes the region. In this test the two conditionals inside the region ; escapes the region. In this test the two conditionals inside the region
; are expressed as two PHI nodes with two incoming values each. ; are expressed as two PHI nodes with two incoming values each.
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; int x = 0; ; int x = 0;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

polly/test/ScopInfo/non_affine_region_3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %s | FileCheck %s
; ;
; Verify the scalar x defined in a non-affine subregion is written as it ; Verify the scalar x defined in a non-affine subregion is written as it
; escapes the region. In this test the two conditionals inside the region ; escapes the region. In this test the two conditionals inside the region
; are expressed as one PHI nodes with three incoming values. ; are expressed as one PHI nodes with three incoming values.
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; int x = 0; ; int x = 0;
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

polly/test/ScopInfo/non_affine_region_4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify that both scalars (x and y) are properly written in the non-affine ; Verify that both scalars (x and y) are properly written in the non-affine
; region and read afterwards. ; region and read afterwards.
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; int x = 0, y = 0; ; int x = 0, y = 0;
; if ((x = 1 + A[i])) ; if ((x = 1 + A[i]))
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

polly/test/ScopInfo/nonaffine-buildMemoryAccess.ll

; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine-loops -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: { Stmt_while_cond_i__TO__while_end_i[] }; ; CHECK-NEXT: { Stmt_while_cond_i__TO__while_end_i[] };
; ;
define i32 @func(i32 %param0, i32 %param1, i64* %param2) #3 { define i32 @func(i32 %param0, i32 %param1, i64* %param2) #3 {
entry: entry:
%var0 = alloca i32 %var0 = alloca i32
Show All 36 Lines

polly/test/ScopInfo/not-a-reduction.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s 2>&1 | not FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/out-of-scop-use-in-region-entry-phi-node.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
; CHECK-NEXT: [p_0] -> { Stmt_bb3[] -> MemRef_tmp5[] }; ; CHECK-NEXT: [p_0] -> { Stmt_bb3[] -> MemRef_tmp5[] };
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @hoge() { define void @hoge() {
bb: bb:
Show All 26 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops \
; RUN: -polly-invariant-load-hoisting=true \ ; RUN: -polly-invariant-load-hoisting=true \
; RUN: -analyze -S < %s | FileCheck %s ; RUN: -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_land_lhs_true563[] -> MemRef_tmp0[809] }; ; CHECK-NEXT: { Stmt_land_lhs_true563[] -> MemRef_tmp0[809] };
; CHECK-NEXT: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: { Stmt_if_then570[] -> MemRef_fs[5] }; ; CHECK-NEXT: { Stmt_if_then570[] -> MemRef_fs[5] };
; CHECK-NEXT: Execution Context: { : } ; CHECK-NEXT: Execution Context: { : }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

polly/test/ScopInfo/parameter_in_dead_statement.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; RUN: opt %loadPolly -polly-codegen -S \ ; RUN: opt %loadPolly -polly-codegen -S \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s --check-prefix=IR
; ;
; Verify we do not create assumptions based on the parameter p_1 which is the ; Verify we do not create assumptions based on the parameter p_1 which is the
; load %0 and due to error-assumptions not "part of the SCoP". ; load %0 and due to error-assumptions not "part of the SCoP".
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
Show All 34 Lines

polly/test/ScopInfo/parameter_product.ll

; RUN: opt %loadPolly -polly-scops -analyze -S < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 21 Lines

polly/test/ScopInfo/parameter_with_constant_factor_in_add.ll

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

polly/test/ScopInfo/partially_invariant_load_1.ll

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

polly/test/ScopInfo/partially_invariant_load_2.ll

; RUN: opt %loadPolly -polly-scops -polly-invariant-load-hoisting=true -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -polly-invariant-load-hoisting=true -disable-output < %s | FileCheck %s
; ;
; Check that we do not try to preload *I and assume p != 42. ; Check that we do not try to preload *I and assume p != 42.
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [N, p] -> { : false } ; CHECK-NEXT: [N, p] -> { : false }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

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

polly/test/ScopInfo/phi_after_error_block.ll

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

polly/test/ScopInfo/phi_condition_modeling_1.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 61 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_condition_modeling_2.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 78 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_conditional_simple_1.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 57 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_loop_carried_float.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 51 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_not_grouped_at_top.ll

; RUN: opt %loadPolly -polly-prepare < %s ; RUN: opt %loadPolly -polly-prepare -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"
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() personality i32 (i32, i64, i8*, i8*)* @generic_personality_v0 { define void @funb() personality i32 (i32, i64, i8*, i8*)* @generic_personality_v0 {
entry: entry:
Show All 19 Lines

polly/test/ScopInfo/phi_scalar_simple_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; The assumed context should be empty since the <nsw> flags on the IV ; The assumed context should be empty since the <nsw> flags on the IV
; increments already guarantee that there is no wrap in the loop trip ; increments already guarantee that there is no wrap in the loop trip
; count. ; count.
; ;
; int jd(int *restrict A, int x, int N) { ; int jd(int *restrict A, int x, int N) {
; for (int i = 1; i < N; i++) ; for (int i = 1; i < N; i++)
; for (int j = 3; j < N; j++) ; for (int j = 3; j < N; j++)
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_scalar_simple_2.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; int jd(int *restrict A, int x, int N, int c) { ; int jd(int *restrict A, int x, int N, int c) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; for (int j = 0; j < N; j++) ; for (int j = 0; j < N; j++)
; if (i < c) ; if (i < c)
; x += A[i]; ; x += A[i];
; return x; ; return x;
; } ; }
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

polly/test/ScopInfo/phi_with_invoke_edge.ll

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

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
; while (A != B) { ; while (A != B) {
; *A = *A + 1; ; *A = *A + 1;
; A++; ; A++;
; } ; }
; } ; }
; ;
Show All 30 Lines

polly/test/ScopInfo/pointer-comparison.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; TODO: FIXME: Investigate why we need a InvalidContext here. ; TODO: FIXME: Investigate why we need a InvalidContext here.
; ;
; void f(int *A, int *B) { ; void f(int *A, int *B) {
; while (A != B) { ; while (A != B) {
; *A = *A + 1; ; *A = *A + 1;
; A++; ; A++;
; } ; }
Show All 29 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 37 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; In this test case we pass a pointer %A into a PHI node and also use this ; In this test case we pass a pointer %A into a PHI node and also use this
; pointer as base pointer of an array store. As a result, we get both scalar ; pointer as base pointer of an array store. As a result, we get both scalar
; and array memory accesses to A[] and A[0]. ; and array memory accesses to A[] and A[0].
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: float MemRef_A[*]; // Element size 4 ; CHECK-NEXT: float MemRef_A[*]; // Element size 4
; CHECK-NEXT: float* MemRef_x__phi; // Element size 8 ; CHECK-NEXT: float* MemRef_x__phi; // Element size 8
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_bb9 ; CHECK-NEXT: Stmt_bb9
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [tmp] -> { Stmt_bb9[] }; ; CHECK-NEXT: [tmp] -> { Stmt_bb9[] };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [tmp] -> { Stmt_bb9[] -> [0] }; ; CHECK-NEXT: [tmp] -> { Stmt_bb9[] -> [0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

polly/test/ScopInfo/pr38218.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; This code causes the SCoP to be rejected because of an ERRORBLOCK ; This code causes the SCoP to be rejected because of an ERRORBLOCK
; assumption and made Polly crash (llvm.org/PR38219). ; assumption and made Polly crash (llvm.org/PR38219).
; ;
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 dso_local void @pr38219() { define dso_local void @pr38219() {
start: start:
Show All 27 Lines

polly/test/ScopInfo/preserve-equiv-class-order-in-basic_block.ll

; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
@b = dso_local local_unnamed_addr global i32 1, align 4 @b = dso_local local_unnamed_addr global i32 1, align 4
@e = dso_local local_unnamed_addr global i32 3, align 4 @e = dso_local local_unnamed_addr global i32 3, align 4
@a = common dso_local local_unnamed_addr global [56 x i32] zeroinitializer, align 16 @a = common dso_local local_unnamed_addr global [56 x i32] zeroinitializer, align 16
@f = common dso_local local_unnamed_addr global i16 0, align 2 @f = common dso_local local_unnamed_addr global i16 0, align 2
@d = common dso_local local_unnamed_addr global i8 0, align 1 @d = common dso_local local_unnamed_addr global i8 0, align 1
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

polly/test/ScopInfo/process_added_dimensions.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: { : } ; CHECK-NEXT: { : }
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: { : false } ; CHECK-NEXT: { : false }
; CHECK: Statements { ; CHECK: Statements {
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

polly/test/ScopInfo/pwaff-complexity-bailout.ll

; RUN: opt %loadPolly -analyze -polly-scops -pass-remarks-analysis=.* < %s 2>&1 > /dev/null | FileCheck %s ; RUN: opt %loadPolly -polly-scops -pass-remarks-analysis=.* -disable-output < %s 2>&1 | FileCheck %s
; Make sure we hit the complexity bailout, and don't crash. ; Make sure we hit the complexity bailout, and don't crash.
; CHECK: Low complexity assumption: { : false } ; CHECK: Low complexity assumption: { : false }
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv8--linux-android" target triple = "thumbv8--linux-android"
define hidden void @f(i32 %arg1, i32 %arg2, i32 %cond, i32 %tmp, i32 %tmp196) { define hidden void @f(i32 %arg1, i32 %arg2, i32 %cond, i32 %tmp, i32 %tmp196) {
Show All 28 Lines

polly/test/ScopInfo/ranged_parameter.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the contstraints on the paramater derived from the ; Check that the contstraints on the paramater derived from the
; range metadata (see bottom of the file) are present: ; range metadata (see bottom of the file) are present:
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp] -> { : 0 <= tmp <= 255 } ; CHECK: [tmp] -> { : 0 <= tmp <= 255 }
; ;
; void jd(int *A, int *p /* in [0,256) */) { ; void jd(int *A, int *p /* in [0,256) */) {
Show All 32 Lines

polly/test/ScopInfo/ranged_parameter_2.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-allow-nonaffine -polly-invariant-load-hoisting=true < %s \ ; RUN: opt %loadPolly -polly-print-scops -disable-output -polly-allow-nonaffine -polly-invariant-load-hoisting=true < %s \
; RUN: -debug 2>&1 | FileCheck %s ; RUN: -debug 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK: Region: %bb1---%bb16 ; CHECK: Region: %bb1---%bb16
; CHECK: [n] -> { : false } ; CHECK: [n] -> { : false }
; This test case at some point caused an assertion when modeling a scop, due ; This test case at some point caused an assertion when modeling a scop, due
Show All 32 Lines

polly/test/ScopInfo/ranged_parameter_wrap.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the constraints on the parameter derived from the ; Check that the constraints on the parameter derived from the
; __wrapping__ range metadata (see bottom of the file) are present: ; __wrapping__ range metadata (see bottom of the file) are present:
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp] -> { : -2147483648 <= tmp <= 2147483647 and (tmp >= 256 or tmp < 0) } ; CHECK: [tmp] -> { : -2147483648 <= tmp <= 2147483647 and (tmp >= 256 or tmp < 0) }
; ;
; void jd(int *A, int *p /* in [256, 0) */) { ; void jd(int *A, int *p /* in [256, 0) */) {
Show All 32 Lines

polly/test/ScopInfo/ranged_parameter_wrap_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that the context is built fast and does not explode due to us ; Check that the context is built fast and does not explode due to us
; combining a large number of non-convex ranges. Instead, after a certain ; combining a large number of non-convex ranges. Instead, after a certain
; time, we store range information with reduced precision. ; time, we store range information with reduced precision.
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK: [tmp_0, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp_6, tmp_7, tmp_8, ; CHECK: [tmp_0, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp_6, tmp_7, tmp_8,
; CHECK: tmp_9, tmp_10, tmp_11, tmp_12, tmp_13, tmp_14, tmp_15] -> { : ; CHECK: tmp_9, tmp_10, tmp_11, tmp_12, tmp_13, tmp_14, tmp_15] -> { :
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: < %s | FileCheck %s
; ;
; float foo(float sum, float A[]) { ; float foo(float sum, float A[]) {
; ;
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; sum += A[i]; ; sum += A[i];
; ;
; return sum; ; return sum;
; } ; }
Show All 27 Lines

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

; RUN: opt %loadPolly -analyze -polly-scops \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: < %s | FileCheck %s
; ;
; float foo(float sum, float A[]) { ; float foo(float sum, float A[]) {
; ;
; for (long i = 0; i < 100; i++) ; for (long i = 0; i < 100; i++)
; sum += A[i]; ; sum += A[i];
; ;
; return sum; ; return sum;
; } ; }
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=false -polly-scops \ ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=false -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=true -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=SCALARS
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-analyze-read-only-scalars=true -polly-scops \
; RUN: -analyze < %s | FileCheck %s \
; RUN: -check-prefix=SCALARS
; CHECK-NOT: Memref_scalar ; CHECK-NOT: Memref_scalar
; SCALARS: float MemRef_scalar; // Element size 4 ; SCALARS: float MemRef_scalar; // Element size 4
; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
; SCALARS: { Stmt_stmt1[i0] -> MemRef_scalar[] }; ; SCALARS: { Stmt_stmt1[i0] -> MemRef_scalar[] };
; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1] ; SCALARS: ReadAccess := [Reduction Type: NONE] [Scalar: 1]
Show All 26 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check we remove read only statements. ; Check we remove read only statements.
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_for_body_2 ; CHECK-NEXT: Stmt_for_body_2
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_for_body_2[i0] : 0 <= i0 <= 99 }; ; CHECK-NEXT: { Stmt_for_body_2[i0] : 0 <= i0 <= 99 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

polly/test/ScopInfo/reduction_alternating_base.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; ;
; void f(int *A) { ; void f(int *A) {
; for (int i = 0; i < 1024; i++) ; for (int i = 0; i < 1024; i++)
; A[i % 2] += i; ; A[i % 2] += i;
; } ; }
; ;
; Verify that we detect the reduction on A ; Verify that we detect the reduction on A
Show All 30 Lines

polly/test/ScopInfo/reduction_chain_partially_outside_the_scop.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_disabled_multiplicative.ll

; RUN: opt -basic-aa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze -polly-disable-multiplicative-reductions < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-stmt-granularity=bb -polly-print-scops -polly-disable-multiplicative-reductions -disable-output < %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/test/ScopInfo/reduction_escaping_intermediate.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_escaping_intermediate_2.ll

; RUN: opt %loadPolly -basic-aa -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-stmt-granularity=bb -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_invalid_different_operators.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_invalid_overlapping_accesses.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_multiple_loops_array_sum.ll

; RUN: opt -basic-aa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_multiple_loops_array_sum_1.ll

; RUN: opt -basic-aa %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_multiple_simple_binary.ll

; RUN: opt -basic-aa %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s ; RUN: opt -basic-aa %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_non_overlapping_chains.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_only_reduction_like_access.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_simple_fp.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_simple_w_constant.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_simple_w_iv.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/reduction_two_identical_reads.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %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/test/ScopInfo/redundant_parameter_constraint.ll

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

polly/test/ScopInfo/region-with-instructions.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions \ ; RUN: opt %loadPolly -polly-print-scops -polly-print-instructions -disable-output < %s | FileCheck %s
; RUN: < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK: Stmt_bb46 ; CHECK: Stmt_bb46
; CHECK: Domain := ; CHECK: Domain :=
; CHECK: [tmp44, tmp9] -> { Stmt_bb46[] : tmp9 = tmp44 }; ; CHECK: [tmp44, tmp9] -> { Stmt_bb46[] : tmp9 = tmp44 };
; CHECK: Schedule := ; CHECK: Schedule :=
; CHECK: [tmp44, tmp9] -> { Stmt_bb46[] -> [0, 0] }; ; CHECK: [tmp44, tmp9] -> { Stmt_bb46[] -> [0, 0] };
; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1] ; CHECK: MustWriteAccess := [Reduction Type: NONE] [Scalar: 1]
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output \
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[0] ; CHECK-NEXT: MemRef_bounds[0]
; CHECK-NEXT: Execution Context: [bounds0, bounds1] -> { : } ; CHECK-NEXT: Execution Context: [bounds0, bounds1] -> { : }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: MemRef_bounds[1] ; CHECK-NEXT: MemRef_bounds[1]
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

polly/test/ScopInfo/restriction_in_dead_block.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify we do not generate an empty invalid context only because the wrap ; Verify we do not generate an empty invalid context only because the wrap
; in the second conditional will always happen if the block is executed. ; in the second conditional will always happen if the block is executed.
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [N] -> { : N > 0 } ; CHECK-NEXT: [N] -> { : N > 0 }
; ;
; void f(char *A, char N) { ; void f(char *A, char N) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

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

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 120 Lines • Show Last 20 Lines

polly/test/ScopInfo/run-time-check-many-piecewise-aliasing.ll

; RUN: opt %loadPolly -polly-detect -analyze < %s \ ; RUN: opt %loadPolly -polly-print-detect -disable-output < %s \
; RUN: | FileCheck %s -check-prefix=DETECT ; RUN: | FileCheck %s -check-prefix=DETECT
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; DETECT: Valid Region for Scop: for => return ; DETECT: Valid Region for Scop: for => return
; ;
; Check that this SCoP is allowed, even though the number of disjunct memory accesses of A ; Check that this SCoP is allowed, even though the number of disjunct memory accesses of A
; is 11, greater than RunTimeChecksMaxAccessDisjuncts. ; is 11, greater than RunTimeChecksMaxAccessDisjuncts.
; ;
; CHECK: Function: func ; CHECK: Function: func
; CHECK-NEXT: Region: %for---%return ; CHECK-NEXT: Region: %for---%return
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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/test/ScopInfo/same-base-address-scalar-and-array.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify we introduce two ScopArrayInfo objects (or virtual arrays) for the %out variable ; Verify we introduce two ScopArrayInfo objects (or virtual arrays) for the %out variable
; as it is used as a memory base pointer (%0) but also as a scalar (%out.addr.0.lcssa). ; as it is used as a memory base pointer (%0) but also as a scalar (%out.addr.0.lcssa).
; ;
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: float* MemRef_out_addr_0_lcssa; // Element size 8 ; CHECK-NEXT: float* MemRef_out_addr_0_lcssa; // Element size 8
; CHECK-NEXT: float MemRef_out[*]; // Element size 4 ; CHECK-NEXT: float MemRef_out[*]; // Element size 4
; CHECK-NEXT: } ; CHECK-NEXT: }
Show All 20 Lines

polly/test/ScopInfo/scalar.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
define void @f(i64* %a, i64 %N) { define void @f(i64* %a, i64 %N) {
entry: entry:
br label %for br label %for
for: for:
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ScopInfo/scalar_dependence_cond_br.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output< %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]++;
; } ; }
; ;
; Verify that we do not generate a value write access for the use of %cmp1 in ; Verify that we do not generate a value write access for the use of %cmp1 in
Show All 38 Lines

polly/test/ScopInfo/scalar_to_array.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -basic-aa -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -basic-aa -polly-print-function-scops -disable-output < %s | FileCheck %s
; ModuleID = 'scalar_to_array.ll' ; ModuleID = 'scalar_to_array.ll'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
@A = common global [1024 x float] zeroinitializer, align 8 @A = common global [1024 x float] zeroinitializer, align 8
; Terminating loops without side-effects will be optimzied away, hence ; Terminating loops without side-effects will be optimzied away, hence
; detecting a scop would be pointless. ; detecting a scop would be pointless.
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines

polly/test/ScopInfo/scev-div-with-evaluatable-divisor.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; Derived from test-suite/SingleSource/UnitTests/Vector/SSE/sse.stepfft.c ; Derived from test-suite/SingleSource/UnitTests/Vector/SSE/sse.stepfft.c
; The values %mul.i44 is simplified to constant 4 by ScalarEvolution, but ; The values %mul.i44 is simplified to constant 4 by ScalarEvolution, but
; SCEVAffinator used to check whether the sdiv's argument was constant. ; SCEVAffinator used to check whether the sdiv's argument was constant.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

polly/test/ScopInfo/scev-invalidated.ll

; RUN: opt %loadPolly -polly-scops < %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Region: %if.then6---%return ; CHECK: Region: %if.then6---%return
; ;
target datalayout ="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout ="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
define void @arc_either() { define void @arc_either() {
entry: entry:
%ang2.2.reg2mem = alloca i64 %ang2.2.reg2mem = alloca i64
Show All 15 Lines

polly/test/ScopInfo/schedule-const-post-dominator-walk-2.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; CHECK: Stmt_loopA[i0] -> [0, 0, 0] ; CHECK: Stmt_loopA[i0] -> [0, 0, 0]
Show All 39 Lines

polly/test/ScopInfo/schedule-const-post-dominator-walk.ll

; RUN: opt %loadPolly -analyze -polly-scops < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; CHECK: { Stmt_bb3[i0] -> [0, 0] }; ; CHECK: { Stmt_bb3[i0] -> [0, 0] };
Show All 31 Lines

polly/test/ScopInfo/schedule-constuction-endless-loop1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that we do not build a SCoP and do not crash. ; Check that we do not build a SCoP and do not crash.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
Show All 25 Lines

polly/test/ScopInfo/schedule-constuction-endless-loop2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Check that we do not build a SCoP and do not crash. ; Check that we do not build a SCoP and do not crash.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
Show All 28 Lines

polly/test/ScopInfo/schedule-incorrectly-contructed-in-case-of-infinite-loop.ll

; RUN: opt %loadPolly -polly-process-unprofitable -analyze -polly-scops < %s ; RUN: opt %loadPolly -polly-process-unprofitable -polly-scops -disable-output < %s
; ;
; This test contains a infinite loop (bb13) and crashed the domain generation ; This test contains a infinite loop (bb13) and crashed the domain generation
; at some point. Just verify it does not anymore. ; at some point. Just verify it does not anymore.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @hoge() #0 { define void @hoge() #0 {
bb: bb:
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

polly/test/ScopInfo/scop-affine-parameter-ordering.ll

; RUN: opt %loadPolly -polly-scops %s -analyze | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n8:16:32:64-S128"
target triple = "aarch64--linux-android" target triple = "aarch64--linux-android"
; Check for SCOP: ; Check for SCOP:
; CHECK: Stmt_for_body8_us_us95_i ; CHECK: Stmt_for_body8_us_us95_i
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [p_0] -> { Stmt_for_body8_us_us95_i[i0] : 0 <= i0 <= 4 }; ; CHECK-NEXT: [p_0] -> { Stmt_for_body8_us_us95_i[i0] : 0 <= i0 <= 4 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
Show All 30 Lines

polly/test/ScopInfo/sign_wrapped_set.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-process-unprofitable -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-allow-nonaffine -polly-process-unprofitable < %s | FileCheck %s
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] : 0 <= i0 <= -3 + srcHeight }; ; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] : 0 <= i0 <= -3 + srcHeight };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> [i0] }; ; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> [i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: +] [Scalar: 0]
; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> MemRef_src[o0] }; ; CHECK-NEXT: [srcHeight] -> { Stmt_for_cond6_preheader_us[i0] -> MemRef_src[o0] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: +] [Scalar: 0] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: +] [Scalar: 0]
Show All 32 Lines

polly/test/ScopInfo/simple_loop_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 34 Lines

polly/test/ScopInfo/simple_loop_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; void f(int a[], int N) { ; void f(int a[], int N) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; a[i] = i; ; a[i] = i;
; } ; }
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 34 Lines

polly/test/ScopInfo/simple_loop_unsigned.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; void f(int a[], unsigned N) { ; void f(int a[], unsigned N) {
; unsigned i; ; unsigned i;
; do { ; do {
; a[i] = i; ; a[i] = i;
; } while (++i <= N); ; } while (++i <= N);
; } ; }
Show All 25 Lines

polly/test/ScopInfo/simple_loop_unsigned_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [N] -> { : N <= 0 or N >= 1152921504606846976 } ; CHECK-NEXT: [N] -> { : N <= 0 or N >= 1152921504606846976 }
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: [N] -> { Stmt_bb[i0] : 0 <= i0 < N; Stmt_bb[0] : N <= 0 }; ; CHECK-NEXT: [N] -> { Stmt_bb[i0] : 0 <= i0 < N; Stmt_bb[0] : N <= 0 };
Show All 18 Lines

polly/test/ScopInfo/simple_loop_unsigned_3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
; ;
; CHECK: Domain := ; CHECK: Domain :=
; CHECK-NEXT: [N] -> { Stmt_bb[0] }; ; CHECK-NEXT: [N] -> { Stmt_bb[0] };
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-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 17 Lines

polly/test/ScopInfo/simple_nonaffine_loop_not.ll

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

polly/test/ScopInfo/smax.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:32-n32-S64"
define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) { define void @foo(i32 * noalias %data, i32 * noalias %ptr, i32 %x_pos, i32 %w) {
entry: entry:
br label %for.body br label %for.body
for.body: for.body:
%x = phi i32 [ 0, %entry ], [ %x.inc, %for.body ] %x = phi i32 [ 0, %entry ], [ %x.inc, %for.body ]
Show All 16 Lines

polly/test/ScopInfo/statistics.ll

; RUN: opt %loadPolly -polly-scops -stats -analyze < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -polly-scops -stats -disable-output < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-DAG: 4 polly-scops - Maximal number of loops in scops ; CHECK-DAG: 4 polly-scops - Maximal number of loops in scops
; CHECK-DAG: 10 polly-scops - Number of loops in scops ; CHECK-DAG: 10 polly-scops - Number of loops in scops
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 4 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 4
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 1 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 1
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 3 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 3
; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 2 ; CHECK-DAG: 1 polly-scops - Number of scops with maximal loop depth 2
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_exit_of_region_stmt.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_Region__TO__Stmt ; CHECK-NEXT: Stmt_Region__TO__Stmt
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_Region__TO__Stmt[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_Region__TO__Stmt[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Region__TO__Stmt[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_Region__TO__Stmt[i0] -> [i0, 0] };
; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_no_after_split.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_Stmt ; CHECK-NEXT: Stmt_Stmt
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
Show All 34 Lines

polly/test/ScopInfo/stmt_split_no_dependence.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; void func(int *A, int *B){ ; void func(int *A, int *B){
; for (int i = 0; i < 1024; i+=1) { ; for (int i = 0; i < 1024; i+=1) {
; Stmt: ; Stmt:
; A[i] = i; ; A[i] = i;
; B[i] = i; ; B[i] = i;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_on_store.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-stmt-granularity=store -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=store -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; void func(int *A, int *B){ ; void func(int *A, int *B){
; for (int i = 0; i < 1024; i+=1) { ; for (int i = 0; i < 1024; i+=1) {
; Stmt: ; Stmt:
; A[i] = i; ; A[i] = i;
; B[i] = i; ; B[i] = i;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_on_synthesizable.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_Stmt ; CHECK-NEXT: Stmt_Stmt
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_phi_in_beginning_bb.ll

; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-instructions -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_Stmt ; CHECK-NEXT: Stmt_Stmt
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 }; ; CHECK-NEXT: { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] }; ; CHECK-NEXT: { Stmt_Stmt[i0] -> [i0, 0] };
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ScopInfo/stmt_split_phi_in_stmt.ll

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

polly/test/ScopInfo/stmt_split_scalar_dependence.ll

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

polly/test/ScopInfo/stmt_split_within_loop.ll

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

polly/test/ScopInfo/stmt_with_read_but_without_sideffect.ll

; RUN: opt %loadPolly -polly-delicm -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-delicm -disable-output < %s | FileCheck %s
; ;
; The statement Stmt_for_if_else_1 should be removed because it has no ; The statement Stmt_for_if_else_1 should be removed because it has no
; sideeffects. But it has a use of MemRef_tmp21 that must also be ; sideeffects. But it has a use of MemRef_tmp21 that must also be
; removed from every list containing it. ; removed from every list containing it.
; This is a test-case meant for ScopInfo, but only later pass iterate ; This is a test-case meant for ScopInfo, but only later pass iterate
; over the uses of MemRef_tmp21 of which the use by Stmt_for_if_else_1 ; over the uses of MemRef_tmp21 of which the use by Stmt_for_if_else_1
; should have been removed. We use -polly-delicm to trigger such an ; should have been removed. We use -polly-delicm to trigger such an
; iteration of an already deleted MemoryAccess. ; iteration of an already deleted MemoryAccess.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; break; ; break;
; case 1: ; case 1:
; A[i] += 1; ; A[i] += 1;
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
; case 1: ; case 1:
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; case 1: ; case 1:
; A[i] += 2; ; A[i] += 2;
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; switch (i % 4) { ; switch (i % 4) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
; case 1: ; case 1:
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-5.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; The SCoP contains a loop with multiple exit blocks (BBs after leaving ; The SCoP contains a loop with multiple exit blocks (BBs after leaving
; the loop). The current implementation of deriving their domain derives ; the loop). The current implementation of deriving their domain derives
; only a common domain for all of the exit blocks. We disabled loops with ; only a common domain for all of the exit blocks. We disabled loops with
; multiple exit blocks until this is fixed. ; multiple exit blocks until this is fixed.
; XFAIL: * ; XFAIL: *
; ;
; void f(int *A, int *B, int N) { ; void f(int *A, int *B, int N) {
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-6.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int N) { ; void f(int *A, int N) {
; for (int i = 0; i < N; i++) { ; for (int i = 0; i < N; i++) {
; switch (i) { ; switch (i) {
; case 0: ; case 0:
; A[i] += 1; ; A[i] += 1;
; break; ; break;
; case 1: ; case 1:
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

polly/test/ScopInfo/switch-7.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ast -analyze < %s | FileCheck %s --check-prefix=AST ; RUN: opt %loadPolly -polly-print-ast -disable-output < %s | FileCheck %s --check-prefix=AST
; ;
; void f(int *A, int c, int N) { ; void f(int *A, int c, int N) {
; switch (c) { ; switch (c) {
; case -1: { ; case -1: {
; for (int j = N; j > 0; j--) ; for (int j = N; j > 0; j--)
; A[j] += A[j - 1]; ; A[j] += A[j - 1];
; break; ; break;
; } ; }
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

polly/test/ScopInfo/tempscop-printing.ll

; RUN: opt %loadPolly -basic-aa -polly-scops -analyze \ ; RUN: opt %loadPolly -basic-aa -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; void f(long A[], int N, int *init_ptr) { ; void f(long A[], int N, int *init_ptr) {
; long i, j; ; long i, j;
; ;
; for (i = 0; i < N; ++i) { ; for (i = 0; i < N; ++i) {
; init = *init_ptr; ; init = *init_ptr;
; 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 93 Lines • Show Last 20 Lines

polly/test/ScopInfo/test-wrapping-in-condition.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-function-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-function-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; #include <stdlib.h> ; #include <stdlib.h>
; #include <stdio.h> ; #include <stdio.h>
; ;
; void __attribute__((noinline)) foo(float *A, long N) { ; void __attribute__((noinline)) foo(float *A, long N) {
Show All 36 Lines

polly/test/ScopInfo/truncate-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(char *A, short N) { ; void f(char *A, short N) {
; for (char i = 0; i < (char)N; i++) ; for (char i = 0; i < (char)N; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; FIXME: We should the truncate precisely... or just make it a separate parameter. ; FIXME: We should the truncate precisely... or just make it a separate parameter.
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 37 Lines

polly/test/ScopInfo/truncate-2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(char *A, short N) { ; void f(char *A, short N) {
; for (short i = 0; i < N; i++) ; for (short i = 0; i < N; i++)
; A[(char)(N)]++; ; A[(char)(N)]++;
; } ; }
; ;
; FIXME: We should the truncate precisely... or just make it a separate parameter. ; FIXME: We should the truncate precisely... or just make it a separate parameter.
; CHECK: Assumed Context: ; CHECK: Assumed Context:
Show All 35 Lines

polly/test/ScopInfo/two-loops-one-infinite.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Verify we do not create a SCoP in the presence of infinite loops. ; Verify we do not create a SCoP in the presence of infinite loops.
; ;
; CHECK-NOT: Statements ; CHECK-NOT: Statements
; ;
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n8:16:32-S64"
define void @foo(i32* noalias nocapture readonly %xxx, i32* noalias nocapture readonly %yyy, i8*** nocapture readonly %zzz, i32 %conv6) { define void @foo(i32* noalias nocapture readonly %xxx, i32* noalias nocapture readonly %yyy, i8*** nocapture readonly %zzz, i32 %conv6) {
Show All 31 Lines

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

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: < %s | FileCheck %s
; CHECK: Statements { ; CHECK: Statements {
; CHECK-NEXT: Stmt_loop_1 ; CHECK-NEXT: Stmt_loop_1
; CHECK-NEXT: Domain := ; CHECK-NEXT: Domain :=
; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] : N <= 100 and 0 <= i0 <= 101 }; ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] : N <= 100 and 0 <= i0 <= 101 };
; CHECK-NEXT: Schedule := ; CHECK-NEXT: Schedule :=
; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] -> [0, i0] }; ; CHECK-NEXT: [N] -> { Stmt_loop_1[i0] -> [0, i0] };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/ScopInfo/undef_in_cond.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
define fastcc void @fix_operands() nounwind { define fastcc void @fix_operands() nounwind {
entry: entry:
br i1 undef, label %bb3, label %bb1 br i1 undef, label %bb3, label %bb1
bb1: ; preds = %bb bb1: ; preds = %bb
%0 = icmp eq i32 0, undef ; <i1> [#uses=1] %0 = icmp eq i32 0, undef ; <i1> [#uses=1]
Show All 13 Lines

polly/test/ScopInfo/unnamed_nonaffine.ll

; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \ ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-use-llvm-names=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-use-llvm-names=true | FileCheck %s ; RUN: opt %loadPolly -polly-allow-nonaffine -polly-use-llvm-names=false -polly-print-scops -disable-output < %s | FileCheck %s -check-prefix=UNNAMED
;
; RUN: opt %loadPolly -polly-allow-nonaffine -polly-scops -analyze < %s \
; RUN: -polly-use-llvm-names=false | FileCheck %s -check-prefix=UNNAMED
; ;
; void f(int *A, int b) { ; void f(int *A, int b) {
; int x; ; int x;
; for (int i = 0; i < 1024; i++) { ; for (int i = 0; i < 1024; i++) {
; if (b > i) ; if (b > i)
; x = 0; ; x = 0;
; else if (b < 2 * i) ; else if (b < 2 * i)
; x = 3; ; x = 3;
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

polly/test/ScopInfo/unnamed_stmts.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; This test case verifies that we generate numbered statement names in case ; This test case verifies that we generate numbered statement names in case
; no LLVM-IR names are used in the test case. We also verify, that we ; no LLVM-IR names are used in the test case. We also verify, that we
; distinguish statements named with a number and unnamed statements that happen ; distinguish statements named with a number and unnamed statements that happen
; to have an index identical to a number used in a statement name. ; to have an index identical to a number used in a statement name.
; CHECK: Arrays { ; CHECK: Arrays {
; CHECK-NEXT: float MemRef0[*][%n]; // Element size 4 ; CHECK-NEXT: float MemRef0[*][%n]; // Element size 4
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

polly/test/ScopInfo/unpredictable_nonscop_loop.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-scops -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-scops -disable-output < %s | FileCheck %s -match-full-lines
; Derived from test-suite/MultiSource/Applications/sgefa/blas.c ; Derived from test-suite/MultiSource/Applications/sgefa/blas.c
; ;
; The exit value of %i.0320 in land.rhs is not computable. ; The exit value of %i.0320 in land.rhs is not computable.
; It is still synthesizable in %if.end13---%for.end170 because ; It is still synthesizable in %if.end13---%for.end170 because
; %i.0320 is fixed within the SCoP and therefore just another parameter. ; %i.0320 is fixed within the SCoP and therefore just another parameter.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/ScopInfo/unprofitable_scalar-accs.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=false -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=true -polly-scops -analyze < %s | FileCheck %s --check-prefix=HEURISTIC ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-process-unprofitable=false -polly-unprofitable-scalar-accs=true -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=HEURISTIC
; Check the effect of -polly-unprofitable-scalar-accs ; Check the effect of -polly-unprofitable-scalar-accs
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define void @func(i32 %n, i32 %m, double* noalias nonnull %A) { define void @func(i32 %n, i32 %m, double* noalias nonnull %A) {
entry: entry:
br label %outer.for br label %outer.for
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

polly/test/ScopInfo/unsigned-condition.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %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 35 Lines

polly/test/ScopInfo/unsigned-division-1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N / 2; i++) ; for (unsigned i = 0; i < N / 2; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
Show All 33 Lines

polly/test/ScopInfo/unsigned-division-2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N / 2 + 3; i++) ; for (unsigned i = 0; i < N / 2 + 3; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
Show All 34 Lines

polly/test/ScopInfo/unsigned-division-3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, unsigned char N) { ; void f(int *A, unsigned char N) {
; for (unsigned i = 0; i <= N / -128; i++) ; for (unsigned i = 0; i <= N / -128; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
Show All 33 Lines

polly/test/ScopInfo/unsigned-division-4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, unsigned char N) { ; void f(int *A, unsigned char N) {
; for (unsigned i = 0; i < (N / -128) + 3; i++) ; for (unsigned i = 0; i < (N / -128) + 3; i++)
; A[i]++; ; A[i]++;
; } ; }
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [N] -> { : } ; CHECK-NEXT: [N] -> { : }
Show All 34 Lines

polly/test/ScopInfo/unsigned-division-5.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(int *A, unsigned N) { ; void f(int *A, unsigned N) {
; for (unsigned i = 0; i < N; i++) ; for (unsigned i = 0; i < N; i++)
; A[i / 3] = A[5 * N / 3]; ; A[i / 3] = A[5 * N / 3];
; } ; }
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0] ; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
Show All 40 Lines

polly/test/ScopInfo/unsigned_wrap_uge.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( 63 >= (unsigned)i ) ; if ( 63 >= (unsigned)i )
; A[i] = 42; ; A[i] = 42;
Show All 37 Lines

polly/test/ScopInfo/unsigned_wrap_ugt.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( 64 > (unsigned)i ) ; if ( 64 > (unsigned)i )
; A[i] = 42; ; A[i] = 42;
Show All 37 Lines

polly/test/ScopInfo/unsigned_wrap_ule.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( (unsigned)i <= 63 ) ; if ( (unsigned)i <= 63 )
; A[i] = 42; ; A[i] = 42;
Show All 37 Lines

polly/test/ScopInfo/unsigned_wrap_ult.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; Unsigned wrap-around check. ; Unsigned wrap-around check.
; ;
; for (int i = -1; i < 65 ; i ++ ) ; for (int i = -1; i < 65 ; i ++ )
; if ( (unsigned)i < 64 ) ; if ( (unsigned)i < 64 )
; A[i] = 42; ; A[i] = 42;
Show All 37 Lines

polly/test/ScopInfo/user_context.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-context='[N] -> {: N = 1024}' -analyze < %s | FileCheck %s --check-prefix=CTX ; RUN: opt %loadPolly -polly-context='[N] -> {: N = 1024}' -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=CTX
; RUN: opt %loadPolly -polly-scops -polly-context='[N,M] -> {: 1 = 0}' -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-context='[N,M] -> {: 1 = 0}' -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-scops -polly-context='[] -> {: 1 = 0}' -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-context='[] -> {: 1 = 0}' -polly-print-scops -disable-output < %s | FileCheck %s
; void f(int a[], int N) { ; void f(int a[], int N) {
; int i; ; int i;
; for (i = 0; i < N; ++i) ; for (i = 0; i < N; ++i)
; a[i] = i; ; a[i] = i;
; } ; }
; CHECK: Context: ; CHECK: Context:
Show All 23 Lines

polly/test/ScopInfo/user_provided_assumptions-in-bb-signed-conditional.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; REMARK: remark: <unknown>:0:0: Use user assumption: [n, b] -> { : n <= 100 or (b = 0 and n >= 101) } ; REMARK: remark: <unknown>:0:0: Use user assumption: [n, b] -> { : n <= 100 or (b = 0 and n >= 101) }
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n, b] -> { : -9223372036854775808 <= n <= 9223372036854775807 and ((n <= 100 and -9223372036854775808 <= b <= 9223372036854775807) or (b = 0 and n >= 101)) } ; CHECK-NEXT: [n, b] -> { : -9223372036854775808 <= n <= 9223372036854775807 and ((n <= 100 and -9223372036854775808 <= b <= 9223372036854775807) or (b = 0 and n >= 101)) }
; CHECK-NEXT: Assumed Context: ; CHECK-NEXT: Assumed Context:
; CHECK-NEXT: [n, b] -> { : } ; CHECK-NEXT: [n, b] -> { : }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/ScopInfo/user_provided_assumptions-in-bb-signed.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 } ; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 }
; ;
; void foo(float A[][100], long n) { ; void foo(float A[][100], long n) {
; for (long i = 0; i < n; i++) ; for (long i = 0; i < n; i++)
; A[42][i] = 42.0; ; A[42][i] = 42.0;
; } ; }
Show All 33 Lines

polly/test/ScopInfo/user_provided_assumptions-in-bb-unsigned.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s --check-prefix=REMARK
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; REMARK: remark: <unknown>:0:0: SCoP begins here. ; REMARK: remark: <unknown>:0:0: SCoP begins here.
; REMARK-NEXT: remark: <unknown>:0:0: Use user assumption: [n] -> { : n <= 100 } ; REMARK-NEXT: remark: <unknown>:0:0: Use user assumption: [n] -> { : n <= 100 }
; REMARK-NEXT: remark: <unknown>:0:0: Signed-unsigned restriction: [n] -> { : n < 0 } ; REMARK-NEXT: remark: <unknown>:0:0: Signed-unsigned restriction: [n] -> { : n < 0 }
; REMARK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; REMARK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; ;
; CHECK: Context: ; CHECK: Context:
; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 } ; CHECK-NEXT: [n] -> { : -9223372036854775808 <= n <= 100 }
Show All 38 Lines

polly/test/ScopInfo/user_provided_assumptions.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; ;
; CHECK: remark: <unknown>:0:0: SCoP begins here. ; CHECK: remark: <unknown>:0:0: SCoP begins here.
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : -2147483648 - M <= N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N] -> { : -2147483648 - M <= N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and -2147483648 - M <= N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and -2147483648 - M <= N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and 0 < N <= 2147483647 - M } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [M, N, Debug] -> { : Debug = 0 and 0 < M <= 100 and 0 < N <= 2147483647 - M }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

polly/test/ScopInfo/user_provided_assumptions_2.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; ;
; CHECK: remark: <unknown>:0:0: SCoP begins here. ; CHECK: remark: <unknown>:0:0: SCoP begins here.
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: { : } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: { : }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; SCOP: Context: ; SCOP: Context:
; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 } ; SCOP-NEXT: [N, M] -> { : -2147483648 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 }
; SCOP: Assumed Context: ; SCOP: Assumed Context:
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

polly/test/ScopInfo/user_provided_assumptions_3.ll

; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s --check-prefix=SCOP
; ;
; CHECK: remark: <unknown>:0:0: SCoP begins here. ; CHECK: remark: <unknown>:0:0: SCoP begins here.
; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [N] -> { : N >= 2 } ; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [N] -> { : N >= 2 }
; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here. ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.
; SCOP: Context: ; SCOP: Context:
; SCOP-NEXT: [N, M] -> { : 2 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 } ; SCOP-NEXT: [N, M] -> { : 2 <= N <= 2147483647 and -2147483648 <= M <= 2147483647 }
; SCOP: Assumed Context: ; SCOP: Assumed Context:
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/ScopInfo/variant_base_pointer.ll

; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-codegen -analyze < %s ; RUN: opt %loadPolly -polly-ignore-aliasing -polly-invariant-load-hoisting=true -polly-codegen -disable-output < %s
; ;
; %tmp is added to the list of required hoists by -polly-scops and just ; %tmp is added to the list of required hoists by -polly-scops and just
; assumed to be hoisted. Only -polly-scops recognizes it to be unhoistable ; assumed to be hoisted. Only -polly-scops recognizes it to be unhoistable
; because ir depends on %call which cannot be executed speculatively. ; because ir depends on %call which cannot be executed speculatively.
; ;
; CHECK-NOT: Invariant Accesses: ; CHECK-NOT: Invariant Accesses:
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 28 Lines

polly/test/ScopInfo/variant_load_empty_domain.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Invariant Accesses: { ; CHECK: Invariant Accesses: {
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; CHECK-NOT: Stmt_if_then ; CHECK-NOT: Stmt_if_then
; ;
; ;
; void f(int *A) { ; void f(int *A) {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

polly/test/ScopInfo/wraping_signed_expr_0.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, char N, char p) { ; void f(int *A, char N, char p) {
; for (char i = 0; i < N; i++) { ; for (char i = 0; i < N; i++) {
; A[i + 3] = 0; ; A[i + 3] = 0;
; } ; }
; } ; }
; ;
; The wrap function has no inbounds GEP but the nowrap function has. Therefore, ; The wrap function has no inbounds GEP but the nowrap function has. Therefore,
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

polly/test/ScopInfo/wraping_signed_expr_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(long *A, long N, long p) { ; void f(long *A, long N, long p) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; A[i + 1] = 0; ; A[i + 1] = 0;
; } ; }
; ;
; The wrap function has no inbounds GEP but the nowrap function has. Therefore, ; The wrap function has no inbounds GEP but the nowrap function has. Therefore,
; we will add the assumption that i+1 won't overflow only to the former. ; we will add the assumption that i+1 won't overflow only to the former.
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

polly/test/ScopInfo/wraping_signed_expr_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, int N, int p) { ; void f(int *A, int N, int p) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + 30] = 0; ; A[i + 30] = 0;
; } ; }
; ;
; The wrap function has no inbounds GEP but the nowrap function has. Therefore, ; The wrap function has no inbounds GEP but the nowrap function has. Therefore,
; we will add the assumption that i+1 won't overflow only to the former. ; we will add the assumption that i+1 won't overflow only to the former.
Show All 35 Lines

polly/test/ScopInfo/wraping_signed_expr_3.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(int *A, int N, int p) { ; void f(int *A, int N, int p) {
; for (int i = 0; i < N; i++) ; for (int i = 0; i < N; i++)
; A[i + p] = 0; ; A[i + p] = 0;
; } ; }
; ;
; Note: 2147483648 == 2 ^ 31 ; Note: 2147483648 == 2 ^ 31
; ;
Show All 28 Lines

polly/test/ScopInfo/wraping_signed_expr_4.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; void f(char *A, char N, char p) { ; void f(char *A, char N, char p) {
; for (char i = 0; i < N; i++) ; for (char i = 0; i < N; i++)
; A[p-1] = 0; ; A[p-1] = 0;
; } ; }
; CHECK: Function: wrap ; CHECK: Function: wrap
; ;
Show All 30 Lines

polly/test/ScopInfo/wraping_signed_expr_5.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; We should not generate runtime check for ((int)r1 + (int)r2) as it is known not ; We should not generate runtime check for ((int)r1 + (int)r2) as it is known not
; to overflow. However (p + q) can, thus checks are needed. ; to overflow. However (p + q) can, thus checks are needed.
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK-NEXT: [r1, r2, q, p] -> { : r2 > r1 and (p <= -2147483649 - q or r2 >= 128 + r1 or p >= 2147483648 - q) } ; CHECK-NEXT: [r1, r2, q, p] -> { : r2 > r1 and (p <= -2147483649 - q or r2 >= 128 + r1 or p >= 2147483648 - q) }
; ;
; void wraps(int *A, int p, short q, char r1, char r2) { ; void wraps(int *A, int p, short q, char r1, char r2) {
Show All 35 Lines

polly/test/ScopInfo/wraping_signed_expr_6.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; void foo(float *A, long N) { ; void foo(float *A, long N) {
; for (long i = 0; i < N; i++) ; for (long i = 0; i < N; i++)
; if ((signed char)i < 100) ; if ((signed char)i < 100)
; A[i] += i; ; A[i] += i;
Show All 33 Lines

polly/test/ScopInfo/wraping_signed_expr_7.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Invalid Context: ; CHECK: Invalid Context:
; CHECK: [N] -> { : N >= 129 } ; CHECK: [N] -> { : N >= 129 }
; ;
; void foo(float *A, long N) { ; void foo(float *A, long N) {
; for (long i = 0; i < N;) ; for (long i = 0; i < N;)
; if ((signed char)i++ < 100) ; if ((signed char)i++ < 100)
; A[i] += i; ; A[i] += i;
Show All 33 Lines

polly/test/ScopInfo/wraping_signed_expr_slow_1.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; This checks that the no-wraps checks will be computed fast as some example ; This checks that the no-wraps checks will be computed fast as some example
; already showed huge slowdowns even though the inbounds and nsw flags were ; already showed huge slowdowns even though the inbounds and nsw flags were
; all in place. ; all in place.
; ;
; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark. ; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark.
; void fast(char *A, char N, char M) { ; void fast(char *A, char N, char M) {
; for (char i = 0; i < 8; i++) { ; for (char i = 0; i < 8; i++) {
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

polly/test/ScopInfo/wraping_signed_expr_slow_2.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; This checks that the no-wraps checks will be computed fast as some example ; This checks that the no-wraps checks will be computed fast as some example
; already showed huge slowdowns even though the inbounds and nsw flags were ; already showed huge slowdowns even though the inbounds and nsw flags were
; all in place. ; all in place.
; ;
; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark. ; // Inspired by itrans8x8 in transform8x8.c from the ldecode benchmark.
; void fast(char *A, char N, char M) { ; void fast(char *A, char N, char M) {
; for (char i = 0; i < 8; i++) { ; for (char i = 0; i < 8; i++) {
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

polly/test/ScopInfo/zero_ext_of_truncate.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(unsigned *restrict I, unsigned *restrict A, unsigned N, unsigned M) { ; void f(unsigned *restrict I, unsigned *restrict A, unsigned N, unsigned M) {
; for (unsigned i = 0; i < N; i++) { ; for (unsigned i = 0; i < N; i++) {
; unsigned char V = *I; ; unsigned char V = *I;
; if (V < M) ; if (V < M)
; A[i]++; ; A[i]++;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/ScopInfo/zero_ext_of_truncate_2.ll

; RUN: opt %loadPolly -polly-scops -analyze \ ; RUN: opt %loadPolly -polly-invariant-load-hoisting=true -polly-print-scops -disable-output < %s | FileCheck %s
; RUN: -polly-invariant-load-hoisting=true < %s | FileCheck %s
; ;
; void f(unsigned long *restrict I, unsigned *restrict A, unsigned N) { ; void f(unsigned long *restrict I, unsigned *restrict A, unsigned N) {
; for (unsigned i = 0; i < N; i++) { ; for (unsigned i = 0; i < N; i++) {
; unsigned V = *I; ; unsigned V = *I;
; if (V < i) ; if (V < i)
; A[i]++; ; A[i]++;
; } ; }
; } ; }
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

polly/test/ScopInfo/zero_ext_space_mismatch.ll

; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
; ;
; CHECK: Assumed Context: ; CHECK: Assumed Context:
; CHECK-NEXT: [dim] -> { : dim > 0 } ; CHECK-NEXT: [dim] -> { : dim > 0 }
; CHECK-NEXT: Invalid Context: ; CHECK-NEXT: Invalid Context:
; CHECK-NEXT: [dim] -> { : dim < 0 } ; CHECK-NEXT: [dim] -> { : dim < 0 }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 21 Lines

polly/test/ScopInliner/ignore-declares.ll

; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \ ; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \
; RUN: -polly-scops -analyze < %s ; RUN: -polly-scops -disable-output < %s
; Check that we do not crash if there are declares. We should skip function ; Check that we do not crash if there are declares. We should skip function
; declarations and not try to query for domtree. ; declarations and not try to query for domtree.
declare void @foo() declare void @foo()

polly/test/ScopInliner/invariant-load-func.ll

; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \ ; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \
; RUN: -polly-scops -analyze -polly-invariant-load-hoisting < %s | FileCheck %s ; RUN: -polly-invariant-load-hoisting -polly-print-scops -disable-output < %s | FileCheck %s
; Check that we inline a function that requires invariant load hoisting ; Check that we inline a function that requires invariant load hoisting
; correctly. ; correctly.
; CHECK: Max Loop Depth: 2 ; CHECK: Max Loop Depth: 2
; REQUIRES: pollyacc ; REQUIRES: pollyacc
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

polly/test/ScopInliner/simple-inline-loop.ll

; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \ ; RUN: opt %loadPolly -polly-detect-full-functions -polly-scop-inliner \
; RUN: -polly-scops -analyze < %s | FileCheck %s ; RUN: -polly-print-scops -disable-output < %s | FileCheck %s
; Check that we get the 2 nested loops by inlining `to_be_inlined` into ; Check that we get the 2 nested loops by inlining `to_be_inlined` into
; `inline_site`. ; `inline_site`.
; CHECK: Max Loop Depth: 2 ; CHECK: Max Loop Depth: 2
; static const int N = 1000; ; static const int N = 1000;
; ;
; void to_be_inlined(int A[]) { ; void to_be_inlined(int A[]) {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/Simplify/coalesce_3partials.ll

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

polly/test/Simplify/coalesce_disjointelements.ll

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

polly/test/Simplify/coalesce_overlapping.ll

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

polly/test/Simplify/coalesce_partial.ll

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

polly/test/Simplify/dead_access_load.ll

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

polly/test/Simplify/dead_access_phi.ll

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

polly/test/Simplify/dead_access_value.ll

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

polly/test/Simplify/dead_instruction.ll

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

polly/test/Simplify/emptyaccessdomain.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; A[0] = 42.0; ; A[0] = 42.0;
; } ; }
; ;
define void @emptyaccessdomain(i32 %n, double* noalias nonnull %A) { define void @emptyaccessdomain(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 29 Lines

polly/test/Simplify/exit_phi_accesses-2.ll

; RUN: opt %loadPolly -polly-scops -polly-simplify -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-scops -polly-print-simplify -disable-output < %s | FileCheck %s
; ;
; The use of %sum.next by %phi counts as an escaping use. ; The use of %sum.next by %phi counts as an escaping use.
; Don't remove the scalar write of %sum.next. ; Don't remove the scalar write of %sum.next.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
define float @foo(float* %A) { define float @foo(float* %A) {
entry: entry:
Show All 28 Lines

polly/test/Simplify/func-b320a7.ll

; RUN: opt %loadPolly -polly-simplify -polly-optree -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -polly-optree -disable-output < %s | FileCheck %s -match-full-lines
; llvm.org/PR47098 ; llvm.org/PR47098
; Use-after-free by reference to Stmt remaining in InstStmtMap after removing it has been removed by Scop::simplifyScop. ; Use-after-free by reference to Stmt remaining in InstStmtMap after removing it has been removed by Scop::simplifyScop.
; Removal happened in -polly-simplify, Reference was using in -polly-optree. ; Removal happened in -polly-simplify, Reference was using in -polly-optree.
; Check that Simplify removes the definition of %0 as well of its use. ; Check that Simplify removes the definition of %0 as well of its use.
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.26.28806" target triple = "x86_64-pc-windows-msvc19.26.28806"
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

polly/test/Simplify/gemm.ll

; RUN: opt %loadPolly -polly-import-jscop \ ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s
; RUN: -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s \
; RUN: | FileCheck %s
; ;
; void gemm(float A[][1024], float B[][1024], float C[][1024]) { ; void gemm(float A[][1024], float B[][1024], float C[][1024]) {
; for (long i = 0; i < 1024; i++) ; for (long i = 0; i < 1024; i++)
; for (long j = 0; j < 1024; j++) { ; for (long j = 0; j < 1024; j++) {
; float tmp = C[i][j]; ; float tmp = C[i][j];
; for (long k = 0; k < 1024; k++) ; for (long k = 0; k < 1024; k++)
; tmp += A[i][k] * B[k][j]; ; tmp += A[i][k] * B[k][j];
; C[i][j] = tmp; ; C[i][j] = tmp;
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

polly/test/Simplify/nocoalesce_differentvalues.ll

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

polly/test/Simplify/nocoalesce_elementmismatch.ll

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

polly/test/Simplify/nocoalesce_readbetween.ll

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

polly/test/Simplify/nocoalesce_writebetween.ll

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

polly/test/Simplify/notdead_region_exitphi.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Do not remove dependencies of a phi node in a region's exit block. ; Do not remove dependencies of a phi node in a region's exit block.
; ;
define void @func(i32 %n, double* noalias nonnull %A, double %alpha) { define void @func(i32 %n, double* noalias nonnull %A, double %alpha) {
entry: entry:
br label %for br label %for
Show All 36 Lines

polly/test/Simplify/notdead_region_innerphi.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Do not remove dependencies of a phi node within a region statement (%phi). ; Do not remove dependencies of a phi node within a region statement (%phi).
; ;
define void @func(i32 %n, double* noalias nonnull %A, double %alpha) { define void @func(i32 %n, double* noalias nonnull %A, double %alpha) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

polly/test/Simplify/notredundant_region_loop.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-allow-nonaffine-loops -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-allow-nonaffine-loops -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Do not remove the store in region_entry. It can be executed multiple times ; Do not remove the store in region_entry. It can be executed multiple times
; due to being part of a non-affine loop. ; due to being part of a non-affine loop.
; ;
define void @notredundant_region_loop(i32 %n, double* noalias nonnull %A) { define void @notredundant_region_loop(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 37 Lines

polly/test/Simplify/notredundant_region_middle.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Do not remove redundant stores in the middle of region statements. ; Do not remove redundant stores in the middle of region statements.
; The store in region_true could be removed, but in practice we do try to ; The store in region_true could be removed, but in practice we do try to
; determine the relative ordering of block in region statements. ; determine the relative ordering of block in region statements.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; double val = A[0]; ; double val = A[0];
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

polly/test/Simplify/notredundant_synthesizable_unknownit.ll

; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly -polly-stmt-granularity=bb "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-stmt-granularity=bb "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Do not remove the scalar value write of %i.trunc in inner.for. ; Do not remove the scalar value write of %i.trunc in inner.for.
; It is used by body. ; It is used by body.
; %i.trunc is synthesizable in inner.for, so some code might think it is ; %i.trunc is synthesizable in inner.for, so some code might think it is
; synthesizable everywhere such that no scalar write would be needed. ; synthesizable everywhere such that no scalar write would be needed.
; ;
; Note that -polly-simplify rightfully removes %inner.cond. It should ; Note that -polly-simplify rightfully removes %inner.cond. It should
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

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

polly/test/Simplify/overwritten.ll

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

polly/test/Simplify/overwritten_3phi.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck -match-full-lines %s
; ;
; Remove identical writes ; Remove identical writes
; (two stores in the same statement that write the same value to the same ; (two stores in the same statement that write the same value to the same
; destination) ; destination)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/Simplify/overwritten_3store.ll

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

polly/test/Simplify/overwritten_implicit_and_explicit.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck -match-full-lines %s
; ;
; Remove a store that is overwritten by another store in the same statement. ; Remove a store that is overwritten by another store in the same statement.
; Check that this works even if one of the writes is a scalar MemoryKind. ; Check that this works even if one of the writes is a scalar MemoryKind.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
; A[1] = val; ; A[1] = val;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/Simplify/overwritten_loadbetween.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck -match-full-lines %s
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck -match-full-lines %s
; ;
; Do not remove overwrites when the value is read before. ; Do not remove overwrites when the value is read before.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
;body: ;body:
; A[0] = 21.0; ; A[0] = 21.0;
; val = A[0]; ; val = A[0];
Show All 38 Lines

polly/test/Simplify/overwritten_scalar.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck -match-full-lines %s ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck -match-full-lines %s
; ;
; Remove identical writes ; Remove identical writes
; (two stores in the same statement that write the same value to the same ; (two stores in the same statement that write the same value to the same
; destination) ; destination)
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; body: ; body:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

polly/test/Simplify/pass_existence.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s
; RUN: opt %loadPolly -disable-output "-passes=scop(print<polly-simplify>)" < %s -aa-pipeline=basic-aa < %s | FileCheck %s ; RUN: opt %loadPolly -disable-output "-passes=scop(print<polly-simplify>)" < %s -aa-pipeline=basic-aa < %s | FileCheck %s
; ;
; Simple test for the existence of the Simplify pass. ; Simple test for the existence of the Simplify pass.
; ;
; for (int j = 0; j < n; j += 1) ; for (int j = 0; j < n; j += 1)
; A[0] = 0.0; ; A[0] = 0.0;
; ;
define void @func(i32 %n, double* noalias nonnull %A) { define void @func(i32 %n, double* noalias nonnull %A) {
Show All 25 Lines

polly/test/Simplify/phi_in_regionstmt.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; The PHINode %cond91.sink.sink.us.sink.6 is in the middle of a region ; The PHINode %cond91.sink.sink.us.sink.6 is in the middle of a region
; statement. ; statement.
; Check that we are not expect a MemoryKind::PHI access for it, and no ; Check that we are not expect a MemoryKind::PHI access for it, and no
; assertion guarding querying for it. ; assertion guarding querying for it.
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

polly/test/Simplify/pr33323.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s
; ;
; llvm.org/PR33323 ; llvm.org/PR33323
; ;
; Do not remove the pair (store double %add119, read %add119) as redundant ; Do not remove the pair (store double %add119, read %add119) as redundant
; because the are in the wrong order. ; because the are in the wrong order.
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
Show All 39 Lines

polly/test/Simplify/redundant.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Remove redundant store (a store that writes the same value already ; Remove redundant store (a store that writes the same value already
; at the destination) ; at the destination)
; ;
; for (int j = 0; j < n; j += 1) ; for (int j = 0; j < n; j += 1)
; A[0] = A[0]; ; A[0] = A[0];
; ;
Show All 33 Lines

polly/test/Simplify/redundant_differentindex.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; A store that has a different index than the load it is storing is ; A store that has a different index than the load it is storing is
; not redundant. ; not redundant.
; ;
; for (int j = 0; j < n; j += 1) ; for (int j = 0; j < n; j += 1)
; A[0] = A[0]; ; A[0] = A[0];
; ;
Show All 28 Lines

polly/test/Simplify/redundant_partialwrite.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop-postfix=transformed -polly-print-import-jscop -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Remove a redundant store, if its partial domain is a subset of the ; Remove a redundant store, if its partial domain is a subset of the
; read's domain. ; read's domain.
; ;
define void @redundant_partialwrite(i32 %n, double* noalias nonnull %A) { define void @redundant_partialwrite(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 31 Lines

polly/test/Simplify/redundant_region.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Remove redundant store (a store that writes the same value already ; Remove redundant store (a store that writes the same value already
; at the destination) in a region. ; at the destination) in a region.
; ;
define void @redundant_region(i32 %n, double* noalias nonnull %A) { define void @redundant_region(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
Show All 40 Lines

polly/test/Simplify/redundant_region_scalar.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Remove redundant store (a store that writes the same value already ; Remove redundant store (a store that writes the same value already
; at the destination) in a region. ; at the destination) in a region.
; ;
define void @redundant_region_scalar(i32 %n, double* noalias nonnull %A) { define void @redundant_region_scalar(i32 %n, double* noalias nonnull %A) {
entry: entry:
br label %for br label %for
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

polly/test/Simplify/redundant_scalarwrite.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Remove redundant scalar stores. ; Remove redundant scalar stores.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = A[0]; ; double val = A[0];
; ;
; bodyB: ; bodyB:
Show All 40 Lines

polly/test/Simplify/redundant_storebetween.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly "-passes=scop(print<polly-simplify>)" -disable-output -aa-pipeline=basic-aa < %s | FileCheck %s -match-full-lines
; ;
; Don't remove store where there is another store to the same target ; Don't remove store where there is another store to the same target
; in-between them. ; in-between them.
; ;
; for (int j = 0; j < n; j += 1) ; for (int j = 0; j < n; j += 1)
; A[0] = A[0]; ; A[0] = A[0];
; ;
Show All 30 Lines

polly/test/Simplify/scalability1.ll

; RUN: opt %loadPolly -polly-ignore-inbounds -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-ignore-inbounds -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Test scalability. ; Test scalability.
; ;
define void @func(i32 %n, double* noalias nonnull %A, define void @func(i32 %n, double* noalias nonnull %A,
i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5, i32 %p6, i32 %p7, i32 %p8, i32 %p9, i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5, i32 %p6, i32 %p7, i32 %p8, i32 %p9,
i32 %p10, i32 %p11, i32 %p12, i32 %p13, i32 %p14, i32 %p15, i32 %p16, i32 %p17, i32 %p18, i32 %p19, i32 %p10, i32 %p11, i32 %p12, i32 %p13, i32 %p14, i32 %p15, i32 %p16, i32 %p17, i32 %p18, i32 %p19,
i32 %p20, i32 %p21, i32 %p22, i32 %p23, i32 %p24, i32 %p25, i32 %p26, i32 %p27, i32 %p28, i32 %p29, i32 %p20, i32 %p21, i32 %p22, i32 %p23, i32 %p24, i32 %p25, i32 %p26, i32 %p27, i32 %p28, i32 %p29,
i32 %p30, i32 %p31, i32 %p32) { i32 %p30, i32 %p31, i32 %p32) {
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

polly/test/Simplify/scalability2.ll

; RUN: opt %loadPolly -polly-ignore-inbounds -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-ignore-inbounds -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Test scalability. ; Test scalability.
; ;
define void @func(i32 %n, double* noalias nonnull %A, define void @func(i32 %n, double* noalias nonnull %A,
i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5, i32 %p6, i32 %p7, i32 %p8, i32 %p9, i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %p4, i32 %p5, i32 %p6, i32 %p7, i32 %p8, i32 %p9,
i32 %p10, i32 %p11, i32 %p12, i32 %p13, i32 %p14, i32 %p15, i32 %p16, i32 %p17, i32 %p18, i32 %p19, i32 %p10, i32 %p11, i32 %p12, i32 %p13, i32 %p14, i32 %p15, i32 %p16, i32 %p17, i32 %p18, i32 %p19,
i32 %p20, i32 %p21, i32 %p22, i32 %p23, i32 %p24, i32 %p25, i32 %p26, i32 %p27, i32 %p28, i32 %p29, i32 %p20, i32 %p21, i32 %p22, i32 %p23, i32 %p24, i32 %p25, i32 %p26, i32 %p27, i32 %p28, i32 %p29,
i32 %p30, i32 %p31, i32 %p32, i32 %p33, i32 %p34, i32 %p35, i32 %p36, i32 %p37, i32 %p38, i32 %p39, i32 %p30, i32 %p31, i32 %p32, i32 %p33, i32 %p34, i32 %p35, i32 %p36, i32 %p37, i32 %p38, i32 %p39,
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

polly/test/Simplify/sweep_mapped_phi.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Map %phi to A[j], so the scalar write in Stmt_for_bodyA can be removed. ; Map %phi to A[j], so the scalar write in Stmt_for_bodyA can be removed.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; val = 21.0 + 21.0; ; val = 21.0 + 21.0;
; A[j] = val; ; A[j] = val;
; ;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/Simplify/sweep_mapped_value.ll

; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-print-simplify -disable-output < %s | FileCheck %s -match-full-lines
; ;
; Map %val to A[j], so the scalar write on Stmt_for_bodyB can be removed. ; Map %val to A[j], so the scalar write on Stmt_for_bodyB can be removed.
; ;
; for (int j = 0; j < n; j += 1) { ; for (int j = 0; j < n; j += 1) {
; bodyA: ; bodyA:
; double val = 21.0 + 21.0; ; double val = 21.0 + 21.0;
; A[j] = val; ; A[j] = val;
; ;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

polly/test/Simplify/ununsed_read_in_region_entry.ll

; RUN: opt %loadPolly -polly-simplify -analyze < %s | FileCheck %s -match-full-lines ; RUN: opt %loadPolly -polly-print-simplify -disable-output< %s | FileCheck %s -match-full-lines
; RUN: opt %loadPolly -polly-simplify -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN ; RUN: opt %loadPolly -polly-simplify -polly-codegen -S < %s | FileCheck %s -check-prefix=CODEGEN
; ;
; for (int i = 0; i < n; i+=1) { ; for (int i = 0; i < n; i+=1) {
; (void)A[0]; ; (void)A[0];
; if (21.0 == 0.0) ; if (21.0 == 0.0)
; B[0] = 42.0; ; B[0] = 42.0;
; } ; }
; ;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

polly/test/create_ll.sh

#!/bin/sh -e #!/bin/sh -e
LLFILE=`echo $1 | sed -e 's/\.c/.ll/g'` LLFILE=`echo $1 | sed -e 's/\.c/.ll/g'`
LLFILE_TMP=${LLFILE}.tmp LLFILE_TMP=${LLFILE}.tmp
SOURCE=$1 SOURCE=$1
shift shift
clang -c -S -emit-llvm -O3 -mllvm -disable-llvm-optzns ${SOURCE} -o ${LLFILE} "$@" clang -c -S -emit-llvm -O3 -mllvm -disable-llvm-optzns ${SOURCE} -o ${LLFILE} "$@"
opt -correlated-propagation -mem2reg -instcombine -loop-simplify -indvars \ opt -correlated-propagation -mem2reg -instcombine -loop-simplify -indvars \
-instnamer ${LLFILE} -S -o ${LLFILE_TMP} -instnamer ${LLFILE} -S -o ${LLFILE_TMP}
# Insert a header into the new testcase containing a sample RUN line a FIXME and # Insert a header into the new testcase containing a sample RUN line a FIXME and
# an XFAIL. Then insert the formated C code and finally the LLVM-IR without # an XFAIL. Then insert the formated C code and finally the LLVM-IR without
# attributes, the module ID or the target triple. # attributes, the module ID or the target triple.
echo '; RUN: opt %loadPolly -analyze < %s | FileCheck %s' > ${LLFILE} echo '; RUN: opt %loadPolly -S < %s | FileCheck %s' > ${LLFILE}
echo ';' >> ${LLFILE} echo ';' >> ${LLFILE}
echo '; FIXME: Edit the run line and add checks!' >> ${LLFILE} echo '; FIXME: Edit the run line and add checks!' >> ${LLFILE}
echo ';' >> ${LLFILE} echo ';' >> ${LLFILE}
echo '; XFAIL: *' >> ${LLFILE} echo '; XFAIL: *' >> ${LLFILE}
echo ';' >> ${LLFILE} echo ';' >> ${LLFILE}
clang-format ${SOURCE} | sed -e 's/^[^$]/; &/' -e 's/^$/;/' >> ${LLFILE} clang-format ${SOURCE} | sed -e 's/^[^$]/; &/' -e 's/^$/;/' >> ${LLFILE}
echo ';' >> ${LLFILE} echo ';' >> ${LLFILE}
cat ${LLFILE_TMP} >> ${LLFILE} cat ${LLFILE_TMP} >> ${LLFILE}
sed -i".tmp" '/attributes .* =/d' ${LLFILE} sed -i".tmp" '/attributes .* =/d' ${LLFILE}
sed -i".tmp" -e 's/) \#[0-9]*/)/' ${LLFILE} sed -i".tmp" -e 's/) \#[0-9]*/)/' ${LLFILE}
sed -i".tmp" '/; Function Attrs:/d' ${LLFILE} sed -i".tmp" '/; Function Attrs:/d' ${LLFILE}
sed -i".tmp" '/; ModuleID =/d' ${LLFILE} sed -i".tmp" '/; ModuleID =/d' ${LLFILE}
sed -i".tmp" '/target triple/d' ${LLFILE} sed -i".tmp" '/target triple/d' ${LLFILE}
mv ${LLFILE_TMP} ${LLFILE} mv ${LLFILE_TMP} ${LLFILE}
polly/test/ScopInfo/licm_reduction.ll