Go to the documentation of this file.
42 #include "llvm/Analysis/CFGPrinter.h"
43 #include "llvm/IR/LegacyPassManager.h"
44 #include "llvm/IR/PassManager.h"
45 #include "llvm/IR/Verifier.h"
46 #include "llvm/Passes/PassBuilder.h"
47 #include "llvm/Passes/PassPlugin.h"
48 #include "llvm/Support/CommandLine.h"
49 #include "llvm/Support/TargetSelect.h"
50 #include "llvm/Transforms/IPO.h"
51 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
53 namespace cl = llvm::cl;
55 using llvm::FunctionPassManager;
56 using llvm::OptimizationLevel;
57 using llvm::PassBuilder;
58 using llvm::PassInstrumentationCallbacks;
61 "Configure the polly loop optimizer");
66 cl::desc(
"Enable the polly optimizer (with -O1, -O2 or -O3)"),
70 "polly-only-scop-detection",
71 cl::desc(
"Only run scop detection, but no other optimizations"),
83 "polly-position", cl::desc(
"Where to run polly in the pass pipeline"),
87 "After the loop optimizer (but within the inline cycle)"),
89 "Right before the vectorizer")),
93 static cl::opt<OptimizerChoice>
94 Optimizer(
"polly-optimizer", cl::desc(
"Select the scheduling optimizer"),
97 "The isl scheduling optimizer")),
103 "polly-code-generation", cl::desc(
"How much code-generation to perform"),
104 cl::values(clEnumValN(
CODEGEN_FULL,
"full",
"AST and IR generation"),
105 clEnumValN(
CODEGEN_AST,
"ast",
"Only AST generation"),
106 clEnumValN(
CODEGEN_NONE,
"none",
"No code generation")),
110 static cl::opt<TargetChoice>
111 Target(
"polly-target", cl::desc(
"The hardware to target"),
112 cl::values(clEnumValN(
TARGET_CPU,
"cpu",
"generate CPU code")
115 clEnumValN(
TARGET_GPU,
"gpu",
"generate GPU code"),
117 "generate GPU code (preferably) or CPU code")
124 static cl::opt<VectorizerChoice, true>
Vectorizer(
125 "polly-vectorizer", cl::desc(
"Select the vectorization strategy"),
131 "Strip-mine outer loops for the loop-vectorizer to trigger")),
137 cl::desc(
"Import the polyhedral description of the detected Scops"),
142 cl::desc(
"Fully expand the memory accesses of the detected Scops"),
147 cl::desc(
"Export the polyhedral description of the detected Scops"),
151 cl::desc(
"Run the dead code elimination"),
152 cl::Hidden,
cl::init(
false), cl::ZeroOrMore,
157 cl::desc(
"Highlight the code regions that will be optimized in a "
158 "(CFG BBs and LLVM-IR instructions)"),
163 cl::desc(
"Highlight the code regions that will be optimized in "
168 PollyPrinter(
"polly-dot", cl::desc(
"Enable the Polly DOT printer in -O3"),
169 cl::Hidden, cl::value_desc(
"Run the Polly DOT printer at -O3"),
174 cl::desc(
"Enable the Polly DOT printer in -O3 (no BB content)"), cl::Hidden,
175 cl::value_desc(
"Run the Polly DOT printer at -O3 (no BB content"),
180 cl::desc(
"Show the Polly CFG right after code generation"),
185 cl::desc(
"Enable polyhedral interface of Polly"),
190 cl::desc(
"Enable operand tree forwarding"), cl::Hidden,
195 cl::desc(
"Dump module before Polly transformations into a file "
196 "suffixed with \"-before\""),
200 "polly-dump-before-file",
201 cl::desc(
"Dump module before Polly transformations to the given file"),
206 cl::desc(
"Dump module after Polly transformations into a file "
207 "suffixed with \"-after\""),
211 "polly-dump-after-file",
212 cl::desc(
"Dump module after Polly transformations to the given file"),
217 cl::desc(
"Eliminate scalar loop carried dependences"),
222 cl::desc(
"Simplify SCoP after optimizations"),
226 "polly-enable-prune-unprofitable",
227 cl::desc(
"Bail out on unprofitable SCoPs before rescheduling"), cl::Hidden,
237 struct StaticInitializer {
238 StaticInitializer() {
239 llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
243 static StaticInitializer InitializeEverything;
250 initializePPCGCodeGenerationPass(Registry);
251 initializeManagedMemoryRewritePassPass(Registry);
252 LLVMInitializeNVPTXTarget();
253 LLVMInitializeNVPTXTargetInfo();
254 LLVMInitializeNVPTXTargetMC();
255 LLVMInitializeNVPTXAsmPrinter();
402 PM.add(polly::createManagedMemoryRewritePassPass());
408 PM.add(polly::createManagedMemoryRewritePassPass(
GPUArchChoice,
415 PM.add(llvm::createBarrierNoopPass());
423 PM.add(llvm::createCFGPrinterLegacyPassPass());
440 llvm::legacy::PassManagerBase &PM) {
445 Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
455 llvm::legacy::PassManagerBase &PM) {
460 Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
471 llvm::legacy::PassManagerBase &PM) {
476 Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
494 OptimizationLevel Level,
519 llvm::report_fatal_error(
520 "Option -polly-enable-polyhedralinfo not supported with NPM",
false);
538 llvm::report_fatal_error(
"Option -polly-enable-mse not supported with NPM",
555 llvm::report_fatal_error(
"Option -polly-export not supported with NPM",
578 llvm::report_fatal_error(
"Option -polly-target=gpu not supported for NPM",
584 llvm::report_fatal_error(
585 "Option -polly-target=hybrid not supported for NPM",
false);
589 PM.addPass(PB.buildFunctionSimplificationPipeline(
590 Level, llvm::ThinOrFullLTOPhase::None));
593 PM.addPass(llvm::CFGPrinterPass());
597 llvm::OptimizationLevel Level) {
606 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
613 FPM = FunctionPassManager();
617 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
626 llvm::OptimizationLevel Level) {
635 llvm::report_fatal_error(
636 "Option -polly-dump-before-file at -polly-position=late "
637 "not supported with NPM",
645 llvm::report_fatal_error(
646 "Option -polly-dump-after-file at -polly-position=late "
647 "not supported with NPM",
689 llvm::PassManagerBuilder::EP_ModuleOptimizerEarly,
692 static llvm::RegisterStandardPasses
697 llvm::PassManagerBuilder::EP_VectorizerStart,
702 PassInstrumentationCallbacks *PIC) {
704 #define SCOP_ANALYSIS(NAME, CREATE_PASS) \
705 Proxy.getManager().registerPass([PIC] { \
707 return CREATE_PASS; \
709 #include "PollyPasses.def"
717 PassInstrumentationCallbacks *PIC) {
719 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
720 FAM.registerPass([] { return CREATE_PASS; });
722 #include "PollyPasses.def"
729 ArrayRef<PassBuilder::PipelineElement> Pipeline) {
730 if (llvm::parseAnalysisUtilityPasses<OwningScopAnalysisManagerFunctionProxy>(
731 "polly-scop-analyses", Name, FPM))
734 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
735 if (llvm::parseAnalysisUtilityPasses< \
736 std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name, \
740 #define FUNCTION_PASS(NAME, CREATE_PASS) \
741 if (Name == NAME) { \
742 FPM.addPass(CREATE_PASS); \
746 #include "PollyPasses.def"
751 PassInstrumentationCallbacks *PIC) {
752 #define SCOP_ANALYSIS(NAME, CREATE_PASS) \
753 if (llvm::parseAnalysisUtilityPasses< \
754 std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name, \
758 #define SCOP_PASS(NAME, CREATE_PASS) \
759 if (Name == NAME) { \
760 SPM.addPass(CREATE_PASS); \
764 #include "PollyPasses.def"
770 PassInstrumentationCallbacks *PIC,
771 ArrayRef<PassBuilder::PipelineElement> Pipeline) {
774 if (!Pipeline.empty()) {
776 for (
const auto &E : Pipeline)
785 #define SCOP_ANALYSIS(NAME, CREATE_PASS) \
786 if (Name == "require<" NAME ">") \
788 if (Name == "invalidate<" NAME ">") \
791 #define SCOP_PASS(NAME, CREATE_PASS) \
795 #include "PollyPasses.def"
802 PassInstrumentationCallbacks *PIC,
803 ArrayRef<PassBuilder::PipelineElement> Pipeline) {
804 std::vector<PassBuilder::PipelineElement> FullPipeline;
805 StringRef FirstName = Pipeline.front().Name;
810 FunctionPassManager FPM;
813 for (
auto &Element : Pipeline) {
814 auto &Name = Element.Name;
815 auto &InnerPipeline = Element.InnerPipeline;
816 if (!InnerPipeline.empty())
823 MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
829 PassInstrumentationCallbacks *PIC = PB.getPassInstrumentationCallbacks();
830 PB.registerAnalysisRegistrationCallback([PIC](FunctionAnalysisManager &FAM) {
834 PB.registerPipelineParsingCallback(
835 [PIC](StringRef Name, FunctionPassManager &FPM,
836 ArrayRef<PassBuilder::PipelineElement> Pipeline) ->
bool {
839 PB.registerParseTopLevelPipelineCallback(
840 [PIC](llvm::ModulePassManager &MPM,
841 ArrayRef<PassBuilder::PipelineElement> Pipeline) ->
bool {
850 llvm::report_fatal_error(
851 "Option -polly-position=after-loopopt not supported with NPM",
false);
861 return {LLVM_PLUGIN_API_VERSION,
"Polly", LLVM_VERSION_STRING,
llvm::Pass * createDeLICMWrapperPass()
Create a new DeLICM pass instance.
void initializeDeLICMWrapperPassPass(llvm::PassRegistry &)
static bool isScopPassName(StringRef Name)
void initializeIslAstInfoWrapperPassPass(llvm::PassRegistry &)
static bool shouldEnablePollyForDiagnostic()
static cl::opt< bool > PollyOnlyPrinter("polly-dot-only", cl::desc("Enable the Polly DOT printer in -O3 (no BB content)"), cl::Hidden, cl::value_desc("Run the Polly DOT printer at -O3 (no BB content"), cl::init(false), cl::cat(PollyCategory))
static cl::opt< bool > PollyEnabled("polly", cl::desc("Enable the polly optimizer (with -O1, -O2 or -O3)"), cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
void initializeFlattenSchedulePrinterLegacyPassPass(llvm::PassRegistry &)
static bool parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM, ArrayRef< PassBuilder::PipelineElement > Pipeline)
llvm::Pass * createJSONImporterPass()
void initializeDumpModuleWrapperPassPass(llvm::PassRegistry &)
static cl::opt< TargetChoice > Target("polly-target", cl::desc("The hardware to target"), cl::values(clEnumValN(TARGET_CPU, "cpu", "generate CPU code")), cl::init(TARGET_CPU), cl::ZeroOrMore, cl::cat(PollyCategory))
void initializeScopDetectionPrinterLegacyPassPass(llvm::PassRegistry &)
void initializeDependenceInfoPrinterLegacyFunctionPassPass(llvm::PassRegistry &)
void initializeDeLICMPrinterLegacyPassPass(llvm::PassRegistry &)
static void buildCommonPollyPipeline(FunctionPassManager &PM, OptimizationLevel Level, bool EnableForOpt)
Add the pass sequence required for Polly to the New Pass Manager.
llvm::FunctionPassManager buildCanonicalicationPassesForNPM(llvm::ModulePassManager &MPM, llvm::OptimizationLevel Level)
llvm::Pass * createIslAstInfoWrapperPassPass()
void initializeCodePreparationPass(llvm::PassRegistry &)
llvm::Pass * createDOTOnlyViewerWrapperPass()
void initializeIslAstInfoPrinterLegacyPassPass(llvm::PassRegistry &)
void initializeDependenceInfoPass(llvm::PassRegistry &)
void initializeDeadCodeElimWrapperPassPass(llvm::PassRegistry &)
cl::OptionCategory PollyCategory("Polly Options", "Configure the polly loop optimizer")
static void registerFunctionAnalyses(FunctionAnalysisManager &FAM, PassInstrumentationCallbacks *PIC)
void initializeDependenceInfoWrapperPassPass(llvm::PassRegistry &)
void initializeScopInfoPrinterLegacyRegionPassPass(llvm::PassRegistry &)
AnalysisManager< Scop, ScopStandardAnalysisResults & > ScopAnalysisManager
static cl::opt< bool > EnableDeLICM("polly-enable-delicm", cl::desc("Eliminate scalar loop carried dependences"), cl::Hidden, cl::init(true), cl::cat(PollyCategory))
static bool parseScopPass(StringRef Name, ScopPassManager &SPM, PassInstrumentationCallbacks *PIC)
void initializePollyCanonicalizePass(llvm::PassRegistry &)
void GMPQAPI() init(mp_rat x)
static cl::opt< bool > EnablePolyhedralInfo("polly-enable-polyhedralinfo", cl::desc("Enable polyhedral interface of Polly"), cl::Hidden, cl::init(false), cl::cat(PollyCategory))
void initializeScopInfoPrinterLegacyFunctionPassPass(PassRegistry &)
void initializeJSONImporterPrinterLegacyPassPass(llvm::PassRegistry &)
void initializeDependenceInfoPrinterLegacyPassPass(llvm::PassRegistry &)
static cl::opt< bool > FullyIndexedStaticExpansion("polly-enable-mse", cl::desc("Fully expand the memory accesses of the detected Scops"), cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
static cl::opt< bool > PollyPrinter("polly-dot", cl::desc("Enable the Polly DOT printer in -O3"), cl::Hidden, cl::value_desc("Run the Polly DOT printer at -O3"), cl::init(false), cl::cat(PollyCategory))
void initializeFlattenSchedulePass(llvm::PassRegistry &)
void initializeScopInfoWrapperPassPass(PassRegistry &)
static cl::opt< bool > EnablePruneUnprofitable("polly-enable-prune-unprofitable", cl::desc("Bail out on unprofitable SCoPs before rescheduling"), cl::Hidden, cl::init(true), cl::cat(PollyCategory))
void initializeJSONExporterPass(llvm::PassRegistry &)
static bool parseScopPipeline(StringRef Name, FunctionPassManager &FPM, PassInstrumentationCallbacks *PIC, ArrayRef< PassBuilder::PipelineElement > Pipeline)
llvm::PassPluginLibraryInfo getPollyPluginInfo()
static void registerPollyLoopOptimizerEndPasses(const llvm::PassManagerBuilder &Builder, llvm::legacy::PassManagerBase &PM)
void registerCanonicalicationPasses(llvm::legacy::PassManagerBase &PM)
Schedule a set of canonicalization passes to prepare for Polly.
static cl::opt< bool > EnableSimplify("polly-enable-simplify", cl::desc("Simplify SCoP after optimizations"), cl::init(true), cl::cat(PollyCategory))
AnalysisManagerT & getManager()
void initializeForwardOpTreePrinterLegacyPassPass(PassRegistry &)
static void buildLatePollyPipeline(FunctionPassManager &PM, llvm::OptimizationLevel Level)
void initializeScopInlinerPass(llvm::PassRegistry &)
OwningInnerAnalysisManagerProxy< ScopAnalysisManager, Function > OwningScopAnalysisManagerFunctionProxy
void initializeJSONImporterPass(llvm::PassRegistry &)
static bool shouldEnablePollyForOptimization()
void initializeCodeGenerationPass(llvm::PassRegistry &)
static cl::opt< bool > CFGPrinter("polly-view-cfg", cl::desc("Show the Polly CFG right after code generation"), cl::Hidden, cl::init(false), cl::cat(PollyCategory))
void initializeIslScheduleOptimizerWrapperPassPass(llvm::PassRegistry &)
llvm::Pass * createForwardOpTreeWrapperPass()
llvm::Pass * createPruneUnprofitableWrapperPass()
static cl::list< std::string > DumpAfterFile("polly-dump-after-file", cl::desc("Dump module after Polly transformations to the given file"), cl::ZeroOrMore, cl::cat(PollyCategory))
static cl::opt< CodeGenChoice > CodeGeneration("polly-code-generation", cl::desc("How much code-generation to perform"), cl::values(clEnumValN(CODEGEN_FULL, "full", "AST and IR generation"), clEnumValN(CODEGEN_AST, "ast", "Only AST generation"), clEnumValN(CODEGEN_NONE, "none", "No code generation")), cl::Hidden, cl::init(CODEGEN_FULL), cl::ZeroOrMore, cl::cat(PollyCategory))
llvm::Pass * createCodeGenerationPass()
static llvm::RegisterStandardPasses RegisterPollyOptimizerEarly(llvm::PassManagerBuilder::EP_ModuleOptimizerEarly, registerPollyEarlyAsPossiblePasses)
Register Polly to be available as an optimizer.
llvm::Pass * createDeadCodeElimWrapperPass()
void initializeScopDetectionWrapperPassPass(llvm::PassRegistry &)
void initializeMaximalStaticExpanderPass(llvm::PassRegistry &)
A pass that prints the module into a file.
A pass that isolates a function into a new Module and writes it into a file.
llvm::Pass * createScopDetectionWrapperPassPass()
static void registerPollyEarlyAsPossiblePasses(const llvm::PassManagerBuilder &Builder, llvm::legacy::PassManagerBase &PM)
void initializePruneUnprofitableWrapperPassPass(llvm::PassRegistry &)
llvm::Pass * createPolyhedralInfoPass()
void initializeSimplifyPrinterLegacyPassPass(llvm::PassRegistry &)
static bool parseTopLevelPipeline(llvm::ModulePassManager &MPM, PassInstrumentationCallbacks *PIC, ArrayRef< PassBuilder::PipelineElement > Pipeline)
static llvm::RegisterStandardPasses RegisterPollyOptimizerLoopEnd(llvm::PassManagerBuilder::EP_LoopOptimizerEnd, registerPollyLoopOptimizerEndPasses)
static llvm::RegisterStandardPasses RegisterPollyOptimizerScalarLate(llvm::PassManagerBuilder::EP_VectorizerStart, registerPollyScalarOptimizerLatePasses)
void initializeIslScheduleOptimizerPrinterLegacyPassPass(llvm::PassRegistry &)
static cl::opt< VectorizerChoice, true > Vectorizer("polly-vectorizer", cl::desc("Select the vectorization strategy"), cl::values(clEnumValN(VECTORIZER_NONE, "none", "No Vectorization"), clEnumValN(VECTORIZER_POLLY, "polly", "Polly internal vectorizer"), clEnumValN(VECTORIZER_STRIPMINE, "stripmine", "Strip-mine outer loops for the loop-vectorizer to trigger")), cl::location(PollyVectorizerChoice), cl::init(VECTORIZER_NONE), cl::ZeroOrMore, cl::cat(PollyCategory))
void initializeForwardOpTreeWrapperPassPass(PassRegistry &)
llvm::Pass * createDOTOnlyPrinterWrapperPass()
void initializeSimplifyWrapperPassPass(llvm::PassRegistry &)
llvm::Pass * createScopInfoRegionPassPass()
@ POSITION_BEFORE_VECTORIZER
This pass imports a scop from a jscop file.
PassManager< Scop, ScopAnalysisManager, ScopStandardAnalysisResults &, SPMUpdater & > ScopPassManager
VectorizerChoice PollyVectorizerChoice
GPURuntime GPURuntimeChoice
Use for pass instantiation defaults.
llvm::FunctionPass * createCodegenCleanupPass()
static OwningScopAnalysisManagerFunctionProxy createScopAnalyses(FunctionAnalysisManager &FAM, PassInstrumentationCallbacks *PIC)
void initializePolyhedralInfoPrinterLegacyPassPass(llvm::PassRegistry &)
OuterAnalysisManagerProxy< FunctionAnalysisManager, Scop, ScopStandardAnalysisResults & > FunctionAnalysisManagerScopProxy
void initializePollyPasses(llvm::PassRegistry &Registry)
static cl::list< std::string > DumpBeforeFile("polly-dump-before-file", cl::desc("Dump module before Polly transformations to the given file"), cl::cat(PollyCategory))
FunctionToScopPassAdaptor< ScopPassT > createFunctionToScopPassAdaptor(ScopPassT Pass)
llvm::Pass * createSimplifyWrapperPass(int)
Create a Simplify pass.
void registerPollyPasses(llvm::PassBuilder &PB)
static cl::opt< bool > EnableForwardOpTree("polly-enable-optree", cl::desc("Enable operand tree forwarding"), cl::Hidden, cl::init(true), cl::cat(PollyCategory))
llvm::Pass * createMaximalStaticExpansionPass()
static cl::opt< bool > DumpBefore("polly-dump-before", cl::desc("Dump module before Polly transformations into a file " "suffixed with \"-before\""), cl::init(false), cl::cat(PollyCategory))
llvm::Pass * createCodePreparationPass()
llvm::Pass * createIslScheduleOptimizerWrapperPass()
static cl::opt< PassPositionChoice > PassPosition("polly-position", cl::desc("Where to run polly in the pass pipeline"), cl::values(clEnumValN(POSITION_EARLY, "early", "Before everything"), clEnumValN(POSITION_AFTER_LOOPOPT, "after-loopopt", "After the loop optimizer (but within the inline cycle)"), clEnumValN(POSITION_BEFORE_VECTORIZER, "before-vectorizer", "Right before the vectorizer")), cl::Hidden, cl::init(POSITION_BEFORE_VECTORIZER), cl::ZeroOrMore, cl::cat(PollyCategory))
llvm::Pass * createJSONExporterPass()
static cl::opt< bool > ExportJScop("polly-export", cl::desc("Export the polyhedral description of the detected Scops"), cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
llvm::ModulePass * createDumpModuleWrapperPass(std::string Filename, bool IsSuffix)
Create a pass that prints the module into a file.
void initializeCodegenCleanupPass(llvm::PassRegistry &)
static cl::opt< bool > PollyViewer("polly-show", cl::desc("Highlight the code regions that will be optimized in a " "(CFG BBs and LLVM-IR instructions)"), cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
static cl::opt< bool > PollyDetectOnly("polly-only-scop-detection", cl::desc("Only run scop detection, but no other optimizations"), cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
static cl::opt< bool > DeadCodeElim("polly-run-dce", cl::desc("Run the dead code elimination"), cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
void initializeScopInfoRegionPassPass(PassRegistry &)
static cl::opt< bool > PollyOnlyViewer("polly-show-only", cl::desc("Highlight the code regions that will be optimized in " "a (CFG only BBs)"), cl::init(false), cl::cat(PollyCategory))
static cl::opt< bool > DumpAfter("polly-dump-after", cl::desc("Dump module after Polly transformations into a file " "suffixed with \"-after\""), cl::init(false), cl::cat(PollyCategory))
llvm::Pass * createDOTViewerWrapperPass()
static cl::opt< OptimizerChoice > Optimizer("polly-optimizer", cl::desc("Select the scheduling optimizer"), cl::values(clEnumValN(OPTIMIZER_NONE, "none", "No optimizer"), clEnumValN(OPTIMIZER_ISL, "isl", "The isl scheduling optimizer")), cl::Hidden, cl::init(OPTIMIZER_ISL), cl::ZeroOrMore, cl::cat(PollyCategory))
static void registerPollyScalarOptimizerLatePasses(const llvm::PassManagerBuilder &Builder, llvm::legacy::PassManagerBase &PM)
llvm::Pass * createDOTPrinterWrapperPass()
static cl::opt< bool > ImportJScop("polly-import", cl::desc("Import the polyhedral description of the detected Scops"), cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory))
void initializePolyhedralInfoPass(llvm::PassRegistry &)
static void buildEarlyPollyPipeline(llvm::ModulePassManager &MPM, llvm::OptimizationLevel Level)