[mlir] Prefix pass manager options with `mlir-`

[awarzynski]

Summary

With this change, there's going to be a clear distinction between LLVM
and MLIR pass maanger options (e.g. -mlir-print-after-all vs
-print-after-all). This change is desirable from the point of view of
projects that depend on both LLVM and MLIR, e.g. Flang.

For consistency, all pass manager options in MLIR are prefixed with
mlir-, even options that don't have equivalents in LLVM .

[awarzynski]

Fix -mlir-mlir-pass-statistics-display

[awarzynski]

For a bit of context, this was suggested in https://reviews.llvm.org/D123297.

[rriddle]

Thanks!

mlir/docs/PassManagement.md

1143

-print-ir-failure

Does this need to be updated?

[awarzynski]

mlir/docs/PassManagement.md

1143

Ah, it should be -print-ir-after-failure _before_ this change and -mlir-print-ir-after-failure _after_. I'll update this before merging.

[rovka]

Just a thought: What do you think about adding an overload for llvm::cl::opt that also takes a prefix, and encourage people to use that for internal things? That way it will be easier for people to remember to add "mlir" to such options (and maybe we could make the same change in llvm, to add "llvm" as a prefix).

Anyway, I'm not objecting to doing things like this for now, it's just a suggestion (I guess people will just copy paste whatever's already in the file they're working on, so if all the options there have names like "mlir-blah", they'll stick to the pattern).

[awarzynski]

In D123495#3444831, @rovka wrote:

Just a thought: What do you think about adding an overload for llvm::cl::opt that also takes a prefix, and encourage people to use that for internal things?

In general, +1. I guess that there are two things here:

1. the option spellings that are visible to the end users and to other sub-projects (i.e. pre-fixing globally visible options is good),
2. what's the best way to implement this?

For now, let me address 1. and merge this as is :)

mlir/docs/PassManagement.md

 Statistics can be added to a pass by using the 'Pass::Statistic' class. This
 class takes as a constructor arguments: the parent pass, a name, and a
 description. This class acts like an atomic unsigned integer, and may be
 incremented and updated accordingly. These statistics rely on the same
 infrastructure as
 [`llvm::Statistic`](http://llvm.org/docs/ProgrammersManual.html#the-statistic-class-stats-option)
 and thus have similar usage constraints. Collected statistics can be dumped by
 the [pass manager](#pass-manager) programmatically via
-`PassManager::enableStatistics`; or via `-pass-statistics` and
-`-pass-statistics-display` on the command line.
+`PassManager::enableStatistics`; or via `-mlir-pass-statistics` and
+`-mlir-pass-statistics-display` on the command line.
 
 An example is shown below:
 
 ```c++
 struct MyPass ... {
   /// Make sure that we have a valid default constructor and copy constructor to
   /// ensure that the options are initialized properly.
   MyPass() = default;

 ```
 
 The collected statistics may be aggregated in two types of views:
 
 A pipeline view that models the structure of the pass manager, this is the
 default view:
 
 ```shell
-$ mlir-opt -pass-pipeline='func.func(my-pass,my-pass)' foo.mlir -pass-statistics
+$ mlir-opt -pass-pipeline='func.func(my-pass,my-pass)' foo.mlir -mlir-pass-statistics
 
 ===-------------------------------------------------------------------------===
                          ... Pass statistics report ...
 ===-------------------------------------------------------------------------===
 'func.func' Pipeline
   MyPass
     (S) 15 exampleStat - An example statistic
   VerifierPass
   MyPass
     (S)  6 exampleStat - An example statistic
   VerifierPass
 VerifierPass
 ```
 
 A list view that aggregates the statistics of all instances of a specific pass
 together:
 
 ```shell
-$ mlir-opt -pass-pipeline='func.func(my-pass, my-pass)' foo.mlir -pass-statistics -pass-statistics-display=list
+$ mlir-opt -pass-pipeline='func.func(my-pass, my-pass)' foo.mlir -mlir-pass-statistics -mlir-pass-statistics-display=list
 
 ===-------------------------------------------------------------------------===
                          ... Pass statistics report ...
 ===-------------------------------------------------------------------------===
 MyPass
   (S) 21 exampleStat - An example statistic
 ```
 

 When debugging it is often useful to dump the IR at various stages of a pass
 pipeline. This is where the IR printing instrumentation comes into play. This
 instrumentation allows for conditionally printing the IR before and after pass
 execution by optionally filtering on the pass being executed. This
 instrumentation can be added directly to the PassManager via the
 `enableIRPrinting` method. `mlir-opt` provides a few useful flags for utilizing
 this instrumentation:
 
-*   `print-ir-before=(comma-separated-pass-list)`
+*   `mlir-print-ir-before=(comma-separated-pass-list)`
     *   Print the IR before each of the passes provided within the pass list.
-*   `print-ir-before-all`
+*   `mlir-print-ir-before-all`
     *   Print the IR before every pass in the pipeline.
 
 ```shell
-$ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -print-ir-before=cse
+$ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -mlir-print-ir-before=cse
 
 *** IR Dump Before CSE ***
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = arith.constant 1 : i32
   %c1_i32_0 = arith.constant 1 : i32
   return %c1_i32, %c1_i32_0 : i32, i32
 }
 ```
 
-*   `print-ir-after=(comma-separated-pass-list)`
+*   `mlir-print-ir-after=(comma-separated-pass-list)`
     *   Print the IR after each of the passes provided within the pass list.
-*   `print-ir-after-all`
+*   `mlir-print-ir-after-all`
     *   Print the IR after every pass in the pipeline.
 
 ```shell
-$ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -print-ir-after=cse
+$ mlir-opt foo.mlir -pass-pipeline='func.func(cse)' -mlir-print-ir-after=cse
 
 *** IR Dump After CSE ***
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = arith.constant 1 : i32
   return %c1_i32, %c1_i32 : i32, i32
 }
 ```
 
-*   `print-ir-after-change`
+*   `mlir-print-ir-after-change`
     *   Only print the IR after a pass if the pass mutated the IR. This helps to
         reduce the number of IR dumps for "uninteresting" passes.
     *   Note: Changes are detected by comparing a hash of the operation before
         and after the pass. This adds additional run-time to compute the hash of
         the IR, and in some rare cases may result in false-positives depending
         on the collision rate of the hash algorithm used.
     *   Note: This option should be used in unison with one of the other
-        'print-ir-after' options above, as this option alone does not enable
+        'mlir-print-ir-after' options above, as this option alone does not enable
         printing.
 
 ```shell
-$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,cse)' -print-ir-after=cse -print-ir-after-change
+$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,cse)' -mlir-print-ir-after=cse -mlir-print-ir-after-change
 
 *** IR Dump After CSE ***
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = arith.constant 1 : i32
   return %c1_i32, %c1_i32 : i32, i32
 }
 ```
 
-*   `print-ir-after-failure`
+*   `mlir-print-ir-after-failure`
     *   Only print IR after a pass failure.
-    *   This option should *not* be used with the other `print-ir-after` flags
+    *   This option should *not* be used with the other `mlir-print-ir-after` flags
         above.
 
 ```shell
-$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,bad-pass)' -print-ir-failure
+$ mlir-opt foo.mlir -pass-pipeline='func.func(cse,bad-pass)' -mlir-print-ir-after-failure
 
 *** IR Dump After BadPass Failed ***
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = arith.constant 1 : i32
   return %c1_i32, %c1_i32 : i32, i32
 }
 ```
 
-*   `print-ir-module-scope`
+*   `mlir-print-ir-module-scope`
     *   Always print the top-level module operation, regardless of pass type or
         operation nesting level.
     *   Note: Printing at module scope should only be used when multi-threading
         is disabled(`-mlir-disable-threading`)
 
 ```shell
-$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse)' -print-ir-after=cse -print-ir-module-scope
+$ mlir-opt foo.mlir -mlir-disable-threading -pass-pipeline='func.func(cse)' -mlir-print-ir-after=cse -mlir-print-ir-module-scope
 
 *** IR Dump After CSE ***  ('func.func' operation: @bar)
 func @bar(%arg0: f32, %arg1: f32) -> f32 {
   ...
 }
 
 func @simple_constant() -> (i32, i32) {
   %c1_i32 = arith.constant 1 : i32

 ```
 
 ## Crash and Failure Reproduction
 
 The [pass manager](#pass-manager) in MLIR contains a builtin mechanism to
 generate reproducibles in the event of a crash, or a
 [pass failure](#pass-failure). This functionality can be enabled via
 `PassManager::enableCrashReproducerGeneration` or via the command line flag
-`pass-pipeline-crash-reproducer`. In either case, an argument is provided that
+`mlir-pass-pipeline-crash-reproducer`. In either case, an argument is provided that
 corresponds to the output `.mlir` file name that the reproducible should be
 written to. The reproducible contains the configuration of the pass manager that
 was executing, as well as the initial IR before any passes were run. A potential
 reproducible may have the form:
 
 ```mlir
 // configuration: -pass-pipeline='func.func(cse,canonicalize),inline' -verify-each
 

 Beyond specifying a filename, one can also register a `ReproducerStreamFactory`
 function that would be invoked in the case of a crash and the reproducer written
 to its stream.
 
 ### Local Reproducer Generation
 
 An additional flag may be passed to
 `PassManager::enableCrashReproducerGeneration`, and specified via
-`pass-pipeline-local-reproducer` on the command line, that signals that the pass
+`mlir-pass-pipeline-local-reproducer` on the command line, that signals that the pass
 manager should attempt to generate a "local" reproducer. This will attempt to
 generate a reproducer containing IR right before the pass that fails. This is
 useful for situations where the crash is known to be within a specific pass, or
 when the original input relies on components (like dialects or passes) that may
 not always be available.
 
 Note: Local reproducer generation requires that multi-threading is
 disabled(`-mlir-disable-threading`)

mlir/docs/Tutorials/Toy/Ch-6.md

 ```shell
 $ echo 'def main() { print([[1, 2], [3, 4]]); }' | ./bin/toyc-ch6 -emit=jit
 1.000000 2.000000
 3.000000 4.000000
 ```
 
 You can also play with `-emit=mlir`, `-emit=mlir-affine`, `-emit=mlir-llvm`, and
 `-emit=llvm` to compare the various levels of IR involved. Also try options like
-[`--print-ir-after-all`](../../PassManagement.md/#ir-printing) to track the
+[`--mlir-print-ir-after-all`](../../PassManagement.md/#ir-printing) to track the
 evolution of the IR throughout the pipeline.
 
 The example code used throughout this section can be found in
 test/Examples/Toy/Ch6/llvm-lowering.mlir.
 
 So far, we have worked with primitive data types. In the
 [next chapter](Ch-7.md), we will add a composite `struct` type.

mlir/include/mlir-c/IR.h

 /// Gets the dialect instance owned by the given context using the dialect
 /// namespace to identify it, loads (i.e., constructs the instance of) the
 /// dialect if necessary. If the dialect is not registered with the context,
 /// returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
 /// dialect.
 MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                                            MlirStringRef name);
 
-/// Set threading mode (must be set to false to print-ir-after-all).
+/// Set threading mode (must be set to false to mlir-print-ir-after-all).
 MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context,
                                                         bool enable);
 
 /// Returns whether the given fully-qualified operation (i.e.
 /// 'dialect.operation') is registered with the context. This will return true
 /// if the dialect is loaded and the operation is registered within the
 /// dialect.
 MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(MlirContext context,

mlir/include/mlir-c/Pass.h

 /// Cast a top-level PassManager to a generic OpPassManager.
 MLIR_CAPI_EXPORTED MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager);
 
 /// Run the provided `passManager` on the given `module`.
 MLIR_CAPI_EXPORTED MlirLogicalResult
 mlirPassManagerRun(MlirPassManager passManager, MlirModule module);
 
-/// Enable print-ir-after-all.
+/// Enable mlir-print-ir-after-all.
 MLIR_CAPI_EXPORTED void
 mlirPassManagerEnableIRPrinting(MlirPassManager passManager);
 
 /// Enable / disable verify-each.
 MLIR_CAPI_EXPORTED void
 mlirPassManagerEnableVerifier(MlirPassManager passManager, bool enable);
 
 /// Nest an OpPassManager under the top-level PassManager, the nested

mlir/lib/Bindings/Python/Pass.cpp

py::class_<PyPassManager>(m, "PassManager", py::module_local())
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyPassManager::createFromCapsule)
       .def("_testing_release", &PyPassManager::release,
            "Releases (leaks) the backing pass manager (testing)")
       .def(
           "enable_ir_printing",
           [](PyPassManager &passManager) {
             mlirPassManagerEnableIRPrinting(passManager.get());
           },
-          "Enable print-ir-after-all.")
+          "Enable mlir-print-ir-after-all.")
       .def(
           "enable_verifier",
           [](PyPassManager &passManager, bool enable) {
             mlirPassManagerEnableVerifier(passManager.get(), enable);
           },
           py::arg("enable"), "Enable / disable verify-each.")
       .def_static(
           "parse",

mlir/lib/Pass/PassManagerOptions.cpp

 using namespace mlir;
 
 namespace {
 struct PassManagerOptions {
   //===--------------------------------------------------------------------===//
   // Crash Reproducer Generator
   //===--------------------------------------------------------------------===//
   llvm::cl::opt<std::string> reproducerFile{
-      "pass-pipeline-crash-reproducer",
+      "mlir-pass-pipeline-crash-reproducer",
       llvm::cl::desc("Generate a .mlir reproducer file at the given output path"
                      " if the pass manager crashes or fails")};
   llvm::cl::opt<bool> localReproducer{
-      "pass-pipeline-local-reproducer",
+      "mlir-pass-pipeline-local-reproducer",
       llvm::cl::desc("When generating a crash reproducer, attempt to generated "
                      "a reproducer with the smallest pipeline."),
       llvm::cl::init(false)};
 
   //===--------------------------------------------------------------------===//
   // IR Printing
   //===--------------------------------------------------------------------===//
-  PassNameCLParser printBefore{"print-ir-before",
+  PassNameCLParser printBefore{"mlir-print-ir-before",
                                "Print IR before specified passes"};
-  PassNameCLParser printAfter{"print-ir-after",
+  PassNameCLParser printAfter{"mlir-print-ir-after",
                               "Print IR after specified passes"};
   llvm::cl::opt<bool> printBeforeAll{
-      "print-ir-before-all", llvm::cl::desc("Print IR before each pass"),
+      "mlir-print-ir-before-all", llvm::cl::desc("Print IR before each pass"),
       llvm::cl::init(false)};
-  llvm::cl::opt<bool> printAfterAll{"print-ir-after-all",
+  llvm::cl::opt<bool> printAfterAll{"mlir-print-ir-after-all",
                                     llvm::cl::desc("Print IR after each pass"),
                                     llvm::cl::init(false)};
   llvm::cl::opt<bool> printAfterChange{
-      "print-ir-after-change",
+      "mlir-print-ir-after-change",
       llvm::cl::desc(
           "When printing the IR after a pass, only print if the IR changed"),
       llvm::cl::init(false)};
   llvm::cl::opt<bool> printAfterFailure{
-      "print-ir-after-failure",
+      "mlir-print-ir-after-failure",
       llvm::cl::desc(
           "When printing the IR after a pass, only print if the pass failed"),
       llvm::cl::init(false)};
   llvm::cl::opt<bool> printModuleScope{
-      "print-ir-module-scope",
+      "mlir-print-ir-module-scope",
       llvm::cl::desc("When printing IR for print-ir-[before|after]{-all} "
                      "always print the top-level operation"),
       llvm::cl::init(false)};
 
   /// Add an IR printing instrumentation if enabled by any 'print-ir' flags.
   void addPrinterInstrumentation(PassManager &pm);
 
   //===--------------------------------------------------------------------===//
   // Pass Statistics
   //===--------------------------------------------------------------------===//
   llvm::cl::opt<bool> passStatistics{
-      "pass-statistics", llvm::cl::desc("Display the statistics of each pass")};
+      "mlir-pass-statistics",
+      llvm::cl::desc("Display the statistics of each pass")};
   llvm::cl::opt<PassDisplayMode> passStatisticsDisplayMode{
-      "pass-statistics-display",
+      "mlir-pass-statistics-display",
       llvm::cl::desc("Display method for pass statistics"),
       llvm::cl::init(PassDisplayMode::Pipeline),
       llvm::cl::values(
           clEnumValN(
               PassDisplayMode::List, "list",
               "display the results in a merged list sorted by pass name"),
           clEnumValN(PassDisplayMode::Pipeline, "pipeline",
                      "display the results with a nested pipeline view"))};

mlir/test/Pass/crash-recovery-dynamic-failure.mlir

 // Check that local reproducers will also traverse dynamic pass pipelines.
-// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-failure}' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer --mlir-disable-threading
+// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-failure}' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading
 // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC_FAILURE %s
 
 // The crash recovery mechanism will leak memory allocated in the crashing thread.
 // UNSUPPORTED: asan
 
 module @inner_mod1 {
   // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
   // expected-note@below {{Pipeline failed while executing}}
   module @foo {}
 }
 
 // REPRO_LOCAL_DYNAMIC_FAILURE: configuration: -pass-pipeline='builtin.module(test-pass-failure)'
 
 // REPRO_LOCAL_DYNAMIC_FAILURE: module @inner_mod1
 // REPRO_LOCAL_DYNAMIC_FAILURE: module @foo {

mlir/test/Pass/crash-recovery.mlir

-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics
 // RUN: cat %t | FileCheck -check-prefix=REPRO %s
-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer -mlir-disable-threading
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-module-pass, test-pass-crash)' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer -mlir-disable-threading
 // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s
 
 // Check that we correctly handle verifiers passes with local reproducer, this used to crash.
-// RUN: mlir-opt %s -test-module-pass -test-module-pass  -test-module-pass -pass-pipeline-crash-reproducer=%t -pass-pipeline-local-reproducer -mlir-disable-threading
+// RUN: mlir-opt %s -test-module-pass -test-module-pass  -test-module-pass -mlir-pass-pipeline-crash-reproducer=%t -mlir-pass-pipeline-local-reproducer -mlir-disable-threading
 // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL %s
 
 // Check that local reproducers will also traverse dynamic pass pipelines.
-// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-crash}' -pass-pipeline-crash-reproducer=%t -verify-diagnostics -pass-pipeline-local-reproducer --mlir-disable-threading
+// RUN: mlir-opt %s -pass-pipeline='test-module-pass,test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=test-pass-crash}' -mlir-pass-pipeline-crash-reproducer=%t -verify-diagnostics -mlir-pass-pipeline-local-reproducer --mlir-disable-threading
 // RUN: cat %t | FileCheck -check-prefix=REPRO_LOCAL_DYNAMIC %s
 
 // The crash recovery mechanism will leak memory allocated in the crashing thread.
 // UNSUPPORTED: asan
 
 // expected-error@below {{Failures have been detected while processing an MLIR pass pipeline}}
 // expected-note@below {{Pipeline failed while executing}}
 module @inner_mod1 {

mlir/test/Pass/dynamic-pipeline-nested.mlir

-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK
-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 dynamic-pipeline=cse})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NOTNESTED --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1 run-on-nested-operations=1 dynamic-pipeline=cse})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=NESTED --check-prefix=CHECK
 
 
 // Verify that we can schedule a dynamic pipeline on a nested operation
 
 func @f() {
   return
 }
 
 // CHECK: IR Dump Before
 // CHECK-SAME: TestDynamicPipelinePass
 // CHECK-NEXT: module @inner_mod1
 module @inner_mod1 {
-// We use the print-ir-after-all dumps to check the granularity of the
+// We use the mlir-print-ir-after-all dumps to check the granularity of the
 // scheduling: if we are nesting we expect to see to individual "Dump Before
 // CSE" output: one for each of the function. If we don't nest, then we expect
 // the CSE pass to run on the `inner_mod1` module directly.
 
 // CHECK: Dump Before CSE
 // NOTNESTED-NEXT: @inner_mod1
 // NESTED-NEXT: @foo
   module @foo {}
 // Only in the nested case we have a second run of the pass here.
 // NESTED: Dump Before CSE
 // NESTED-NEXT: @baz
   module @baz {}
 }

mlir/test/Pass/dynamic-pipeline.mlir

-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK
-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK
-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
-// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD1-ONLY --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD2 --check-prefix=MOD2-ONLY --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{op-name=inner_mod1,inner_mod2, dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
+// RUN: mlir-opt %s -pass-pipeline='builtin.module(test-dynamic-pipeline{dynamic-pipeline=func.func(cse,canonicalize)})'  --mlir-disable-threading  -mlir-print-ir-before-all 2>&1 | FileCheck %s --check-prefix=MOD1 --check-prefix=MOD2 --check-prefix=CHECK
 
 
 func @f() {
   return
 }
 
 // CHECK: IR Dump Before
 // CHECK-SAME: TestDynamicPipelinePass

mlir/test/Pass/ir-printing.mlir

-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse  -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse -print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
-// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,cse)' -print-ir-after-all -print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
-// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,test-pass-failure)' -print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before=cse  -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before-all -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_ALL %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-after=cse -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-after-all -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before=cse -mlir-print-ir-module-scope -o /dev/null 2>&1 | FileCheck -check-prefix=BEFORE_MODULE %s
+// RUN: mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,cse)' -mlir-print-ir-after-all -mlir-print-ir-after-change -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_ALL_CHANGE %s
+// RUN: not mlir-opt %s -mlir-disable-threading=true -pass-pipeline='func.func(cse,test-pass-failure)' -mlir-print-ir-after-failure -o /dev/null 2>&1 | FileCheck -check-prefix=AFTER_FAILURE %s
 
 func @foo() {
   %0 = arith.constant 0 : i32
   return
 }
 
 func @bar() {
   return

mlir/test/Pass/pipeline-stats.mlir

 // REQUIRES: asserts
-// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s
-// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -pass-statistics -pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
+// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -mlir-pass-statistics -mlir-pass-statistics-display=list 2>&1 | FileCheck -check-prefix=LIST %s
+// RUN: mlir-opt %s -verify-each=true -pass-pipeline='func.func(test-stats-pass,test-stats-pass)' -mlir-pass-statistics -mlir-pass-statistics-display=pipeline 2>&1 | FileCheck -check-prefix=PIPELINE %s
 
 // LIST: Pass statistics report
 // LIST: TestStatisticPass
 // LIST-NEXT:  (S) {{0|8}} num-ops - Number of operations counted
 // LIST-NOT: Verifier
 
 // PIPELINE: Pass statistics report
 // PIPELINE: 'func.func' Pipeline

mlir/test/Pass/run-reproducer.mlir

-// configuration: -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -print-ir-before=cse
+// configuration: -mlir-disable-threading=true -pass-pipeline='func.func(cse,canonicalize)' -mlir-print-ir-before=cse
 
 // Test of the reproducer run option. The first line has to be the
 // configuration (matching what is produced by reproducer).
 
 // RUN: mlir-opt %s -run-reproducer 2>&1 | FileCheck -check-prefix=BEFORE %s
 
 func @foo() {
   %0 = arith.constant 0 : i32