[polly] Remove legacy pass manager hooks

[aeubanks]

Summary

And some options that only throw errors with the new PM.

[aeubanks]

remove legacy PM tests
remove unused function

[Meinersbur]

-enable-new-pm is going to be removed from opt? What is that patch doing that?

polly/test/Support/defaultpipelines.ll

0–6

[Meinersbur]

polly/lib/Support/RegisterPasses.cpp

587

b) (POSITION_AFTER_LOOPOPT is not supported by the NPM because there is no extension point). Maybe remove it entirely?

[aeubanks]

address comments

[aeubanks]

In D136621#3885759, @Meinersbur wrote:

-enable-new-pm is going to be removed from opt? What is that patch doing that?

it's explicitly for the legacy PM -> new PM migration, which has basically already happened. on discourse we've talked about how to deal with the option, and we're now trying to remove it

polly/lib/Support/RegisterPasses.cpp

587

done.

that extension point looks like it was specifically for loop passes, but due to the legacy PM design it's possible to add non-loop passes and have it still run like that. so perhaps not worth porting to the new PM

[Meinersbur]

Some other Polly options become inaccessible using any pipeline builder: PollyACC (-polly-target), static expansion (-polly-enable-mse), polyhedral info (-polly-enable-polyhedralinfo), and JSON export (-polly-export).

-polly-target, -polly-enable-mse and -polly-enable-polyhedralinfo are experiments that are effectively unmaintained now and I think should also be removed in this patch (that is, the cl::opt options, I can remove the passes separately at some point unless someone jumps in to update them to the NPM)

I will commit a patch that makes -polly-export usable with the NPM.

polly/lib/Support/RegisterPasses.cpp

587

it's possible to add non-loop passes and have it still run like that

do you mean impossible? I can only add loop passes at that point while Polly uses function passes.

That extension point was added to the legacy pass manager by @grosser explicitly to implement -polly-position=after-loopopt. I am not aware of any other use of it.

In any case, I never used that position and therefore fine with removing it.

[Meinersbur]

MaximalStaticExpansion expansion was actually already ported to the NPM in D125870. I made the NPM pass builder use it in rGb150d34c47ef.

That is, only the flags -polly-target and -polly-enable-polyhedralinfo remain to have no function without the legacy pass manager (other than throwing a fatal error) and should be removed with this patch.

[aeubanks]

remove more options

[Meinersbur]

LGTM

polly/lib/Support/RegisterPasses.cpp

 
 static cl::opt<bool> PollyDetectOnly(
     "polly-only-scop-detection",
     cl::desc("Only run scop detection, but no other optimizations"),
     cl::cat(PollyCategory));
 
 enum PassPositionChoice {
   POSITION_EARLY,
-  POSITION_AFTER_LOOPOPT,
   POSITION_BEFORE_VECTORIZER
 };
 
 enum OptimizerChoice { OPTIMIZER_NONE, OPTIMIZER_ISL };
 
 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::cat(PollyCategory));
 
 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::cat(PollyCategory));
 
 enum CodeGenChoice { CODEGEN_FULL, CODEGEN_AST, CODEGEN_NONE };
 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::cat(PollyCategory));
 
-enum TargetChoice { TARGET_CPU, TARGET_GPU, TARGET_HYBRID };
-static cl::opt<TargetChoice>
-    Target("polly-target", cl::desc("The hardware to target"),
-           cl::values(clEnumValN(TARGET_CPU, "cpu", "generate CPU code")
-#ifdef GPU_CODEGEN
-                          ,
-                      clEnumValN(TARGET_GPU, "gpu", "generate GPU code"),
-                      clEnumValN(TARGET_HYBRID, "hybrid",
-                                 "generate GPU code (preferably) or CPU code")
-#endif
-                          ),
-           cl::init(TARGET_CPU), cl::cat(PollyCategory));
-
 VectorizerChoice PollyVectorizerChoice;
 
 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(
static cl::opt<bool> PollyOnlyPrinter(
     cl::init(false), cl::cat(PollyCategory));
 
 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));
 
 static cl::opt<bool>
-    EnablePolyhedralInfo("polly-enable-polyhedralinfo",
-                         cl::desc("Enable polyhedral interface of Polly"),
-                         cl::Hidden, cl::init(false), cl::cat(PollyCategory));
-
-static cl::opt<bool>
     EnableForwardOpTree("polly-enable-optree",
                         cl::desc("Enable operand tree forwarding"), cl::Hidden,
                         cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool>
     DumpBefore("polly-dump-before",
                cl::desc("Dump module before Polly transformations into a file "
                         "suffixed with \"-before\""),
#endif
   initializeDeLICMWrapperPassPass(Registry);
   initializeDeLICMPrinterLegacyPassPass(Registry);
   initializeSimplifyWrapperPassPass(Registry);
   initializeSimplifyPrinterLegacyPassPass(Registry);
   initializeDumpModuleWrapperPassPass(Registry);
   initializePruneUnprofitableWrapperPassPass(Registry);
 }
 
+static bool shouldEnablePollyForOptimization() { return PollyEnabled; }
+
+static bool shouldEnablePollyForDiagnostic() {
+  // FIXME: PollyTrackFailures is user-controlled, should not be set
+  // programmatically.
+  if (PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer)
+    PollyTrackFailures = true;
+
+  return PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer ||
+         ExportJScop;
+}
+
 /// Register Polly passes such that they form a polyhedral optimizer.
 ///
 /// 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
 /// a set of preparing transformations that canonicalize the LLVM-IR such that
 /// the LLVM-IR is easier for us to understand and to optimizes. On the
 /// canonicalized LLVM-IR we first run the ScopDetection pass, which detects
 /// static control flow regions. Those regions are then translated by the

 ///
 /// As scheduling optimizer we support the isl scheduling optimizer
 /// (http://freecode.com/projects/isl).
 /// It is also possible to run Polly with no optimizer. This mode is mainly
 /// provided to analyze the run and compile time changes caused by the
 /// scheduling optimizer.
 ///
 /// Polly supports the isl internal code generator.
-static void registerPollyPasses(llvm::legacy::PassManagerBase &PM,
-                                bool EnableForOpt) {
-  if (DumpBefore)
-    PM.add(polly::createDumpModuleWrapperPass("-before", true));
-  for (auto &Filename : DumpBeforeFile)
-    PM.add(polly::createDumpModuleWrapperPass(Filename, false));
-
-  PM.add(polly::createCodePreparationPass());
-  PM.add(polly::createScopDetectionWrapperPassPass());
-
-  if (PollyDetectOnly)
-    return;
-
-  if (PollyViewer)
-    PM.add(polly::createDOTViewerWrapperPass());
-  if (PollyOnlyViewer)
-    PM.add(polly::createDOTOnlyViewerWrapperPass());
-  if (PollyPrinter)
-    PM.add(polly::createDOTPrinterWrapperPass());
-  if (PollyOnlyPrinter)
-    PM.add(polly::createDOTOnlyPrinterWrapperPass());
-  PM.add(polly::createScopInfoRegionPassPass());
-  if (EnablePolyhedralInfo)
-    PM.add(polly::createPolyhedralInfoPass());
-
-  if (EnableSimplify)
-    PM.add(polly::createSimplifyWrapperPass(0));
-  if (EnableForwardOpTree)
-    PM.add(polly::createForwardOpTreeWrapperPass());
-  if (EnableDeLICM)
-    PM.add(polly::createDeLICMWrapperPass());
-  if (EnableSimplify)
-    PM.add(polly::createSimplifyWrapperPass(1));
-
-  if (ImportJScop)
-    PM.add(polly::createJSONImporterPass());
-
-  if (DeadCodeElim)
-    PM.add(polly::createDeadCodeElimWrapperPass());
-
-  if (FullyIndexedStaticExpansion)
-    PM.add(polly::createMaximalStaticExpansionPass());
-
-  if (EnablePruneUnprofitable)
-    PM.add(polly::createPruneUnprofitableWrapperPass());
-
-#ifdef GPU_CODEGEN
-  if (Target == TARGET_HYBRID)
-    PM.add(
-        polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
-#endif
-  if (Target == TARGET_CPU || Target == TARGET_HYBRID)
-    switch (Optimizer) {
-    case OPTIMIZER_NONE:
-      break; /* Do nothing */
-
-    case OPTIMIZER_ISL:
-      PM.add(polly::createIslScheduleOptimizerWrapperPass());
-      break;
-    }
-
-  if (ExportJScop)
-    PM.add(polly::createJSONExporterPass());
-
-  if (!EnableForOpt)
-    return;
-
-  if (Target == TARGET_CPU || Target == TARGET_HYBRID)
-    switch (CodeGeneration) {
-    case CODEGEN_AST:
-      PM.add(polly::createIslAstInfoWrapperPassPass());
-      break;
-    case CODEGEN_FULL:
-      PM.add(polly::createCodeGenerationPass());
-      break;
-    case CODEGEN_NONE:
-      break;
-    }
-#ifdef GPU_CODEGEN
-  else {
-    PM.add(
-        polly::createPPCGCodeGenerationPass(GPUArchChoice, GPURuntimeChoice));
-    PM.add(polly::createManagedMemoryRewritePassPass());
-  }
-#endif
-
-#ifdef GPU_CODEGEN
-  if (Target == TARGET_HYBRID)
-    PM.add(polly::createManagedMemoryRewritePassPass(GPUArchChoice,
-                                                     GPURuntimeChoice));
-#endif
-
-  // FIXME: This dummy ModulePass keeps some programs from miscompiling,
-  // probably some not correctly preserved analyses. It acts as a barrier to
-  // force all analysis results to be recomputed.
-  PM.add(llvm::createBarrierNoopPass());
-
-  if (DumpAfter)
-    PM.add(polly::createDumpModuleWrapperPass("-after", true));
-  for (auto &Filename : DumpAfterFile)
-    PM.add(polly::createDumpModuleWrapperPass(Filename, false));
-
-  if (CFGPrinter)
-    PM.add(llvm::createCFGPrinterLegacyPassPass());
-}
-
-static bool shouldEnablePollyForOptimization() { return PollyEnabled; }
-
-static bool shouldEnablePollyForDiagnostic() {
-  // FIXME: PollyTrackFailures is user-controlled, should not be set
-  // programmatically.
-  if (PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer)
-    PollyTrackFailures = true;
-
-  return PollyOnlyPrinter || PollyPrinter || PollyOnlyViewer || PollyViewer ||
-         ExportJScop;
-}
-
-static void
-registerPollyEarlyAsPossiblePasses(const llvm::PassManagerBuilder &Builder,
-                                   llvm::legacy::PassManagerBase &PM) {
-  if (PassPosition != POSITION_EARLY)
-    return;
-
-  bool EnableForOpt = shouldEnablePollyForOptimization() &&
-                      Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
-  if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
-    return;
-
-  registerCanonicalicationPasses(PM);
-  registerPollyPasses(PM, EnableForOpt);
-}
-
-static void
-registerPollyLoopOptimizerEndPasses(const llvm::PassManagerBuilder &Builder,
-                                    llvm::legacy::PassManagerBase &PM) {
-  if (PassPosition != POSITION_AFTER_LOOPOPT)
-    return;
-
-  bool EnableForOpt = shouldEnablePollyForOptimization() &&
-                      Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
-  if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
-    return;
-
-  registerPollyPasses(PM, EnableForOpt);
-  if (EnableForOpt)
-    PM.add(createCodegenCleanupPass());
-}
-
-static void
-registerPollyScalarOptimizerLatePasses(const llvm::PassManagerBuilder &Builder,
-                                       llvm::legacy::PassManagerBase &PM) {
-  if (PassPosition != POSITION_BEFORE_VECTORIZER)
-    return;
-
-  bool EnableForOpt = shouldEnablePollyForOptimization() &&
-                      Builder.OptLevel >= 1 && Builder.SizeLevel == 0;
-  if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
-    return;
-
-  polly::registerPollyPasses(PM, EnableForOpt);
-  if (EnableForOpt)
-    PM.add(createCodegenCleanupPass());
-}
 
 /// Add the pass sequence required for Polly to the New Pass Manager.
 ///
 /// @param PM           The pass manager itself.
 /// @param Level        The optimization level. Used for the cleanup of Polly's
 ///                     output.
 /// @param EnableForOpt Whether to add Polly IR transformations. If False, only
 ///                     the analysis passes are added, skipping Polly itself.
static void buildCommonPollyPipeline(FunctionPassManager &PM,
   if (PollyViewer)
     PM.addPass(ScopViewer());
   if (PollyOnlyViewer)
     PM.addPass(ScopOnlyViewer());
   if (PollyPrinter)
     PM.addPass(ScopPrinter());
   if (PollyOnlyPrinter)
     PM.addPass(ScopOnlyPrinter());
-  if (EnablePolyhedralInfo)
-    llvm::report_fatal_error(
-        "Option -polly-enable-polyhedralinfo not supported with NPM", false);
-
   if (EnableSimplify)
     SPM.addPass(SimplifyPass(0));
   if (EnableForwardOpTree)
     SPM.addPass(ForwardOpTreePass());
   if (EnableDeLICM)
     SPM.addPass(DeLICMPass());
   if (EnableSimplify)
     SPM.addPass(SimplifyPass(1));
 
   if (ImportJScop)
     SPM.addPass(JSONImportPass());
 
   if (DeadCodeElim)
     SPM.addPass(DeadCodeElimPass());
 
   if (FullyIndexedStaticExpansion)
     SPM.addPass(MaximalStaticExpansionPass());
 
   if (EnablePruneUnprofitable)
     SPM.addPass(PruneUnprofitablePass());
 
-  if (Target == TARGET_CPU || Target == TARGET_HYBRID) {
-    switch (Optimizer) {
-    case OPTIMIZER_NONE:
-      break; /* Do nothing */
-    case OPTIMIZER_ISL:
-      SPM.addPass(IslScheduleOptimizerPass());
-      break;
-    }
-  }
 
   if (ExportJScop)
     SPM.addPass(JSONExportPass());
 
   if (!EnableForOpt)
     return;
 
-  if (Target == TARGET_CPU || Target == TARGET_HYBRID) {
-    switch (CodeGeneration) {
-    case CODEGEN_AST:
-      SPM.addPass(
-          llvm::RequireAnalysisPass<IslAstAnalysis, Scop, ScopAnalysisManager,
-                                    ScopStandardAnalysisResults &,
-                                    SPMUpdater &>());
-      break;
-    case CODEGEN_FULL:
-      SPM.addPass(CodeGenerationPass());
-      break;
-    case CODEGEN_NONE:
-      break;
-    }
-  }
-#ifdef GPU_CODEGEN
-  else
-    llvm::report_fatal_error("Option -polly-target=gpu not supported for NPM",
-                             false);
-#endif
-
-#ifdef GPU_CODEGEN
-  if (Target == TARGET_HYBRID)
-    llvm::report_fatal_error(
-        "Option -polly-target=hybrid not supported for NPM", false);
-#endif
 
   PM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
   PM.addPass(PB.buildFunctionSimplificationPipeline(
       Level, llvm::ThinOrFullLTOPhase::None)); // Cleanup
 
   if (CFGPrinter)
     PM.addPass(llvm::CFGPrinterPass());
 }
if (DumpAfter)
     PM.addPass(DumpFunctionPass("-after"));
   if (!DumpAfterFile.empty())
     llvm::report_fatal_error(
         "Option -polly-dump-after-file at -polly-position=late "
         "not supported with NPM",
         false);
 }
 
-/// Register Polly to be available as an optimizer
-///
-///
-/// We can currently run Polly at three different points int the pass manager.
-/// a) very early, b) after the canonicalizing loop transformations and c) right
-/// before the vectorizer.
-///
-/// The default is currently a), to register Polly such that it runs as early as
-/// possible. This has several implications:
-///
-///   1) We need to schedule more canonicalization passes
-///
-///   As nothing is run before Polly, it is necessary to run a set of preparing
-///   transformations before Polly to canonicalize the LLVM-IR and to allow
-///   Polly to detect and understand the code.
-///
-///   2) LICM and LoopIdiom pass have not yet been run
-///
-///   Loop invariant code motion as well as the loop idiom recognition pass make
-///   it more difficult for Polly to transform code. LICM may introduce
-///   additional data dependences that are hard to eliminate and the loop idiom
-///   recognition pass may introduce calls to memset that we currently do not
-///   understand. By running Polly early enough (meaning before these passes) we
-///   avoid difficulties that may be introduced by these passes.
-///
-///   3) We get the full -O3 optimization sequence after Polly
-///
-///   The LLVM-IR that is generated by Polly has been optimized on a high level,
-///   but it may be rather inefficient on the lower/scalar level. By scheduling
-///   Polly before all other passes, we have the full sequence of -O3
-///   optimizations behind us, such that inefficiencies on the low level can
-///   be optimized away.
-///
-/// We are currently evaluating the benefit or running Polly at position b) or
-/// c). b) is likely too early as it interacts with the inliner. c) is nice
-/// as everything is fully inlined and canonicalized, but we need to be able
-/// to handle LICMed code to make it useful.
-static llvm::RegisterStandardPasses RegisterPollyOptimizerEarly(
-    llvm::PassManagerBuilder::EP_ModuleOptimizerEarly,
-    registerPollyEarlyAsPossiblePasses);
-
-static llvm::RegisterStandardPasses
-    RegisterPollyOptimizerLoopEnd(llvm::PassManagerBuilder::EP_LoopOptimizerEnd,
-                                  registerPollyLoopOptimizerEndPasses);
-
-static llvm::RegisterStandardPasses RegisterPollyOptimizerScalarLate(
-    llvm::PassManagerBuilder::EP_VectorizerStart,
-    registerPollyScalarOptimizerLatePasses);
-
 static OwningScopAnalysisManagerFunctionProxy
 createScopAnalyses(FunctionAnalysisManager &FAM,
                    PassInstrumentationCallbacks *PIC) {
   OwningScopAnalysisManagerFunctionProxy Proxy;
 #define SCOP_ANALYSIS(NAME, CREATE_PASS)                                       \
   Proxy.getManager().registerPass([PIC] {                                      \
     (void)PIC;                                                                 \
     return CREATE_PASS;                                                        \
parseTopLevelPipeline(llvm::ModulePassManager &MPM,
   }
 
   FPM.addPass(createFunctionToScopPassAdaptor(std::move(SPM)));
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
   return true;
 }
 
+/// Register Polly to be available as an optimizer
+///
+///
+/// We can currently run Polly at two different points int the pass manager.
+/// a) very early, b) right before the vectorizer.
+///
+/// The default is currently a), to register Polly such that it runs as early as
+/// possible. This has several implications:
+///
+///   1) We need to schedule more canonicalization passes
+///
+///   As nothing is run before Polly, it is necessary to run a set of preparing
+///   transformations before Polly to canonicalize the LLVM-IR and to allow
+///   Polly to detect and understand the code.
+///
+///   2) We get the full -O3 optimization sequence after Polly
+///
+///   The LLVM-IR that is generated by Polly has been optimized on a high level,
+///   but it may be rather inefficient on the lower/scalar level. By scheduling
+///   Polly before all other passes, we have the full sequence of -O3
+///   optimizations behind us, such that inefficiencies on the low level can
+///   be optimized away.
+///
+/// We are currently evaluating the benefit or running Polly at b). b) is nice
+/// as everything is fully inlined and canonicalized, but we need to be able to
+/// handle LICMed code to make it useful.
 void registerPollyPasses(PassBuilder &PB) {
   PassInstrumentationCallbacks *PIC = PB.getPassInstrumentationCallbacks();
   PB.registerAnalysisRegistrationCallback([PIC](FunctionAnalysisManager &FAM) {
     registerFunctionAnalyses(FAM, PIC);
   });
   PB.registerPipelineParsingCallback(parseFunctionPipeline);
   PB.registerPipelineParsingCallback(
       [PIC](StringRef Name, FunctionPassManager &FPM,
             ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
         return parseScopPipeline(Name, FPM, PIC, Pipeline);
       });
   PB.registerParseTopLevelPipelineCallback(
       [PIC](llvm::ModulePassManager &MPM,
             ArrayRef<PassBuilder::PipelineElement> Pipeline) -> bool {
         return parseTopLevelPipeline(MPM, PIC, Pipeline);
       });
 
   switch (PassPosition) {
   case POSITION_EARLY:
     PB.registerPipelineStartEPCallback(buildEarlyPollyPipeline);
     break;
-  case POSITION_AFTER_LOOPOPT:
-    llvm::report_fatal_error(
-        "Option -polly-position=after-loopopt not supported with NPM", false);
-    break;
   case POSITION_BEFORE_VECTORIZER:
     PB.registerVectorizerStartEPCallback(buildLatePollyPipeline);
     break;
   }
 }
 } // namespace polly
 
 llvm::PassPluginLibraryInfo getPollyPluginInfo() {
   return {LLVM_PLUGIN_API_VERSION, "Polly", LLVM_VERSION_STRING,
           polly::registerPollyPasses};
 }

polly/test/Support/defaultpipelines.ll

-; Legacy pass manager
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -O0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -O1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -O2 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -O3 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -Os -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
-; RUN: opt %loadPolly -enable-new-pm=0 -polly -Oz -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
-;
-; New pass manager
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -O0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -O1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -O2 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -O3 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -Os -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -polly -Oz -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
+; RUN: opt %loadNPMPolly -polly -O0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
+; RUN: opt %loadNPMPolly -polly -O1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
+; RUN: opt %loadNPMPolly -polly -O2 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
+; RUN: opt %loadNPMPolly -polly -O3 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=ON
+; RUN: opt %loadNPMPolly -polly -Os -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
+; RUN: opt %loadNPMPolly -polly -Oz -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=OFF
 ;
 ; Check that Polly's default pipeline works from detection to code generation
 ; with either pass manager.
 ; The presence of the BB polly.stmt.body.lr.ph indicates that the statement
 ; has been re-generated by Polly. It should not have been merged with other
 ; BBs by SimplifyCFG.
 ;
 ; for (int j = 0; j < n; j += 1) {

polly/test/Support/dumpmodule.ll

-; Legacy pass manager
-; RUN: opt %loadPolly -enable-new-pm=0 -O3 -polly -polly-position=early             -polly-dump-before-file=%t-legacy-before-early.ll --disable-output < %s && FileCheck --input-file=%t-legacy-before-early.ll --check-prefix=EARLY  %s
-; RUN: opt %loadPolly -enable-new-pm=0 -O3 -polly -polly-position=before-vectorizer -polly-dump-before-file=%t-legacy-before-late.ll  --disable-output < %s && FileCheck --input-file=%t-legacy-before-late.ll  --check-prefix=LATE   %s
-; RUN: opt %loadPolly -enable-new-pm=0 -O3 -polly -polly-position=early             -polly-dump-after-file=%t-legacy-after-early.ll   --disable-output < %s && FileCheck --input-file=%t-legacy-after-early.ll  --check-prefix=EARLY --check-prefix=AFTEREARLY %s
-; RUN: opt %loadPolly -enable-new-pm=0 -O3 -polly -polly-position=before-vectorizer -polly-dump-after-file=%t-legacy-after-late.ll    --disable-output < %s && FileCheck --input-file=%t-legacy-after-late.ll   --check-prefix=LATE  --check-prefix=AFTERLATE  %s
-;
-; New pass manager
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -O3 -polly -polly-position=early             -polly-dump-before-file=%t-npm-before-early.ll    --disable-output < %s && FileCheck --input-file=%t-npm-before-early.ll    --check-prefix=EARLY %s
-; RUN: opt %loadNPMPolly -enable-new-pm=1 -O3 -polly -polly-position=early             -polly-dump-after-file=%t-npm-after-early.ll      --disable-output < %s && FileCheck --input-file=%t-npm-after-early.ll     --check-prefix=EARLY --check-prefix=AFTEREARLY %s
+; RUN: opt %loadNPMPolly -O3 -polly -polly-position=early             -polly-dump-before-file=%t-npm-before-early.ll    --disable-output < %s && FileCheck --input-file=%t-npm-before-early.ll    --check-prefix=EARLY %s
+; RUN: opt %loadNPMPolly -O3 -polly -polly-position=early             -polly-dump-after-file=%t-npm-after-early.ll      --disable-output < %s && FileCheck --input-file=%t-npm-after-early.ll     --check-prefix=EARLY --check-prefix=AFTEREARLY %s
 ;
 ; Check the module dumping before Polly at specific positions in the
 ; pass pipeline.
 ;
 ; void callee(int n, double A[], int i) {
 ;   for (int j = 0; j < n; j += 1)
 ;     A[i+j] = 42.0;
 ; }

polly/test/Support/pipelineposition.ll

-; Legacy pass manager
-; RUN: opt %loadPolly -O3 -enable-new-pm=0 -polly -polly-position=early                    -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=NOINLINE
-; RUN: opt %loadPolly -O3 -enable-new-pm=0 -polly -polly-position=early -polly-run-inliner -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED1
-; RUN: opt %loadPolly -O3 -enable-new-pm=0 -polly -polly-position=after-loopopt            -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED2
-; RUN: opt %loadPolly -O3 -enable-new-pm=0 -polly -polly-position=before-vectorizer        -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED3
-;
-; New pass manager
-; RUN: opt %loadNPMPolly -O3 -enable-new-pm=1 -polly -polly-position=early                    -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=NOINLINE
-; RUN: opt %loadNPMPolly -O3 -enable-new-pm=1 -polly -polly-position=early -polly-run-inliner -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED1
-; RUN: opt %loadNPMPolly -O3 -enable-new-pm=1 -polly -polly-position=before-vectorizer        -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED3
+; RUN: opt %loadNPMPolly -O3 -polly -polly-position=early                    -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=NOINLINE
+; RUN: opt %loadNPMPolly -O3 -polly -polly-position=early -polly-run-inliner -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED1
+; RUN: opt %loadNPMPolly -O3 -polly -polly-position=before-vectorizer        -disable-output -debug-only=polly-scops < %s 2>&1 | FileCheck %s --check-prefix=INLINED3
 ;
 ; REQUIRES: asserts
 ;
 ; void callee(int n, double A[], int i) {
 ;   for (int j = 0; j < n; j += 1)
 ;     A[i+j] = 42.0;
 ; }
 ;