[mlir:Pass] Add support for op-agnostic pass managers

[rriddle]

Summary

This commit refactors the current pass manager support to allow for
operation agnostic pass managers. This allows for a series of passes
to be executed on any viable pass manager root operation, instead
of one specific operation type. Op-agnostic/generic pass managers
only allow for adding op-agnostic passes.

These types of pass managers are extremely useful when constructing
pass pipelines that can apply to many different types of operations,
e.g., the default inliner simplification pipeline. With the advent of
interface/trait passes, this support can be used to define FunctionOpInterface
pass managers, or other pass managers that effectively operate on
specific interfaces/traits/etc (see #52916 for an example).

[mehdi_amini]

I don't quite get the merging yet, I need to wrap my head around it...

mlir/docs/PassManagement.md

377

wrap?

mlir/include/mlir/Pass/PassManager.h

48–49

"This class is generally not constructed directly" > I think this predates "dynamic pipeline" where now it is commonly built like that.

63

Nice doc improvements :)

214

That would be nice!

mlir/lib/Pass/Pass.cpp

99

Can you spell out types here?

[stellaraccident]

Sorry for the delay - it has been a rough couple of weeks.

This looks really good. My main comments are around documentation tweaks, so marking as accepted. I'm a little bit shaky on the merging logic/intent, but it looks like Mehdi is dialed in there.

mlir/docs/PassManagement.md

354

I had to read through the docs a couple of times to get my head around the definitions. Perhaps an explicit tie-in that op-agnostic passes can be filtered (and then refer to below). Maybe change the parenthetical:

..., or op-agnostic (not restricted to a static operation type, but optionally filtered -- see below)

Basically, I think it bears more explicit calling out that filtered passes are a type of op-agnostic passes.

I also think that a person not coming in with the historic context would ask why we distinguish these two types of passes/pass-managers (i.e. aren't op-specific passes/pass-managers just a type of op-agnostic but filtered to a specific operation type). I suspect that there is a reason (perf?) for special casing this, but might be useful to call this out.

496

Just so I'm clear: it is not an error for a filtered pass to encounter an op in an op-agnostic pass manager for which it does not support (i.e. it will just ignore it)? This is different from if added to a mismatched op-specific pass manager, right? (i.e. there it is assumed to be a programmer error and reported)

mlir/include/mlir/Pass/PassManager.h

140

Just so I understand: this doesn't constrain us in terms of any actual op names in dialects (i.e. even if the builtin dialect had an "any" op, it would be selected by "builtin.any", not "any").

Still, the part of me that has feelings about special bare-words would wish that this anchor name were syntactically not an op name in some way readily distinguishable. Something like "#match-any" or some such thing.

But I now see below that this is also used in the textual pass pipeline. I think I would still prefer some kind of special syntax, but not a strong opinion.

214

Agreed - would be very nice. I was looking in dismay at all of the places where we overly constrain to builtin.module (because we have to) and not looking forward to baking that further in.

mlir/lib/Pass/Pass.cpp

590

sp. "conflict"

597

Why switching to /// form here and below?

mlir/lib/Pass/PassDetail.h

32–41

Can you expand on what this is meaning to do? I was trying to match the implementation to my mental assumed model and it was not completely unambiguous to me.

[rriddle]

mlir/docs/PassManagement.md

496

A filtered pass will never encounter an op that it doesn't support. The part that this paragraph is trying to describe is that an op-agnostic pass manager inherits the constraints of all of the passes inside of it. More specifically, if an operation can't run on one of the passes inside a pass manager, it won't run on the pass manager at all.

[mehdi_amini]

mlir/lib/Pass/Pass.cpp

744–745

Should this be: "find an executor for this operation"?

mlir/test/Pass/pipeline-parsing.mlir

53

Seems like this one could be merged with the first any pipeline?

[rriddle]

mlir/docs/PassManagement.md

354

Restructured the docs and merged this into the section on passes.

mlir/include/mlir/Pass/PassManager.h

140

Right, operation names require dialect namespace prefixes so we would never hit a conflict here. I chose 'any' because its easy to be consistent across the textual format, documentation, etc.

I could switch this to <any> if that is less confusing?

mlir/test/Pass/pipeline-parsing.mlir

53

We don't know what type of filtering a pass is doing, given that it's opaquely behind a callback, so we never merge any pipelines.; given that merging could overly constrain the pass manager, which is potentially not what the user expected.

[stellaraccident]

Thank you for the clarifications. lgtm.

mlir/include/mlir/Pass/PassManager.h

140

I don't feel strongly about it. I'm fine leaving it as it is with your explanation.

mlir/docs/PassManagement.md

 [operation](LangRef.md/#operations). As such, the pass manager is designed to
 work on instances of operations at different levels of nesting. The structure of
 the [pass manager](#pass-manager), and the concept of nesting, is detailed
 further below. All passes in MLIR derive from `OperationPass` and adhere to the
 following restrictions; any noncompliance will lead to problematic behavior in
 multithreaded and other advanced scenarios:
 
 *   Must not modify any state referenced or relied upon outside the current
-    being operated on. This includes adding or removing operations from the
-    parent block, changing the attributes(depending on the contract of the
-    current operation)/operands/results/successors of the current operation.
+    operation being operated on. This includes adding or removing operations
+    from the parent block, changing the attributes(depending on the contract
+    of the current operation)/operands/results/successors of the current operation.
 *   Must not modify the state of another operation not nested within the current
     operation being operated on.
     *   Other threads may be operating on these operations simultaneously.
 *   Must not inspect the state of sibling operations.
     *   Other threads may be modifying these operations in parallel.
     *   Inspecting the state of ancestor/parent operations is permitted.
 *   Must not maintain mutable pass state across invocations of `runOnOperation`.
     A pass may be run on many different operations with no guarantee of
     execution order.
     *   When multithreading, a specific pass instance may not even execute on
         all operations within the IR. As such, a pass should not rely on running
         on all operations.
 *   Must not maintain any global mutable state, e.g. static variables within the
     source file. All mutable state should be maintained by an instance of the
     pass.
 *   Must be copy-constructible
     *   Multiple instances of the pass may be created by the pass manager to
         process operations in parallel.
 
-When creating an operation pass, there are two different types to choose from
-depending on the usage scenario:
+### Op-Agnostic Operation Passes
 
-### OperationPass : Op-Specific
+By default, an operation pass is `op-agnostic`, meaning that it operates on the
+operation type of the pass manager that it is added to. This means a pass may operate
+on many different types of operations. Agnostic passes should be written such that
+they do not make assumptions on the operation they run on. Examples of this type of pass are
+[Canonicalization](Pass.md/-canonicalize-canonicalize-operations)
+[Common Sub-Expression Elimination](Passes.md/#-cse-eliminate-common-sub-expressions).
 
-An `op-specific` operation pass operates explicitly on a given operation type.
-This operation type must adhere to the restrictions set by the pass manager for
-pass execution.
+To create an agnostic operation pass, a derived class must adhere to the following:
 
-To define an op-specific operation pass, a derived class must adhere to the
-following:
-
-*   Inherit from the CRTP class `OperationPass` and provide the operation type
-    as an additional template parameter.
+*   Inherit from the CRTP class `OperationPass`.
 *   Override the virtual `void runOnOperation()` method.
 
 A simple pass may look like:
 
 ```c++
-namespace {
 /// Here we utilize the CRTP `PassWrapper` utility class to provide some
 /// necessary utility hooks. This is only necessary for passes defined directly
 /// in C++. Passes defined declaratively use a cleaner mechanism for providing
 /// these utilities.
-struct MyFunctionPass : public PassWrapper<MyFunctionPass,
-                                           OperationPass<func::FuncOp>> {
+struct MyOperationPass : public PassWrapper<MyOperationPass, OperationPass<>> {
   void runOnOperation() override {
-    // Get the current func::FuncOp operation being operated on.
-    func::FuncOp f = getOperation();
+    // Get the current operation being operated on.
+    Operation *op = getOperation();
+    ...
+  }
+};
+```
 
-    // Walk the operations within the function.
-    f.walk([](Operation *inst) {
-      ....
-    });
+### Filtered Operation Pass
+
+If a pass needs to constrain its execution to specific types or classes of operations,
+additional filtering may be applied on top. This transforms a once `agnostic` pass into
+one more specific to a certain context. There are various ways in which to filter the
+execution of a pass, and different contexts in which filtering may apply:
+
+### Operation Pass: Static Schedule Filtering
+
+Static filtering allows for applying additional constraints on the operation types a
+pass may be scheduled on. This type of filtering generally allows for building more
+constrained passes that can only be scheduled on operations that satisfy the necessary
+constraints. For example, this allows for specifying passes that only run on operations
+of a certain, those that provide a certain interface, trait, or some other constraint that
+applies to all instances of that operation type. Below is an example of a pass that only
+permits scheduling on operations that implement `FunctionOpInterface`:
+
+```c++
+struct MyFunctionPass : ... {
+  /// This method is used to provide additional static filtering, and returns if the
+  /// pass may be scheduled on the given operation type.
+  bool canScheduleOn(RegisteredOperationName opInfo) const override {
+    return opInfo.hasInterface<FunctionOpInterface>();
+  }
+
+  void runOnOperation() {
+    // Here we can freely cast to FunctionOpInterface, because our `canScheduleOn` ensures
+    // that our pass is only executed on operations implementing that interface.
+    FunctionOpInterface op = cast<FunctionOpInterface>(getOperation()); 
   }
 };
-} // namespace
+```
 
-/// Register this pass so that it can be built via from a textual pass pipeline.
-/// (Pass registration is discussed more below)
-void registerMyPass() {
-  PassRegistration<MyFunctionPass>();
+When a pass with static filtering is added to an [`op-specific` pass manager](#oppassmanager),
+it asserts that the operation type of the pass manager satisfies the static constraints of the
+pass. When added to an [`op-agnostic` pass manager](#oppassmanager), that pass manager, and all
+passes contained within, inherits the static constraints of the pass. For example, if the pass
+filters on `FunctionOpInterface`, as in the `MyFunctionPass` example above, only operations that
+implement `FunctionOpInterface` will be considered when executing **any** passes within the pass
+manager. This invariant is important to keep in mind, as each pass added to an `op-agnostic` pass
+manager further constrains the operations that may be scheduled on it. Consider the following example:
+
+```mlir
+func.func @foo() {
+  // ...
+  return
+}
+
+module @someModule {
+  // ...
 }
 ```
 
-### OperationPass : Op-Agnostic
+If we were to apply the op-agnostic pipeline, `any(cse,my-function-pass)`, to the above MLIR snippet
+it would only run on the `foo` function operation. This is because the `my-function-pass` has a
+static filtering constraint to only schedule on operations implementing `FunctionOpInterface`. Remember
+that this constraint is inherited by the entire pass manager, so we never consider `someModule` for
+any of the passes, including `cse` which normally can be scheduled on any operation.
 
-An `op-agnostic` pass operates on the operation type of the pass manager that it
-is added to. This means that passes of this type may operate on several
-different operation types. Passes of this type are generally written generically
-using operation [interfaces](Interfaces.md) and [traits](Traits.md). Examples of
-this type of pass are
-[Common Sub-Expression Elimination](Passes.md/#-cse-eliminate-common-sub-expressions)
-and [Inlining](Passes.md/#-inline-inline-function-calls).
+#### Operation Pass: Static Filtering By Op Type
 
-To create an operation pass, a derived class must adhere to the following:
+In the above section, we detailed a general mechanism for statically filtering the types of operations
+that a pass may be scheduled on. Sugar is provided on top of that mechanism to simplify the definition
+of passes that are restricted to scheduling on a single operation type. In these cases, a pass simply
+needs to provide the type of operation to the `OperationPass` base class. This will automatically
+instill filtering on that operation type:
 
-*   Inherit from the CRTP class `OperationPass`.
-*   Override the virtual `void runOnOperation()` method.
+```c++
+/// Here we utilize the CRTP `PassWrapper` utility class to provide some
+/// necessary utility hooks. This is only necessary for passes defined directly
+/// in C++. Passes defined declaratively use a cleaner mechanism for providing
+/// these utilities.
+struct MyFunctionPass : public PassWrapper<MyOperationPass, OperationPass<func::FuncOp>> {
+  void runOnOperation() {
+    // Get the current operation being operated on.
+    func::FuncOp op = getOperation();
+  }
+};
+```
 
-A simple pass may look like:
+#### Operation Pass: Static Filtering By Interface
+
+In the above section, we detailed a general mechanism for statically filtering the types of operations
+that a pass may be scheduled on. Sugar is provided on top of that mechanism to simplify the definition
+of passes that are restricted to scheduling on a specific operation interface. In these cases, a pass
+simply needs to inherit from the `InterfacePass` base class. This class is similar to `OperationPass`,
+but expects the type of interface to operate on. This will automatically instill filtering on that
+interface type:
 
 ```c++
 /// Here we utilize the CRTP `PassWrapper` utility class to provide some
 /// necessary utility hooks. This is only necessary for passes defined directly
 /// in C++. Passes defined declaratively use a cleaner mechanism for providing
 /// these utilities.
-struct MyOperationPass : public PassWrapper<MyOperationPass, OperationPass<>> {
-  void runOnOperation() override {
+struct MyFunctionPass : public PassWrapper<MyOperationPass, InterfacePass<FunctionOpInterface>> {
+  void runOnOperation() {
     // Get the current operation being operated on.
-    Operation *op = getOperation();
-    ...
+    FunctionOpInterface op = getOperation();
   }
 };
 ```
 
 ### Dependent Dialects
 
 Dialects must be loaded in the MLIRContext before entities from these dialects
 (operations, types, attributes, ...) can be created. Dialects must also be

 related to pass management, the `PassManager` and the `OpPassManager`. The
 `PassManager` class acts as the top-level entry point, and contains various
 configurations used for the entire pass pipeline. The `OpPassManager` class is
 used to schedule passes to run at a specific level of nesting. The top-level
 `PassManager` also functions as an `OpPassManager`.
 
 ### OpPassManager
 
-An `OpPassManager` is essentially a collection of passes to execute on an
-operation of a specific type. This operation type must adhere to the following
-requirement:
+An `OpPassManager` is essentially a collection of passes anchored to execute on
+operations at a given level of nesting. A pass manager may be `op-specific`
+(anchored on a specific operation type), or `op-agnostic` (not restricted to any
+specific operation, and executed on any viable operation type). Operation types that
+anchor pass managers must adhere to the following requirement:
 
 *   Must be registered and marked
     [`IsolatedFromAbove`](Traits.md/#isolatedfromabove).
 
-    *   Passes are expected to not modify operations at or above the current
+    *   Passes are expected not to modify operations at or above the current
         operation being processed. If the operation is not isolated, it may
         inadvertently modify or traverse the SSA use-list of an operation it is
         not supposed to.
 
-Passes can be added to a pass manager via `addPass`. The pass must either be an
-`op-specific` pass operating on the same operation type as `OpPassManager`, or
-an `op-agnostic` pass.
+Passes can be added to a pass manager via `addPass`.
 
 An `OpPassManager` is generally created by explicitly nesting a pipeline within
-another existing `OpPassManager` via the `nest<>` method. This method takes the
-operation type that the nested pass manager will operate on. At the top-level, a
-`PassManager` acts as an `OpPassManager`. Nesting in this sense, corresponds to
-the [structural](Tutorials/UnderstandingTheIRStructure.md) nesting within
+another existing `OpPassManager` via the `nest<OpT>` or `nestAny` methods. The
+former method takes the operation type that the nested pass manager will operate on.
+The latter method nests an `op-agnostic` pass manager, that may run on any viable
+operation type. Nesting in this sense, corresponds to the
+[structural](Tutorials/UnderstandingTheIRStructure.md) nesting within
 [Regions](LangRef.md/#regions) of the IR.
 
 For example, the following `.mlir`:
 
 ```
 module {
   spv.module "Logical" "GLSL450" {
     func @foo() {
       ...
     }
   }
 }
 ```
 
 Has the nesting structure of:
 
 ```
-`module`
+`builtin.module`
   `spv.module`
-    `function`
+    `spv.func`
 ```
 
 Below is an example of constructing a pipeline that operates on the above
 structure:
 
 ```c++
 // Create a top-level `PassManager` class. If an operation type is not
 // explicitly specific, the default is the builtin `module` operation.

 OpPassManager &nestedModulePM = pm.nest<spirv::ModuleOp>();
 nestedModulePM.addPass(std::make_unique<MySPIRVModulePass>());
 
 // Nest a pass manager that operates on functions within the nested SPIRV
 // module.
 OpPassManager &nestedFunctionPM = nestedModulePM.nest<func::FuncOp>();
 nestedFunctionPM.addPass(std::make_unique<MyFunctionPass>());
 
+// Nest an op-agnostic pass manager. This will operate on any viable
+// operation, e.g. func.func, spv.func, spv.module, builtin.module, etc.
+OpPassManager &nestedAnyPM = nestedModulePM.nestAny();
+nestedFunctionPM.addPass(createCanonicalizePass());
+nestedFunctionPM.addPass(createCSEPass());
+
 // Run the pass manager on the top-level module.
 ModuleOp m = ...;
 if (failed(pm.run(m)))
     ... // One of the passes signaled a failure.
 ```
 
 The above pass manager contains the following pipeline structure:
 
 ```
 OpPassManager<ModuleOp>
   MyModulePass
   OpPassManager<spirv::ModuleOp>
     MySPIRVModulePass
     OpPassManager<func::FuncOp>
       MyFunctionPass
+    OpPassManager<>
+      Canonicalizer
+      CSE
 ```
 
 These pipelines are then run over a single operation at a time. This means that,
 for example, given a series of consecutive passes on func::FuncOp, it will execute all
 on the first function, then all on the second function, etc. until the entire
 program has been run through the passes. This provides several benefits:
 
 *   This improves the cache behavior of the compiler, because it is only

 should run in a nested fashion, i.e. when the nested pipeline cannot be
 scheduled statically along with the rest of the main pass pipeline. More
 specifically, a `PassManager` should generally never need to be constructed
 within a `Pass`. Using `runPipeline` also ensures that all analyses,
 [instrumentations](#pass-instrumentation), and other pass manager related
 components are integrated with the dynamic pipeline being executed.
 
 ## Instance Specific Pass Options
 
 MLIR provides a builtin mechanism for passes to specify options that configure
 its behavior. These options are parsed at pass construction time independently
 for each instance of the pass. Options are defined using the `Option<>` and
 `ListOption<>` classes, and generally follow the
 [LLVM command line](https://llvm.org/docs/CommandLine.html) flag definition
 rules. One major distinction from the LLVM command line functionality is that
 all `ListOption`s are comma-separated, and delimited sub-ranges within individual
 elements of the list may contain commas that are not treated as separators for the

 To support the ability to describe the full structure of pass pipelines, MLIR
 supports a custom textual description of pass pipelines. The textual description
 includes the nesting structure, the arguments of the passes and pass pipelines
 to run, and any options for those passes and pipelines. A textual pipeline is
 defined as a series of names, each of which may in itself recursively contain a
 nested pipeline description. The syntax for this specification is as follows:
 
 ```ebnf
-pipeline          ::= op-name `(` pipeline-element (`,` pipeline-element)* `)`
+pipeline          ::= op-anchor `(` pipeline-element (`,` pipeline-element)* `)`
 pipeline-element  ::= pipeline | (pass-name | pass-pipeline-name) options?
 options           ::= '{' (key ('=' value)?)+ '}'
 ```
 
-*   `op-name`
-    *   This corresponds to the mnemonic name of an operation to run passes on,
-        e.g. `func.func` or `builtin.module`.
+*   `op-anchor`
+    *   This corresponds to the mnemonic name that anchors the execution of the
+        pass manager. This is either the name of an operation to run passes on,
+        e.g. `func.func` or `builtin.module`, or `any`, for op-agnostic pass
+        managers that execute on any viable operation (i.e. any operation that
+        can be used to anchor a pass manager).
 *   `pass-name` | `pass-pipeline-name`
     *   This corresponds to the argument of a registered pass or pass pipeline,
         e.g. `cse` or `canonicalize`.
 *   `options`
     *   Options are specific key value pairs representing options defined by a
         pass or pass pipeline, as described in the
         ["Instance Specific Pass Options"](#instance-specific-pass-options)
         section. See this section for an example usage in a textual pipeline.
 
 For example, the following pipeline:
 
 ```shell
 $ mlir-opt foo.mlir -cse -canonicalize -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1'
 ```
 
 Can also be specified as (via the `-pass-pipeline` flag):
 
 ```shell
+# Anchor the cse and canonicalize passes on the `func.func` operation.
 $ mlir-opt foo.mlir -pass-pipeline='func.func(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}'
+
+# Anchor the cse and canonicalize passes on "any" viable root operation.
+$ mlir-opt foo.mlir -pass-pipeline='any(cse,canonicalize),convert-func-to-llvm{use-bare-ptr-memref-call-conv=1}'
 ```
 
 In order to support round-tripping a pass to the textual representation using
 `OpPassManager::printAsTextualPipeline(raw_ostream&)`, override `StringRef
 Pass::getArgument()` to specify the argument used when registering a pass.
 
 ## Declarative Pass Specification
 

mlir/include/mlir/Pass/PassInstrumentation.h

 //===- PassInstrumentation.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_PASS_PASSINSTRUMENTATION_H_
 #define MLIR_PASS_PASSINSTRUMENTATION_H_
 
-#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/TypeID.h"
 
 namespace mlir {
+class OperationName;
 class Operation;
 class Pass;
 
 namespace detail {
 struct PassInstrumentorImpl;
 } // namespace detail
 
 /// PassInstrumentation provides several entry points into the pass manager
struct PipelineParentInfo {
 
     /// The pass that spawned this pipeline.
     Pass *parentPass;
   };
 
   virtual ~PassInstrumentation() = 0;
 
   /// A callback to run before a pass pipeline is executed. This function takes
-  /// the name of the operation type being operated on, and information related
-  /// to the parent that spawned this pipeline.
-  virtual void runBeforePipeline(StringAttr name,
-                                 const PipelineParentInfo &parentInfo) {}
+  /// the name of the operation type being operated on, or None if the pipeline
+  /// is op-agnostic, and information related to the parent that spawned this
+  /// pipeline.
+  virtual void runBeforePipeline(Optional<OperationName> name,
+                                 const PipelineParentInfo &parentInfo);
 
   /// A callback to run after a pass pipeline has executed. This function takes
-  /// the name of the operation type being operated on, and information related
-  /// to the parent that spawned this pipeline.
-  virtual void runAfterPipeline(StringAttr name,
-                                const PipelineParentInfo &parentInfo) {}
+  /// the name of the operation type being operated on, or None if the pipeline
+  /// is op-agnostic, and information related to the parent that spawned this
+  /// pipeline.
+  virtual void runAfterPipeline(Optional<OperationName> name,
+                                const PipelineParentInfo &parentInfo);
 
   /// A callback to run before a pass is executed. This function takes a pointer
   /// to the pass to be executed, as well as the current operation being
   /// operated on.
   virtual void runBeforePass(Pass *pass, Operation *op) {}
 
   /// A callback to run after a pass is successfully executed. This function
   /// takes a pointer to the pass to be executed, as well as the current

 public:
   PassInstrumentor();
   PassInstrumentor(PassInstrumentor &&) = delete;
   PassInstrumentor(const PassInstrumentor &) = delete;
   ~PassInstrumentor();
 
   /// See PassInstrumentation::runBeforePipeline for details.
   void
-  runBeforePipeline(StringAttr name,
+  runBeforePipeline(Optional<OperationName> name,
                     const PassInstrumentation::PipelineParentInfo &parentInfo);
 
   /// See PassInstrumentation::runAfterPipeline for details.
   void
-  runAfterPipeline(StringAttr name,
+  runAfterPipeline(Optional<OperationName> name,
                    const PassInstrumentation::PipelineParentInfo &parentInfo);
 
   /// See PassInstrumentation::runBeforePass for details.
   void runBeforePass(Pass *pass, Operation *op);
 
   /// See PassInstrumentation::runAfterPass for details.
   void runAfterPass(Pass *pass, Operation *op);
 

mlir/include/mlir/Pass/PassManager.h

 
 namespace mlir {
 class AnalysisManager;
 class MLIRContext;
 class Operation;
 class Pass;
 class PassInstrumentation;
 class PassInstrumentor;
-class StringAttr;
 
 namespace detail {
 struct OpPassManagerImpl;
 class OpToOpPassAdaptor;
 class PassCrashReproducerGenerator;
 struct PassExecutionState;
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // OpPassManager
 //===----------------------------------------------------------------------===//
 
-/// This class represents a pass manager that runs passes on a specific
-/// operation type. This class is not constructed directly, but nested within
-/// other OpPassManagers or the top-level PassManager.
+/// This class represents a pass manager that runs passes on either a specific
+/// operation type, or any isolated operation. This pass manager can not be run
+/// on an operation directly, but must be run either as part of a top-level
+/// `PassManager`(e.g. when constructed via `nest` calls), or dynamically within
+/// a pass by using the `Pass::runPipeline` API.
 class OpPassManager {
 public:
-  enum class Nesting { Implicit, Explicit };
-  OpPassManager(StringAttr name, Nesting nesting = Nesting::Explicit);
+  /// This enum represents the nesting behavior of the pass manager.
+  enum class Nesting {
+    /// Implicit nesting behavior. This allows for adding passes operating on
+    /// operations different from this pass manager, in which case a new pass
+    /// manager is implicitly nested for the operation type of the new pass.
+    Implicit,
+    /// Explicit nesting behavior. This requires that any passes added to this
+    /// pass manager support its operation type.
+    Explicit
+  };
+
+  /// Construct a new op-agnostic ("any") pass manager with the given operation
+  /// type and nesting behavior. This is the same as invoking:
+  /// `OpPassManager(getAnyOpAnchorName(), nesting)`.
+  OpPassManager(Nesting nesting = Nesting::Explicit);
+
+  /// Construct a new pass manager with the given anchor operation type and
+  /// nesting behavior.
   OpPassManager(StringRef name, Nesting nesting = Nesting::Explicit);
+  OpPassManager(OperationName name, Nesting nesting = Nesting::Explicit);
   OpPassManager(OpPassManager &&rhs);
   OpPassManager(const OpPassManager &rhs);
   ~OpPassManager();
   OpPassManager &operator=(const OpPassManager &rhs);
 
   /// Iterator over the passes in this pass manager.
   using pass_iterator =
       llvm::pointee_iterator<MutableArrayRef<std::unique_ptr<Pass>>::iterator>;
iterator_range<const_pass_iterator> getPasses() const {
     return {begin(), end()};
   }
 
   /// Returns true if the pass manager has no passes.
   bool empty() const { return begin() == end(); }
 
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
-  OpPassManager &nest(StringAttr nestedName);
+  OpPassManager &nest(OperationName nestedName);
   OpPassManager &nest(StringRef nestedName);
   template <typename OpT> OpPassManager &nest() {
     return nest(OpT::getOperationName());
   }
 
+  /// Nest a new op-agnostic ("any") pass manager under this pass manager.
+  /// Note: This is the same as invoking `nest(getAnyOpAnchorName())`.
+  OpPassManager &nestAny();
+
   /// Add the given pass to this pass manager. If this pass has a concrete
   /// operation type, it must be the same type as this pass manager.
   void addPass(std::unique_ptr<Pass> pass);
 
   /// Clear the pipeline, but not the other options set on this OpPassManager.
   void clear();
 
   /// Add the given pass to a nested pass manager for the given operation kind
   /// `OpT`.
   template <typename OpT> void addNestedPass(std::unique_ptr<Pass> pass) {
     nest<OpT>().addPass(std::move(pass));
   }
 
   /// Returns the number of passes held by this manager.
   size_t size() const;
 
-  /// Return the operation name that this pass manager operates on.
-  OperationName getOpName(MLIRContext &context) const;
-
-  /// Return the operation name that this pass manager operates on.
-  StringRef getOpName() const;
+  /// Return the operation name that this pass manager operates on, or None if
+  /// this is an op-agnostic pass manager.
+  Optional<OperationName> getOpName(MLIRContext &context) const;
+
+  /// Return the operation name that this pass manager operates on, or None if
+  /// this is an op-agnostic pass manager.
+  Optional<StringRef> getOpName() const;
+
+  /// Return the name used to anchor this pass manager. This is either the name
+  /// of an operation, or the result of `getAnyOpAnchorName()` in the case of an
+  /// op-agnostic pass manager.
+  StringRef getOpAnchorName() const;
+
+  /// Return the string name used to anchor op-agnostic pass managers that
+  /// operate generically on any viable operation.
+  static StringRef getAnyOpAnchorName() { return "any"; }
 
   /// Returns the internal implementation instance.
   detail::OpPassManagerImpl &getImpl();
 
   /// Prints out the passes of the pass manager as the textual representation
   /// of pipelines.
   /// Note: The quality of the string representation depends entirely on the
   /// the correctness of per-pass overrides of Pass::printAsTextualPipeline.

 };
 
 /// The main pass manager and pipeline builder.
 class PassManager : public OpPassManager {
 public:
   /// Create a new pass manager under the given context with a specific nesting
   /// style. The created pass manager can schedule operations that match
   /// `operationName`.
+  /// FIXME: We should make the specification of `builtin.module` explicit here,
+  /// so that we can have top-level op-agnostic pass managers.
   PassManager(MLIRContext *ctx, Nesting nesting = Nesting::Explicit,
               StringRef operationName = "builtin.module");
   PassManager(MLIRContext *ctx, StringRef operationName)
       : PassManager(ctx, Nesting::Explicit, operationName) {}
   ~PassManager();
 
   /// Run the passes within this manager on the provided operation. The
   /// specified operation must have the same name as the one provided the pass

mlir/lib/Pass/Pass.cpp

 /// Prints out the pass in the textual representation of pipelines. If this is
 /// an adaptor pass, print with the op_name(sub_pass,...) format.
 void Pass::printAsTextualPipeline(raw_ostream &os) {
   // Special case for adaptors to use the 'op_name(sub_passes)' format.
   if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(this)) {
     llvm::interleave(
         adaptor->getPassManagers(),
         [&](OpPassManager &pm) {
-          os << pm.getOpName() << "(";
+          os << pm.getOpAnchorName() << "(";
           pm.printAsTextualPipeline(os);
           os << ")";
         },
         [&] { os << ","; });
     return;
   }
   // Otherwise, print the pass argument followed by its options. If the pass
   // doesn't have an argument, print the name of the pass to give some indicator

 //===----------------------------------------------------------------------===//
 // OpPassManagerImpl
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 struct OpPassManagerImpl {
   OpPassManagerImpl(OperationName opName, OpPassManager::Nesting nesting)
-      : name(opName.getStringRef()), opName(opName),
+      : name(opName.getStringRef().str()), opName(opName),
         initializationGeneration(0), nesting(nesting) {}
   OpPassManagerImpl(StringRef name, OpPassManager::Nesting nesting)
-      : name(name), initializationGeneration(0), nesting(nesting) {}
+      : name(name == OpPassManager::getAnyOpAnchorName() ? "" : name.str()),
+        initializationGeneration(0), nesting(nesting) {}
+  OpPassManagerImpl(OpPassManager::Nesting nesting)
+      : name(""), initializationGeneration(0), nesting(nesting) {}
+  OpPassManagerImpl(const OpPassManagerImpl &rhs)
+      : name(rhs.name), opName(rhs.opName),
+        initializationGeneration(rhs.initializationGeneration),
+        nesting(rhs.nesting) {
+    for (const std::unique_ptr<Pass> &pass : rhs.passes) {
+      std::unique_ptr<Pass> newPass = pass->clone();
+      newPass->threadingSibling = pass.get();
+      passes.push_back(std::move(newPass));
+    }
+  }
 
   /// Merge the passes of this pass manager into the one provided.
   void mergeInto(OpPassManagerImpl &rhs);
 
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
-  OpPassManager &nest(StringAttr nestedName);
-  OpPassManager &nest(StringRef nestedName);
+  OpPassManager &nest(OperationName nestedName) {
+    return nest(OpPassManager(nestedName, nesting));
+  }
+  OpPassManager &nest(StringRef nestedName) {
+    return nest(OpPassManager(nestedName, nesting));
+  }
+  OpPassManager &nestAny() { return nest(OpPassManager(nesting)); }
+
+  /// Nest the given pass manager under this pass manager.
+  OpPassManager &nest(OpPassManager &&nested);
 
   /// Add the given pass to this pass manager. If this pass has a concrete
   /// operation type, it must be the same type as this pass manager.
   void addPass(std::unique_ptr<Pass> pass);
 
   /// Clear the list of passes in this pass manager, other options are
   /// preserved.
   void clear();
 
   /// Finalize the pass list in preparation for execution. This includes
   /// coalescing adjacent pass managers when possible, verifying scheduled
   /// passes, etc.
   LogicalResult finalizePassList(MLIRContext *ctx);
 
   /// Return the operation name of this pass manager.
-  OperationName getOpName(MLIRContext &context) {
-    if (!opName)
+  Optional<OperationName> getOpName(MLIRContext &context) {
+    if (!name.empty() && !opName)
       opName = OperationName(name, &context);
-    return *opName;
+    return opName;
+  }
+  Optional<StringRef> getOpName() const {
+    return name.empty() ? Optional<StringRef>() : Optional<StringRef>(name);
   }
 
+  /// Return the name used to anchor this pass manager. This is either the name
+  /// of an operation, or the result of `getAnyOpAnchorName()` in the case of an
+  /// op-agnostic pass manager.
+  StringRef getOpAnchorName() const {
+    return getOpName().getValueOr(OpPassManager::getAnyOpAnchorName());
+  }
+
+  /// Indicate if the current pass manager can be scheduled on the given
+  /// operation type.
+  bool canScheduleOn(MLIRContext &context, OperationName opName);
+
   /// The name of the operation that passes of this pass manager operate on.
   std::string name;
 
   /// The cached OperationName (internalized in the context) for the name of the
   /// operation that passes of this pass manager operate on.
   Optional<OperationName> opName;
 
   /// The set of passes to run as part of this pass manager.

 
 void OpPassManagerImpl::mergeInto(OpPassManagerImpl &rhs) {
   assert(name == rhs.name && "merging unrelated pass managers");
   for (auto &pass : passes)
     rhs.passes.push_back(std::move(pass));
   passes.clear();
 }
 
-OpPassManager &OpPassManagerImpl::nest(StringAttr nestedName) {
-  OpPassManager nested(nestedName, nesting);
-  auto *adaptor = new OpToOpPassAdaptor(std::move(nested));
-  addPass(std::unique_ptr<Pass>(adaptor));
-  return adaptor->getPassManagers().front();
-}
-
-OpPassManager &OpPassManagerImpl::nest(StringRef nestedName) {
-  OpPassManager nested(nestedName, nesting);
+OpPassManager &OpPassManagerImpl::nest(OpPassManager &&nested) {
   auto *adaptor = new OpToOpPassAdaptor(std::move(nested));
   addPass(std::unique_ptr<Pass>(adaptor));
   return adaptor->getPassManagers().front();
 }
 
 void OpPassManagerImpl::addPass(std::unique_ptr<Pass> pass) {
   // If this pass runs on a different operation than this pass manager, then
   // implicitly nest a pass manager for this operation if enabled.
-  auto passOpName = pass->getOpName();
-  if (passOpName && passOpName->str() != name) {
+  Optional<StringRef> pmOpName = getOpName();
+  Optional<StringRef> passOpName = pass->getOpName();
+  if (pmOpName && passOpName && *pmOpName != *passOpName) {
     if (nesting == OpPassManager::Nesting::Implicit)
       return nest(*passOpName).addPass(std::move(pass));
     llvm::report_fatal_error(llvm::Twine("Can't add pass '") + pass->getName() +
                              "' restricted to '" + *passOpName +
-                             "' on a PassManager intended to run on '" + name +
-                             "', did you intend to nest?");
+                             "' on a PassManager intended to run on '" +
+                             getOpAnchorName() + "', did you intend to nest?");
   }
 
   passes.emplace_back(std::move(pass));
 }
 
 void OpPassManagerImpl::clear() { passes.clear(); }
 
 LogicalResult OpPassManagerImpl::finalizePassList(MLIRContext *ctx) {
+  auto finalizeAdaptor = [ctx](OpToOpPassAdaptor *adaptor) {
+    for (auto &pm : adaptor->getPassManagers())
+      if (failed(pm.getImpl().finalizePassList(ctx)))
+        return failure();
+    return success();
+  };
+
   // Walk the pass list and merge adjacent adaptors.
   OpToOpPassAdaptor *lastAdaptor = nullptr;
   for (auto &pass : passes) {
     // Check to see if this pass is an adaptor.
     if (auto *currentAdaptor = dyn_cast<OpToOpPassAdaptor>(pass.get())) {
       // If it is the first adaptor in a possible chain, remember it and
       // continue.
       if (!lastAdaptor) {
         lastAdaptor = currentAdaptor;
         continue;
       }
 
-      // Otherwise, merge into the existing adaptor and delete the current one.
-      currentAdaptor->mergeInto(*lastAdaptor);
+      // Otherwise, try to merge into the existing adaptor and delete the
+      // current one. If merging fails, just remember this as the last adaptor.
+      if (succeeded(currentAdaptor->tryMergeInto(ctx, *lastAdaptor)))
         pass.reset();
+      else
+        lastAdaptor = currentAdaptor;
     } else if (lastAdaptor) {
-      // If this pass is not an adaptor, then finalize and forget any existing
-      // adaptor.
-      for (auto &pm : lastAdaptor->getPassManagers())
-        if (failed(pm.getImpl().finalizePassList(ctx)))
-          return failure();
+      // If this pass isn't an adaptor, finalize it and forget the last adaptor.
+      if (failed(finalizeAdaptor(lastAdaptor)))
       lastAdaptor = nullptr;
     }
   }
 
   // If there was an adaptor at the end of the manager, finalize it as well.
-  if (lastAdaptor) {
-    for (auto &pm : lastAdaptor->getPassManagers())
-      if (failed(pm.getImpl().finalizePassList(ctx)))
-        return failure();
-  }
+  if (lastAdaptor && failed(finalizeAdaptor(lastAdaptor)))
 
   // Now that the adaptors have been merged, erase any empty slots corresponding
   // to the merged adaptors that were nulled-out in the loop above.
-  Optional<RegisteredOperationName> opName =
-      getOpName(*ctx).getRegisteredInfo();
   llvm::erase_if(passes, std::logical_not<std::unique_ptr<Pass>>());
 
-  // Verify that all of the passes are valid for the operation.
+  // If this is a op-agnostic pass manager, there is nothing left to do.
+  Optional<OperationName> rawOpName = getOpName(*ctx);
+  if (!rawOpName)
+    return success();
+
+  // Otherwise, verify that all of the passes are valid for the current
+  // operation anchor.
+  Optional<RegisteredOperationName> opName = rawOpName->getRegisteredInfo();
   for (std::unique_ptr<Pass> &pass : passes) {
     if (opName && !pass->canScheduleOn(*opName)) {
       return emitError(UnknownLoc::get(ctx))
              << "unable to schedule pass '" << pass->getName()
-             << "' on a PassManager intended to run on '" << name << "'!";
+             << "' on a PassManager intended to run on '" << getOpAnchorName()
+             << "'!";
     }
   }
   return success();
 }
 
+bool OpPassManagerImpl::canScheduleOn(MLIRContext &context,
+                                      OperationName opName) {
+  // If this pass manager is op-specific, we simply check if the provided
+  // operation name is the same as this one.
+  Optional<OperationName> pmOpName = getOpName(context);
+  if (pmOpName)
+    return pmOpName == opName;
+
+  // Otherwise, this is an op-agnostic pass manager. Check that the operation
+  // can be scheduled on all passes within the manager.
+  Optional<RegisteredOperationName> registeredInfo = opName.getRegisteredInfo();
+  if (!registeredInfo ||
+      !registeredInfo->hasTrait<OpTrait::IsIsolatedFromAbove>())
+    return false;
+  return llvm::all_of(passes, [&](const std::unique_ptr<Pass> &pass) {
+    return pass->canScheduleOn(*registeredInfo);
+  });
+}
+
 //===----------------------------------------------------------------------===//
 // OpPassManager
 //===----------------------------------------------------------------------===//
 
-OpPassManager::OpPassManager(StringAttr name, Nesting nesting)
-    : impl(new OpPassManagerImpl(name, nesting)) {}
+OpPassManager::OpPassManager(Nesting nesting)
+    : impl(new OpPassManagerImpl(nesting)) {}
 OpPassManager::OpPassManager(StringRef name, Nesting nesting)
     : impl(new OpPassManagerImpl(name, nesting)) {}
+OpPassManager::OpPassManager(OperationName name, Nesting nesting)
+    : impl(new OpPassManagerImpl(name, nesting)) {}
 OpPassManager::OpPassManager(OpPassManager &&rhs) : impl(std::move(rhs.impl)) {}
 OpPassManager::OpPassManager(const OpPassManager &rhs) { *this = rhs; }
 OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) {
-  impl = std::make_unique<OpPassManagerImpl>(rhs.impl->name, rhs.impl->nesting);
-  impl->initializationGeneration = rhs.impl->initializationGeneration;
-  for (auto &pass : rhs.impl->passes) {
-    auto newPass = pass->clone();
-    newPass->threadingSibling = pass.get();
-    impl->passes.push_back(std::move(newPass));
-  }
+  impl = std::make_unique<OpPassManagerImpl>(*rhs.impl);
   return *this;
 }
 
 OpPassManager::~OpPassManager() = default;
 
 OpPassManager::pass_iterator OpPassManager::begin() {
   return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin();
 }
 OpPassManager::pass_iterator OpPassManager::end() {
   return MutableArrayRef<std::unique_ptr<Pass>>{impl->passes}.end();
 }
 
 OpPassManager::const_pass_iterator OpPassManager::begin() const {
   return ArrayRef<std::unique_ptr<Pass>>{impl->passes}.begin();
 }
 OpPassManager::const_pass_iterator OpPassManager::end() const {
   return ArrayRef<std::unique_ptr<Pass>>{impl->passes}.end();
 }
 
 /// Nest a new operation pass manager for the given operation kind under this
 /// pass manager.
-OpPassManager &OpPassManager::nest(StringAttr nestedName) {
+OpPassManager &OpPassManager::nest(OperationName nestedName) {
   return impl->nest(nestedName);
 }
 OpPassManager &OpPassManager::nest(StringRef nestedName) {
   return impl->nest(nestedName);
 }
+OpPassManager &OpPassManager::nestAny() { return impl->nestAny(); }
 
 /// Add the given pass to this pass manager. If this pass has a concrete
 /// operation type, it must be the same type as this pass manager.
 void OpPassManager::addPass(std::unique_ptr<Pass> pass) {
   impl->addPass(std::move(pass));
 }
 
 void OpPassManager::clear() { impl->clear(); }
 
 /// Returns the number of passes held by this manager.
 size_t OpPassManager::size() const { return impl->passes.size(); }
 
 /// Returns the internal implementation instance.
 OpPassManagerImpl &OpPassManager::getImpl() { return *impl; }
 
 /// Return the operation name that this pass manager operates on.
-StringRef OpPassManager::getOpName() const { return impl->name; }
+Optional<StringRef> OpPassManager::getOpName() const {
+  return impl->getOpName();
+}
 
 /// Return the operation name that this pass manager operates on.
-OperationName OpPassManager::getOpName(MLIRContext &context) const {
+Optional<OperationName> OpPassManager::getOpName(MLIRContext &context) const {
   return impl->getOpName(context);
 }
 
+StringRef OpPassManager::getOpAnchorName() const {
+  return impl->getOpAnchorName();
+}
+
 /// Prints out the given passes as the textual representation of a pipeline.
 static void printAsTextualPipeline(ArrayRef<std::unique_ptr<Pass>> passes,
                                    raw_ostream &os) {
   llvm::interleave(
       passes,
       [&](const std::unique_ptr<Pass> &pass) {
         pass->printAsTextualPipeline(os);
       },

 
 //===----------------------------------------------------------------------===//
 // OpToOpPassAdaptor
 //===----------------------------------------------------------------------===//
 
 LogicalResult OpToOpPassAdaptor::run(Pass *pass, Operation *op,
                                      AnalysisManager am, bool verifyPasses,
                                      unsigned parentInitGeneration) {
-  if (!op->isRegistered())
+  Optional<RegisteredOperationName> opInfo = op->getRegisteredInfo();
+  if (!opInfo)
     return op->emitOpError()
            << "trying to schedule a pass on an unregistered operation";
-  if (!op->hasTrait<OpTrait::IsIsolatedFromAbove>())
+  if (!opInfo->hasTrait<OpTrait::IsIsolatedFromAbove>())
     return op->emitOpError() << "trying to schedule a pass on an operation not "
                                 "marked as 'IsolatedFromAbove'";
 
   // Initialize the pass state with a callback for the pass to dynamically
   // execute a pipeline on the currently visited operation.
   PassInstrumentor *pi = am.getPassInstrumentor();
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         pass};
   auto dynamicPipelineCallback = [&](OpPassManager &pipeline,
                                      Operation *root) -> LogicalResult {
     if (!op->isAncestor(root))
       return root->emitOpError()
              << "Trying to schedule a dynamic pipeline on an "
                 "operation that isn't "
                 "nested under the current operation the pass is processing";
-    assert(pipeline.getOpName() == root->getName().getStringRef());
+    assert(
+        pipeline.getImpl().canScheduleOn(*op->getContext(), root->getName()));
 
     // Before running, finalize the passes held by the pipeline.
     if (failed(pipeline.getImpl().finalizePassList(root->getContext())))
       return failure();
 
     // Initialize the user provided pipeline and execute the pipeline.
     if (failed(pipeline.initialize(root->getContext(), parentInitGeneration)))
       return failure();
     AnalysisManager nestedAm = root == op ? am : am.nest(root);
-    return OpToOpPassAdaptor::runPipeline(pipeline.getPasses(), root, nestedAm,
+    return OpToOpPassAdaptor::runPipeline(pipeline, root, nestedAm,
                                           verifyPasses, parentInitGeneration,
                                           pi, &parentInfo);
   };
   pass->passState.emplace(op, am, dynamicPipelineCallback);
 
   // Instrument before the pass has run.
   if (pi)
     pi->runBeforePass(pass, op);
#endif
   }
 
   // Return if the pass signaled a failure.
   return failure(passFailed);
 }
 
 /// Run the given operation and analysis manager on a provided op pass manager.
 LogicalResult OpToOpPassAdaptor::runPipeline(
-    iterator_range<OpPassManager::pass_iterator> passes, Operation *op,
-    AnalysisManager am, bool verifyPasses, unsigned parentInitGeneration,
-    PassInstrumentor *instrumentor,
+    OpPassManager &pm, Operation *op, AnalysisManager am, bool verifyPasses,
+    unsigned parentInitGeneration, PassInstrumentor *instrumentor,
     const PassInstrumentation::PipelineParentInfo *parentInfo) {
   assert((!instrumentor || parentInfo) &&
          "expected parent info if instrumentor is provided");
   auto scopeExit = llvm::make_scope_exit([&] {
     // Clear out any computed operation analyses. These analyses won't be used
     // any more in this pipeline, and this helps reduce the current working set
     // of memory. If preserving these analyses becomes important in the future
     // we can re-evaluate this.
     am.clear();
   });
 
   // Run the pipeline over the provided operation.
-  if (instrumentor)
-    instrumentor->runBeforePipeline(op->getName().getIdentifier(), *parentInfo);
-  for (Pass &pass : passes)
+  if (instrumentor) {
+    instrumentor->runBeforePipeline(pm.getOpName(*op->getContext()),
+                                    *parentInfo);
+  }
+
+  for (Pass &pass : pm.getPasses())
     if (failed(run(&pass, op, am, verifyPasses, parentInitGeneration)))
       return failure();
-  if (instrumentor)
-    instrumentor->runAfterPipeline(op->getName().getIdentifier(), *parentInfo);
+
+  if (instrumentor) {
+    instrumentor->runAfterPipeline(pm.getOpName(*op->getContext()),
+                                   *parentInfo);
+  }
   return success();
 }
 
-/// Find an operation pass manager that can operate on an operation of the given
-/// type, or nullptr if one does not exist.
-static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
-                                         StringRef name) {
+/// Find an operation pass manager with the given anchor name, or nullptr if one
+/// does not exist.
+static OpPassManager *
+findPassManagerWithAnchor(MutableArrayRef<OpPassManager> mgrs, StringRef name) {
   auto *it = llvm::find_if(
-      mgrs, [&](OpPassManager &mgr) { return mgr.getOpName() == name; });
+      mgrs, [&](OpPassManager &mgr) { return mgr.getOpAnchorName() == name; });
   return it == mgrs.end() ? nullptr : &*it;
 }
 
 /// Find an operation pass manager that can operate on an operation of the given
 /// type, or nullptr if one does not exist.
 static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
                                          OperationName name,
                                          MLIRContext &context) {
-  auto *it = llvm::find_if(
-      mgrs, [&](OpPassManager &mgr) { return mgr.getOpName(context) == name; });
+  auto *it = llvm::find_if(mgrs, [&](OpPassManager &mgr) {
+    return mgr.getImpl().canScheduleOn(context, name);
+  });
   return it == mgrs.end() ? nullptr : &*it;
 }
 
 OpToOpPassAdaptor::OpToOpPassAdaptor(OpPassManager &&mgr) {
   mgrs.emplace_back(std::move(mgr));
 }
 
 void OpToOpPassAdaptor::getDependentDialects(DialectRegistry &dialects) const {
   for (auto &pm : mgrs)
     pm.getDependentDialects(dialects);
 }
 
-/// Merge the current pass adaptor into given 'rhs'.
-void OpToOpPassAdaptor::mergeInto(OpToOpPassAdaptor &rhs) {
+LogicalResult OpToOpPassAdaptor::tryMergeInto(MLIRContext *ctx,
+                                              OpToOpPassAdaptor &rhs) {
+  // Functor used to check if a pass manager is generic, i.e. op-agnostic.
+  auto isGenericPM = [&](OpPassManager &pm) { return !pm.getOpName(); };
+
+  // Functor used to detect if the given generic pass manager will have a
+  // potential schedule conflict with the given `otherPMs`.
+  auto hasScheduleConflictWith = [&](OpPassManager &genericPM,
+                                     MutableArrayRef<OpPassManager> otherPMs) {
+    return llvm::any_of(otherPMs, [&](OpPassManager &pm) {
+      // If this is a non-generic pass manager, a conflict will arise if a
+      // non-generic pass manager's operation name can be scheduled on the
+      // generic passmanager.
+      if (Optional<OperationName> pmOpName = pm.getOpName(*ctx))
+        return genericPM.getImpl().canScheduleOn(*ctx, *pmOpName);
+      // Otherwise, this is a generic pass manager. We current can't determine
+      // when generic pass managers can be merged, so conservatively assume they
+      // conflict.
+      return true;
+    });
+  };
+
+  // Check that if either adaptor has a generic pass manager, that pm is
+  // compatible within any non-generic pass managers.
+  //
+  // Check the current adaptor.
+  auto *lhsGenericPMIt = llvm::find_if(mgrs, isGenericPM);
+  if (lhsGenericPMIt != mgrs.end() &&
+      hasScheduleConflictWith(*lhsGenericPMIt, rhs.mgrs))
+    return failure();
+  // Check the rhs adaptor.
+  auto *rhsGenericPMIt = llvm::find_if(rhs.mgrs, isGenericPM);
+  if (rhsGenericPMIt != rhs.mgrs.end() &&
+      hasScheduleConflictWith(*rhsGenericPMIt, mgrs))
+    return failure();
+
   for (auto &pm : mgrs) {
     // If an existing pass manager exists, then merge the given pass manager
     // into it.
-    if (auto *existingPM = findPassManagerFor(rhs.mgrs, pm.getOpName())) {
+    if (auto *existingPM =
+            findPassManagerWithAnchor(rhs.mgrs, pm.getOpAnchorName())) {
       pm.getImpl().mergeInto(existingPM->getImpl());
     } else {
       // Otherwise, add the given pass manager to the list.
       rhs.mgrs.emplace_back(std::move(pm));
     }
   }
   mgrs.clear();
 
   // After coalescing, sort the pass managers within rhs by name.
-  llvm::array_pod_sort(rhs.mgrs.begin(), rhs.mgrs.end(),
-                       [](const OpPassManager *lhs, const OpPassManager *rhs) {
-                         return lhs->getOpName().compare(rhs->getOpName());
-                       });
+  auto compareFn = [](const OpPassManager *lhs, const OpPassManager *rhs) {
+    // Order op-specific pass managers first and op-agnostic pass managers last.
+    if (Optional<StringRef> lhsName = lhs->getOpName()) {
+      if (Optional<StringRef> rhsName = rhs->getOpName())
+        return lhsName->compare(*rhsName);
+      return -1; // lhs(op-specific) < rhs(op-agnostic)
+    }
+    return 1; // lhs(op-agnostic) > rhs(op-specific)
+  };
+  llvm::array_pod_sort(rhs.mgrs.begin(), rhs.mgrs.end(), compareFn);
+  return success();
 }
 
 /// Returns the adaptor pass name.
 std::string OpToOpPassAdaptor::getAdaptorName() {
   std::string name = "Pipeline Collection : [";
   llvm::raw_string_ostream os(name);
   llvm::interleaveComma(getPassManagers(), os, [&](OpPassManager &pm) {
-    os << '\'' << pm.getOpName() << '\'';
+    os << '\'' << pm.getOpAnchorName() << '\'';
   });
   os << ']';
   return os.str();
 }
 
 void OpToOpPassAdaptor::runOnOperation() {
   llvm_unreachable(
       "Unexpected call to Pass::runOnOperation() on OpToOpPassAdaptor");
for (auto &region : getOperation()->getRegions()) {
     for (auto &block : region) {
       for (auto &op : block) {
         auto *mgr = findPassManagerFor(mgrs, op.getName(), *op.getContext());
         if (!mgr)
           continue;
 
         // Run the held pipeline over the current operation.
         unsigned initGeneration = mgr->impl->initializationGeneration;
-        if (failed(runPipeline(mgr->getPasses(), &op, am.nest(&op),
-                               verifyPasses, initGeneration, instrumentor,
-                               &parentInfo)))
+        if (failed(runPipeline(*mgr, &op, am.nest(&op), verifyPasses,
+                               initGeneration, instrumentor, &parentInfo)))
           return signalPassFailure();
       }
     }
   }
 }
 
 /// Utility functor that checks if the two ranges of pass managers have a size
 /// mismatch.
void OpToOpPassAdaptor::runOnOperationAsyncImpl(bool verifyPasses) {
   AnalysisManager am = getAnalysisManager();
   MLIRContext *context = &getContext();
 
   // Create the async executors if they haven't been created, or if the main
   // pipeline has changed.
   if (asyncExecutors.empty() || hasSizeMismatch(asyncExecutors.front(), mgrs))
     asyncExecutors.assign(context->getThreadPool().getThreadCount(), mgrs);
 
+  // This struct represents the information for a single operation to be
+  // scheduled on a pass manager.
+  struct OpPMInfo {
+    OpPMInfo(unsigned passManagerIdx, Operation *op, AnalysisManager am)
+        : passManagerIdx(passManagerIdx), op(op), am(am) {}
+
+    /// The index of the pass manager to schedule the operation on.
+    unsigned passManagerIdx;
+    /// The operation to schedule.
+    Operation *op;
+    /// The analysis manager for the operation.
+    AnalysisManager am;
+  };
+
   // Run a prepass over the operation to collect the nested operations to
   // execute over. This ensures that an analysis manager exists for each
   // operation, as well as providing a queue of operations to execute over.
-  std::vector<std::pair<Operation *, AnalysisManager>> opAMPairs;
+  std::vector<OpPMInfo> opInfos;
+  DenseMap<OperationName, Optional<unsigned>> knownOpPMIdx;
   for (auto &region : getOperation()->getRegions()) {
-    for (auto &block : region) {
-      for (auto &op : block) {
-        // Add this operation iff the name matches any of the pass managers.
-        if (findPassManagerFor(mgrs, op.getName(), *context))
-          opAMPairs.emplace_back(&op, am.nest(&op));
+    for (Operation &op : region.getOps()) {
+      // Get the pass manager index for this operation type.
+      auto pmIdxIt = knownOpPMIdx.try_emplace(op.getName(), llvm::None);
+      if (pmIdxIt.second) {
+        if (auto *mgr = findPassManagerFor(mgrs, op.getName(), *context))
+          pmIdxIt.first->second = std::distance(mgrs.begin(), mgr);
       }
+
+      // If this operation can be scheduled, add it to the list.
+      if (pmIdxIt.first->second)
+        opInfos.emplace_back(*pmIdxIt.first->second, &op, am.nest(&op));
     }
   }
 
   // Get the current thread for this adaptor.
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         this};
   auto *instrumentor = am.getPassInstrumentor();
 
   // An atomic failure variable for the async executors.
   std::vector<std::atomic<bool>> activePMs(asyncExecutors.size());
   std::fill(activePMs.begin(), activePMs.end(), false);
-  auto processFn = [&](auto &opPMPair) {
-    // Find a pass manager for this operation.
+  auto processFn = [&](OpPMInfo &opInfo) {
+    // Find an executor for this operation.
     auto it = llvm::find_if(activePMs, [](std::atomic<bool> &isActive) {
       bool expectedInactive = false;
       return isActive.compare_exchange_strong(expectedInactive, true);
     });
     unsigned pmIndex = it - activePMs.begin();
 
     // Get the pass manager for this operation and execute it.
-    auto *pm = findPassManagerFor(asyncExecutors[pmIndex],
-                                  opPMPair.first->getName(), *context);
-    assert(pm && "expected valid pass manager for operation");
-
-    unsigned initGeneration = pm->impl->initializationGeneration;
-    LogicalResult pipelineResult =
-        runPipeline(pm->getPasses(), opPMPair.first, opPMPair.second,
-                    verifyPasses, initGeneration, instrumentor, &parentInfo);
+    OpPassManager &pm = asyncExecutors[pmIndex][opInfo.passManagerIdx];
+    LogicalResult pipelineResult = runPipeline(
+        pm, opInfo.op, opInfo.am, verifyPasses,
+        pm.impl->initializationGeneration, instrumentor, &parentInfo);
 
     // Reset the active bit for this pass manager.
     activePMs[pmIndex].store(false);
     return pipelineResult;
   };
 
   // Signal a failure if any of the executors failed.
-  if (failed(failableParallelForEach(context, opAMPairs, processFn)))
+  if (failed(failableParallelForEach(context, opInfos, processFn)))
     signalPassFailure();
 }
 
 //===----------------------------------------------------------------------===//
 // PassManager
 //===----------------------------------------------------------------------===//
 
 PassManager::PassManager(MLIRContext *ctx, Nesting nesting,
                          StringRef operationName)
-    : OpPassManager(StringAttr::get(ctx, operationName), nesting), context(ctx),
+    : OpPassManager(OperationName(operationName, ctx), nesting), context(ctx),
       initializationKey(DenseMapInfo<llvm::hash_code>::getTombstoneKey()),
       passTiming(false), verifyPasses(true) {}
 
 PassManager::~PassManager() = default;
 
 void PassManager::enableVerifier(bool enabled) { verifyPasses = enabled; }
 
 /// Run the passes within this manager on the provided operation.

 void PassManager::addInstrumentation(std::unique_ptr<PassInstrumentation> pi) {
   if (!instrumentor)
     instrumentor = std::make_unique<PassInstrumentor>();
 
   instrumentor->addInstrumentation(std::move(pi));
 }
 
 LogicalResult PassManager::runPasses(Operation *op, AnalysisManager am) {
-  return OpToOpPassAdaptor::runPipeline(getPasses(), op, am, verifyPasses,
+  return OpToOpPassAdaptor::runPipeline(*this, op, am, verifyPasses,
                                         impl->initializationGeneration);
 }
 
 //===----------------------------------------------------------------------===//
 // AnalysisManager
 //===----------------------------------------------------------------------===//
 
 /// Get an analysis manager for the given operation, which must be a proper

 }
 
 //===----------------------------------------------------------------------===//
 // PassInstrumentation
 //===----------------------------------------------------------------------===//
 
 PassInstrumentation::~PassInstrumentation() = default;
 
+void PassInstrumentation::runBeforePipeline(
+    Optional<OperationName> name, const PipelineParentInfo &parentInfo) {}
+
+void PassInstrumentation::runAfterPipeline(
+    Optional<OperationName> name, const PipelineParentInfo &parentInfo) {}
+
 //===----------------------------------------------------------------------===//
 // PassInstrumentor
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 struct PassInstrumentorImpl {
   /// Mutex to keep instrumentation access thread-safe.
   llvm::sys::SmartMutex<true> mutex;
 
   /// Set of registered instrumentations.
   std::vector<std::unique_ptr<PassInstrumentation>> instrumentations;
 };
 } // namespace detail
 } // namespace mlir
 
 PassInstrumentor::PassInstrumentor() : impl(new PassInstrumentorImpl()) {}
 PassInstrumentor::~PassInstrumentor() = default;
 
 /// See PassInstrumentation::runBeforePipeline for details.
 void PassInstrumentor::runBeforePipeline(
-    StringAttr name,
+    Optional<OperationName> name,
     const PassInstrumentation::PipelineParentInfo &parentInfo) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   for (auto &instr : impl->instrumentations)
     instr->runBeforePipeline(name, parentInfo);
 }
 
 /// See PassInstrumentation::runAfterPipeline for details.
 void PassInstrumentor::runAfterPipeline(
-    StringAttr name,
+    Optional<OperationName> name,
     const PassInstrumentation::PipelineParentInfo &parentInfo) {
   llvm::sys::SmartScopedLock<true> instrumentationLock(impl->mutex);
   for (auto &instr : llvm::reverse(impl->instrumentations))
     instr->runAfterPipeline(name, parentInfo);
 }
 
 /// See PassInstrumentation::runBeforePass for details.
 void PassInstrumentor::runBeforePass(Pass *pass, Operation *op) {

mlir/lib/Pass/PassDetail.h

 public:
   OpToOpPassAdaptor(OpPassManager &&mgr);
   OpToOpPassAdaptor(const OpToOpPassAdaptor &rhs) = default;
 
   /// Run the held pipeline over all operations.
   void runOnOperation(bool verifyPasses);
   void runOnOperation() override;
 
-  /// Merge the current pass adaptor into given 'rhs'.
-  void mergeInto(OpToOpPassAdaptor &rhs);
+  /// Try to merge the current pass adaptor into 'rhs'. This will try to append
+  /// the pass managers of this adaptor into those within `rhs`, or return
+  /// failure if merging isn't possible. The main situation in which merging is
+  /// not possible is if one of the adaptors has an `any` pipeline that is not
+  /// compatible with a pass manager in the other adaptor. For example, if this
+  /// adaptor has a `func.func` pipeline and `rhs` has an `any` pipeline that
+  /// operates on FunctionOpInterface. In this situation the pipelines have a
+  /// conflict (they both want to run on the same operations), so we can't
+  /// merge.
+  LogicalResult tryMergeInto(MLIRContext *ctx, OpToOpPassAdaptor &rhs);
 
   /// Returns the pass managers held by this adaptor.
   MutableArrayRef<OpPassManager> getPassManagers() { return mgrs; }
 
   /// Populate the set of dependent dialects for the passes in the current
   /// adaptor.
   void getDependentDialects(DialectRegistry &dialects) const override;
 
private:
   static LogicalResult run(Pass *pass, Operation *op, AnalysisManager am,
                            bool verifyPasses, unsigned parentInitGeneration);
 
   /// Run the given operation and analysis manager on a provided op pass
   /// manager. `parentInitGeneration` is the initialization generation of the
   /// parent pass manager, and is used to initialize any dynamic pass pipelines
   /// run by the given passes.
   static LogicalResult runPipeline(
-      iterator_range<OpPassManager::pass_iterator> passes, Operation *op,
-      AnalysisManager am, bool verifyPasses, unsigned parentInitGeneration,
-      PassInstrumentor *instrumentor = nullptr,
+      OpPassManager &pm, Operation *op, AnalysisManager am, bool verifyPasses,
+      unsigned parentInitGeneration, PassInstrumentor *instrumentor = nullptr,
       const PassInstrumentation::PipelineParentInfo *parentInfo = nullptr);
 
   /// A set of adaptors to run.
   SmallVector<OpPassManager, 1> mgrs;
 
   /// A set of executors, cloned from the main executor, that run asynchronously
   /// on different threads. This is used when threading is enabled.
   SmallVector<SmallVector<OpPassManager, 1>, 8> asyncExecutors;

mlir/lib/Pass/PassRegistry.cpp

 
 /// Utility to create a default registry function from a pass instance.
 static PassRegistryFunction
 buildDefaultRegistryFn(const PassAllocatorFunction &allocator) {
   return [=](OpPassManager &pm, StringRef options,
              function_ref<LogicalResult(const Twine &)> errorHandler) {
     std::unique_ptr<Pass> pass = allocator();
     LogicalResult result = pass->initializeOptions(options);
-    if ((pm.getNesting() == OpPassManager::Nesting::Explicit) &&
-        pass->getOpName() && *pass->getOpName() != pm.getOpName())
+
+    Optional<StringRef> pmOpName = pm.getOpName();
+    Optional<StringRef> passOpName = pass->getOpName();
+    if ((pm.getNesting() == OpPassManager::Nesting::Explicit) && pmOpName &&
+        passOpName && *pmOpName != *passOpName) {
       return errorHandler(llvm::Twine("Can't add pass '") + pass->getName() +
                           "' restricted to '" + *pass->getOpName() +
                           "' on a PassManager intended to run on '" +
-                          pm.getOpName() + "', did you intend to nest?");
+                          pm.getOpAnchorName() + "', did you intend to nest?");
+    }
     pm.addPass(std::move(pass));
     return result;
   };
 }
 
 /// Utility to print the help string for a specific option.
 static void printOptionHelp(StringRef arg, StringRef desc, size_t indent,
                             size_t descIndent, bool isTopLevel) {

mlir/lib/Pass/PassStatistics.cpp

if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(pass)) {
       auto mgrs = adaptor->getPassManagers();
       if (mgrs.size() > 1) {
         printPassEntry(os, indent, adaptor->getAdaptorName());
         indent += 2;
       }
 
       // Print each of the children passes.
       for (OpPassManager &mgr : mgrs) {
-        auto name = ("'" + mgr.getOpName() + "' Pipeline").str();
+        auto name = ("'" + mgr.getOpAnchorName() + "' Pipeline").str();
         printPassEntry(os, indent, name);
         for (Pass &pass : mgr.getPasses())
           printPass(indent + 2, &pass);
       }
       return;
     }
 
     // Otherwise, we print the statistics for this pass.

mlir/lib/Pass/PassTiming.cpp

struct PassTiming : public PassInstrumentation {
 
   /// The root timing scope into which timing is reported.
   TimingScope &rootScope;
 
   //===--------------------------------------------------------------------===//
   // Pipeline
   //===--------------------------------------------------------------------===//
 
-  void runBeforePipeline(StringAttr name,
+  void runBeforePipeline(Optional<OperationName> name,
                          const PipelineParentInfo &parentInfo) override {
     auto tid = llvm::get_threadid();
     auto &activeTimers = activeThreadTimers[tid];
 
     TimingScope *parentScope;
     if (activeTimers.empty()) {
       auto it = parentTimerIndices.find(parentInfo);
       if (it != parentTimerIndices.end())
         parentScope =
             &activeThreadTimers[parentInfo.parentThreadID][it->second];
       else
         parentScope = &rootScope;
     } else {
       parentScope = &activeTimers.back();
     }
-    activeTimers.push_back(parentScope->nest(name.getAsOpaquePointer(), [name] {
-      return ("'" + name.strref() + "' Pipeline").str();
+
+    // Use nullptr to anchor op-agnostic pipelines, otherwise use the name of
+    // the operation.
+    const void *timerId = name ? name->getAsOpaquePointer() : nullptr;
+    activeTimers.push_back(parentScope->nest(timerId, [name] {
+      return ("'" + (name ? name->getStringRef() : "any") + "' Pipeline").str();
     }));
   }
 
-  void runAfterPipeline(StringAttr, const PipelineParentInfo &) override {
+  void runAfterPipeline(Optional<OperationName>,
+                        const PipelineParentInfo &) override {
     auto &activeTimers = activeThreadTimers[llvm::get_threadid()];
     assert(!activeTimers.empty() && "expected active timer");
     activeTimers.pop_back();
   }
 
   //===--------------------------------------------------------------------===//
   // Pass
   //===--------------------------------------------------------------------===//

mlir/lib/Transforms/Inliner.cpp

InlinerPass::optimizeCallable(CallGraphNode *node,
   return runPipeline(pipelineIt->second, callable);
 }
 
 LogicalResult InlinerPass::initializeOptions(StringRef options) {
   if (failed(Pass::initializeOptions(options)))
     return failure();
 
   // Initialize the default pipeline builder to use the option string.
+  // TODO: Use a generic pass manager for default pipelines, and remove this.
   if (!defaultPipelineStr.empty()) {
     std::string defaultPipelineCopy = defaultPipelineStr;
     defaultPipeline = [=](OpPassManager &pm) {
       (void)parsePassPipeline(defaultPipelineCopy, pm);
     };
   } else if (defaultPipelineStr.getNumOccurrences()) {
     defaultPipeline = nullptr;
   }
 
   // Initialize the op specific pass pipelines.
   llvm::StringMap<OpPassManager> pipelines;
   for (OpPassManager pipeline : opPipelineList)
     if (!pipeline.empty())
-      pipelines.try_emplace(pipeline.getOpName(), pipeline);
+      pipelines.try_emplace(pipeline.getOpAnchorName(), pipeline);
   opPipelines.assign({std::move(pipelines)});
 
   return success();
 }
 
 std::unique_ptr<Pass> mlir::createInlinerPass() {
   return std::make_unique<InlinerPass>();
 }

mlir/test/Pass/generic-pipeline.mlir

+// RUN: mlir-opt %s -verify-diagnostics -pass-pipeline='any(cse, test-interface-pass)' -allow-unregistered-dialect -o /dev/null
+
+// Test that we execute generic pipelines correctly. The `cse` pass is fully generic and should execute
+// on both the module and the func. The `test-interface-pass` filters based on FunctionOpInterface and
+// should only execute on the func.
+
+// expected-remark@below {{Executing interface pass on operation}}
+func.func @main() -> (i1, i1) {
+  // CHECK-LABEL: func @main
+  // CHECK-NEXT: arith.constant true
+  // CHECK-NEXT: return
+  %true = arith.constant true
+  %true1 = arith.constant true
+  return %true, %true1 : i1, i1
+}
+
+module @module {
+  // CHECK-LABEL: module @main
+  // CHECK-NEXT: arith.constant true
+  // CHECK-NEXT: foo.op
+  %true = arith.constant true
+  %true1 = arith.constant true
+  "foo.op"(%true, %true1) : (i1, i1) -> ()
+}

mlir/test/Pass/pipeline-parsing.mlir

 // RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass,func.func(test-function-pass)),func.func(test-function-pass)' -pass-pipeline="func.func(cse,canonicalize)" -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s
 // RUN: mlir-opt %s -mlir-disable-threading -test-textual-pm-nested-pipeline -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=TEXTUAL_CHECK
+// RUN: mlir-opt %s -mlir-disable-threading -pass-pipeline='builtin.module(test-module-pass),any(test-interface-pass),any(test-interface-pass),func.func(test-function-pass),any(canonicalize),func.func(cse)' -verify-each=false -mlir-timing -mlir-timing-display=tree 2>&1 | FileCheck %s --check-prefix=GENERIC_MERGE_CHECK
 // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_1 %s
 // RUN: not mlir-opt %s -pass-pipeline='builtin.module(test-module-pass))' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_2 %s
 // RUN: not mlir-opt %s -pass-pipeline='builtin.module()(' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_3 %s
 // RUN: not mlir-opt %s -pass-pipeline=',' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_4 %s
 // RUN: not mlir-opt %s -pass-pipeline='func.func(test-module-pass)' 2>&1 | FileCheck --check-prefix=CHECK_ERROR_5 %s
 
 // CHECK_ERROR_1: encountered unbalanced parentheses while parsing pipeline
 // CHECK_ERROR_2: encountered extra closing ')' creating unbalanced parentheses while parsing pipeline
 // CHECK_ERROR_3: expected ',' after parsing pipeline
 // CHECK_ERROR_4: does not refer to a registered pass or pass pipeline
 // CHECK_ERROR_5:  Can't add pass '{{.*}}TestModulePass' restricted to 'builtin.module' on a PassManager intended to run on 'func.func', did you intend to nest?
+
 func.func @foo() {
   return
 }
 
 module {
   func.func @foo() {
     return
   }

 
 // TEXTUAL_CHECK: Pipeline Collection : ['builtin.module', 'func.func']
 // TEXTUAL_CHECK-NEXT:   'func.func' Pipeline
 // TEXTUAL_CHECK-NEXT:     TestFunctionPass
 // TEXTUAL_CHECK-NEXT:   'builtin.module' Pipeline
 // TEXTUAL_CHECK-NEXT:     TestModulePass
 // TEXTUAL_CHECK-NEXT:     'func.func' Pipeline
 // TEXTUAL_CHECK-NEXT:       TestFunctionPass
+
+// Check that generic pass pipelines are only merged when they aren't
+// going to overlap with op-specific pipelines.
+// GENERIC_MERGE_CHECK:      Pipeline Collection : ['builtin.module', 'any']
+// GENERIC_MERGE_CHECK-NEXT:   'any' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:     (anonymous namespace)::TestInterfacePass
+// GENERIC_MERGE_CHECK-NEXT:   'builtin.module' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:     (anonymous namespace)::TestModulePass
+// GENERIC_MERGE_CHECK-NEXT: 'any' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:   (anonymous namespace)::TestInterfacePass
+// GENERIC_MERGE_CHECK-NEXT: 'func.func' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:   (anonymous namespace)::TestFunctionPass
+// GENERIC_MERGE_CHECK-NEXT: 'any' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:   Canonicalizer
+// GENERIC_MERGE_CHECK-NEXT: 'func.func' Pipeline
+// GENERIC_MERGE_CHECK-NEXT:   CSE
+// GENERIC_MERGE_CHECK-NEXT:     (A) DominanceInfo