[MLIR] Update pass declarations to new autogenerated files

[mehdi_amini]

Summary

The patch introduces the required changes to update the pass declarations and definitions to use the new autogenerated files and allow dropping the old infrastructure.

[mscuttari]

This patch follows D131839 and D132572. Changes of D132572 are also included in this patch, but they will disappear once that patch will land.

[mehdi_amini]

Nice!

I love that we remove the need for PassDetail.h.

Since we guard things behind macros, could we generate everything in Passes.h.inc instead of the need of a separate TableGen invocation for Passes.cpp.inc? Is there an advantage to use both?

[mscuttari]

In D132838#3754956, @mehdi_amini wrote:

Nice!

I love that we remove the need for PassDetail.h.

Since we guard things behind macros, could we generate everything in Passes.h.inc instead of the need of a separate TableGen invocation for Passes.cpp.inc? Is there an advantage to use both?

PassDetail.h files are indeed not needed anymore and I removed them when it was trivial. There are some few passes that still need it, but it's just a matter of refactoring the code.

There's no real need for splitting .h.inc and .cpp.inc files, but it seems more clear to me from the user perspective. Public stuff goes into the .h.inc and gets included into the .h file, while private one goes into .cpp.inc and gets included by the .cpp one. Seems also coherent with the rest of the autogenerated code (e.g. dialect, types, etc.)

[Mogball]

Awesome!

[mscuttari]

Update flang passes

[mehdi_amini]

In D132838#3754976, @mscuttari wrote:

Since we guard things behind macros, could we generate everything in Passes.h.inc instead of the need of a separate TableGen invocation for Passes.cpp.inc? Is there an advantage to use both?

PassDetail.h files are indeed not needed anymore and I removed them when it was trivial. There are some few passes that still need it, but it's just a matter of refactoring the code.

There's no real need for splitting .h.inc and .cpp.inc files, but it seems more clear to me from the user perspective. Public stuff goes into the .h.inc and gets included into the .h file, while private one goes into .cpp.inc and gets included by the .cpp one. Seems also coherent with the rest of the autogenerated code (e.g. dialect, types, etc.)

I guess that would apply there as well: since we have macros anyway this is just extra boilerplate to generate more files and have more build steps / build configuration.

[rriddle]

In D132838#3756007, @mehdi_amini wrote:

In D132838#3754976, @mscuttari wrote:

Since we guard things behind macros, could we generate everything in Passes.h.inc instead of the need of a separate TableGen invocation for Passes.cpp.inc? Is there an advantage to use both?

PassDetail.h files are indeed not needed anymore and I removed them when it was trivial. There are some few passes that still need it, but it's just a matter of refactoring the code.

There's no real need for splitting .h.inc and .cpp.inc files, but it seems more clear to me from the user perspective. Public stuff goes into the .h.inc and gets included into the .h file, while private one goes into .cpp.inc and gets included by the .cpp one. Seems also coherent with the rest of the autogenerated code (e.g. dialect, types, etc.)

I guess that would apply there as well: since we have macros anyway this is just extra boilerplate to generate more files and have more build steps / build configuration.

I agree with Mehdi here.

[mscuttari]

Right. I will land D132572, open a new review to merge .cpp.inc into .h.inc (just for passes, fixing all the infra also for types, etc. is a bit too much for me) and then update this patch.

[mscuttari]

• Drop old declarations
• Fix some tests expecting the old pass names
• Convert missing flang passes
• Rebase to current upstream code

[mscuttari]

Fix formatting. Still I have to understand why clang-format doesn't run on some apparently random files.

[mscuttari]

Patch seems good from the build bots perspective. I've also dropped the old declarations, as they would not be needed anymore after this patch.
A lot of passes can be further updated to take advantage of the new infra (i.e. inheriting constructors, accepting options, removing redundant option structures), but I would like to separate this into additional and more self-contained patches, and possibly delegate them to more people as they need them to be implemented. My idea behind this patch is to just drop the old autogenerated files and adopt the new ones (patching the whole codebase to reflect the best practices is too much for a single person and sometimes would require discussing names, code organization, etc. which seems out of scope now).

[rriddle]

Don't feel like you are pressured to do all of the follow up cleanups, please file bugs for things and we can delegate from there.

[mscuttari]

In D132838#3759415, @rriddle wrote:

Don't feel like you are pressured to do all of the follow up cleanups, please file bugs for things and we can delegate from there.

Alright. I will wait also for @jpienaar (whose review seems to be mandatory from my understandings) and then make this land.

[rriddle]

In D132838#3759439, @mscuttari wrote:

In D132838#3759415, @rriddle wrote:

Don't feel like you are pressured to do all of the follow up cleanups, please file bugs for things and we can delegate from there.

Alright. I will wait also for @jpienaar (whose review seems to be mandatory from my understandings) and then make this land.

Ah, don't worry about that. You can feel free to land. (It's not mandatory in this case).

[Mogball]

@jpienaar you can't escape!

[mscuttari]

Well, build bots are complaining about some problems.
https://lab.llvm.org/buildbot/#/builders/220/builds/4537
https://lab.llvm.org/buildbot/#/builders/61/builds/31581

I will revert and try to fix.

[jpienaar]

Yes no need to wait for me here (I'm OOO but Rivers review sufficient for me here)

[mscuttari]

More conservative patch. Individual pass improvements are going to be handled by additional
patches.

[mscuttari]

Fix formatting

[mscuttari]

Patch landed, all builds seem fine.
As I have interest in some specific passes for my projects, I will upload additional revisions updating their code to be coherent with what explained in the docs (that is, they need naming change and options usage).
What should I do for the remaining ones (basically, all)? @rriddle was mentioning to open bugs and delegate them, but how should I proceed? One bug for each pass seems a lot to be done manually and would clutter the github issue page. Maybe we should let people discover the change and wait for a volunteer to fix his area of interest? (joking, but not too much :D)

P.S.: I can't close this patch, probably because of needed blocking review, but that's not a major issue atm.

[mehdi_amini]

What should I do for the remaining ones (basically, all)? @rriddle was mentioning to open bugs and delegate them, but how should I proceed? One bug for each pass seems a lot to be done manually and would clutter the github issue page.

In general we operate per areas: that is it could be "per dialect". I would file a single bug for the entire project and then tag people for each as we go.
If you file the bug with the instructions (before/after and pointer to the doc) that would already be great!

[mscuttari]

In D132838#3760825, @mehdi_amini wrote:

What should I do for the remaining ones (basically, all)? @rriddle was mentioning to open bugs and delegate them, but how should I proceed? One bug for each pass seems a lot to be done manually and would clutter the github issue page.

In general we operate per areas: that is it could be "per dialect". I would file a single bug for the entire project and then tag people for each as we go.
If you file the bug with the instructions (before/after and pointer to the doc) that would already be great!

Here it is: https://github.com/llvm/llvm-project/issues/57475
I did not include a "before" section as it is very specific to the pass (i.e. dialect specific transforms have a different namespace, as I discussed in the issue). There is an example of how it should look like after the modifications though, I hope it is enough.

[mehdi_amini]

mlir/tools/mlir-tblgen/PassGen.cpp

450

Could we reintroduce this and give a depreciation notice? Like informing the community that they have x weeks to migrate?

(I thought you would just convert the passes in this patch and remove the backward compatible code in a subsequent change)

[mscuttari]

mlir/tools/mlir-tblgen/PassGen.cpp

450

Actually that was my plan, but I realized that the CAPI generated code was not compatible with the new one. It was not a big deal in previous patches as no pass was using the new infra and thus the CAPI part could still use the old naming convention, but I had to change it once we started relying on the new stuff. Should I reintroduce it anyway?

[mehdi_amini]

mlir/tools/mlir-tblgen/PassGen.cpp

450

If it is possible to reintroduce this so that not every single users of the pass infrastructure has to update right now, it would be great indeed.

[mscuttari]

mlir/tools/mlir-tblgen/PassGen.cpp

450

Well, I'm looking at the CAPI gen file (tools/mlir-tblgen/PassCAPIGen.cpp) and it should work anyway. There may have been a moment in the development process where it wasn't, and that idea persisted in my mind. I will make some more checks and upload a revision for this.

[mscuttari]

mlir/tools/mlir-tblgen/PassGen.cpp

450

Review is up: D133027
Notice that the registration code for C APIs is still incompatible with the new autogenerated code. The old one was appending "Pass", while we now assume that it's already there in the name of the pass. I honestly don't know how much sense it would have to also backward support that, we would need some option to be set, but then users would still have to add it to their code (at that point, they can just update to the new conventions).

[mscuttari]

@jpienaar when you are back, please accept the review so that I can then hopefully close it (no hurry, take your time :))
Part of the non-auto-closing issue is that I wrongly put by hand "Differential Review" instead of "Differential Revision", but still I have no option to close it manually

[Mogball]

Just go ahead and land this

[mscuttari]

In D132838#3772159, @Mogball wrote:

Just go ahead and land this

It's already landed :)
Can't close the revision though.

[Mogball]

That's weird. I didn't realize that

flang/include/flang/Optimizer/CodeGen/CGPasses.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_CODEGEN_FIR_PASSES
 #define FORTRAN_OPTIMIZER_CODEGEN_FIR_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def FIRToLLVMLowering : Pass<"fir-to-llvm-ir", "mlir::ModuleOp"> {
+def FIRToLLVMLoweringPass : Pass<"fir-to-llvm-ir", "mlir::ModuleOp"> {
   let summary = "Convert FIR dialect to LLVM-IR dialect";
   let description = [{
     Convert the FIR dialect to the LLVM-IR dialect of MLIR. This conversion
     will also convert ops in the standard and FIRCG dialects.
   }];
   let constructor = "::fir::createFIRToLLVMPass()";
   let dependentDialects = ["mlir::LLVM::LLVMDialect"];
   let options = [
     Option<"forcedTargetTriple", "target", "std::string", /*default=*/"",
            "Override module's target triple.">
   ];
 }
 
-def CodeGenRewrite : Pass<"cg-rewrite", "mlir::ModuleOp"> {
+def CodeGenRewritePass : Pass<"cg-rewrite", "mlir::ModuleOp"> {
   let summary = "Rewrite some FIR ops into their code-gen forms.";
   let description = [{
     Fuse specific subgraphs into single Ops for code generation.
   }];
   let constructor = "::fir::createFirCodeGenRewritePass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "fir::FIRCodeGenDialect"
   ];
   let statistics = [
     Statistic<"numDCE", "num-dce'd", "Number of operations eliminated">
   ];
 }
 
-def TargetRewrite : Pass<"target-rewrite", "mlir::ModuleOp"> {
+def TargetRewritePass : Pass<"target-rewrite", "mlir::ModuleOp"> {
   let summary = "Rewrite some FIR dialect into target specific forms.";
   let description = [{
       Certain abstractions in the FIR dialect need to be rewritten to reflect
       representations that may differ based on the target machine.
   }];
   let constructor = "::fir::createFirTargetRewritePass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
   let options = [

flang/include/flang/Optimizer/CodeGen/CodeGen.h

 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 namespace fir {
 
 struct NameUniquer;
 
+#define GEN_PASS_DECL_FIRTOLLVMLOWERINGPASS
+#define GEN_PASS_DECL_CODEGENREWRITEPASS
+#define GEN_PASS_DECL_TARGETREWRITEPASS
+#define GEN_PASS_DECL_BOXEDPROCEDUREPASS
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+
 /// Prerequiste pass for code gen. Perform intermediate rewrites to perform
 /// the code gen (to LLVM-IR dialect) conversion.
 std::unique_ptr<mlir::Pass> createFirCodeGenRewritePass();
 
 /// FirTargetRewritePass options.
 struct TargetRewriteOptions {
   bool noCharacterConversion{};
   bool noComplexConversion{};

flang/include/flang/Optimizer/Transforms/Passes.h

 } // namespace mlir
 
 namespace fir {
 
 //===----------------------------------------------------------------------===//
 // Passes defined in Passes.td
 //===----------------------------------------------------------------------===//
 
+#define GEN_PASS_DECL_ABSTRACTRESULTONFUNCOPTPASS
+#define GEN_PASS_DECL_ABSTRACTRESULTONGLOBALOPTPASS
+#define GEN_PASS_DECL_AFFINEDIALECTPROMOTIONPASS
+#define GEN_PASS_DECL_AFFINEDIALECTDEMOTIONPASS
+#define GEN_PASS_DECL_ANNOTATECONSTANTOPERANDSPASS
+#define GEN_PASS_DECL_ARRAYVALUECOPYPASS
+#define GEN_PASS_DECL_CHARACTERCONVERSIONPASS
+#define GEN_PASS_DECL_CFGCONVERSIONPASS
+#define GEN_PASS_DECL_EXTERNALNAMECONVERSIONPASS
+#define GEN_PASS_DECL_MEMREFDATAFLOWOPTPASS
+#define GEN_PASS_DECL_SIMPLIFYINTRINSICSPASS
+#define GEN_PASS_DECL_MEMORYALLOCATIONOPTPASS
+#define GEN_PASS_DECL_SIMPLIFYREGIONLITEPASS
+#define GEN_PASS_DECL_ALGEBRAICSIMPLIFICATIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+
 std::unique_ptr<mlir::Pass> createAbstractResultOnFuncOptPass();
 std::unique_ptr<mlir::Pass> createAbstractResultOnGlobalOptPass();
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
 std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
 std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
 std::unique_ptr<mlir::Pass> createMemDataFlowOptPass();

flang/include/flang/Optimizer/Transforms/Passes.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FLANG_OPTIMIZER_TRANSFORMS_PASSES
 #define FLANG_OPTIMIZER_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-class AbstractResultOptBase<string optExt, string operation> 
+class AbstractResultOptBase<string optExt, string operation>
   : Pass<"abstract-result-on-" # optExt # "-opt", operation> {
   let summary = "Convert fir.array, fir.box and fir.rec function result to "
                 "function argument";
   let description = [{
     This pass is required before code gen to the LLVM IR dialect,
     including the pre-cg rewrite pass.
   }];
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
   let options = [
     Option<"passResultAsBox", "abstract-result-as-box",
            "bool", /*default=*/"false",
            "Pass fir.array<T> result as fir.box<fir.array<T>> argument instead"
            " of fir.ref<fir.array<T>>.">
   ];
 }
 
-def AbstractResultOnFuncOpt : AbstractResultOptBase<"func", "mlir::func::FuncOp"> {
+def AbstractResultOnFuncOptPass : AbstractResultOptBase<"func", "mlir::func::FuncOp"> {
   let constructor = "::fir::createAbstractResultOnFuncOptPass()";
 }
 
-def AbstractResultOnGlobalOpt : AbstractResultOptBase<"global", "fir::GlobalOp"> {
+def AbstractResultOnGlobalOptPass : AbstractResultOptBase<"global", "fir::GlobalOp"> {
   let constructor = "::fir::createAbstractResultOnGlobalOptPass()";
 }
 
-def AffineDialectPromotion : Pass<"promote-to-affine", "::mlir::func::FuncOp"> {
+def AffineDialectPromotionPass : Pass<"promote-to-affine", "::mlir::func::FuncOp"> {
   let summary = "Promotes `fir.{do_loop,if}` to `affine.{for,if}`.";
   let description = [{
     Convert fir operations which satisfy affine constraints to the affine
     dialect.
 
     `fir.do_loop` will be converted to `affine.for` if the loops inside the body
     can be converted and the indices for memory loads and stores satisfy
     `affine.apply` criteria for symbols and dimensions.
 
     `fir.if` will be converted to `affine.if` where possible. `affine.if`'s
     condition uses an integer set (==, >=) and an analysis is done to determine
     the fir condition's parent operations to construct the integer set.
 
     `fir.load` (`fir.store`) will be converted to `affine.load` (`affine.store`)
     where possible. This conversion includes adding a dummy `fir.convert` cast
     to adapt values of type `!fir.ref<!fir.array>` to `memref`. This is done
     because the affine dialect presently only understands the `memref` type.
   }];
   let constructor = "::fir::createPromoteToAffinePass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect", "mlir::AffineDialect"
   ];
 }
 
-def AffineDialectDemotion : Pass<"demote-affine", "::mlir::func::FuncOp"> {
+def AffineDialectDemotionPass : Pass<"demote-affine", "::mlir::func::FuncOp"> {
   let summary = "Converts `affine.{load,store}` back to fir operations";
   let description = [{
     Affine dialect's default lowering for loads and stores is different from
     fir as it uses the `memref` type. The `memref` type is not compatible with
     the Fortran runtime. Therefore, conversion of memory operations back to
     `fir.load` and `fir.store` with `!fir.ref<?>` types is required.
   }];
   let constructor = "::fir::createAffineDemotionPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect", "mlir::AffineDialect"
   ];
 }
 
-def AnnotateConstantOperands : Pass<"annotate-constant"> {
+def AnnotateConstantOperandsPass : Pass<"annotate-constant"> {
   let summary = "Annotate constant operands to all FIR operations";
   let description = [{
     The MLIR canonicalizer makes a distinction between constants based on how
     they are packaged in the IR. A constant value is wrapped in an Attr and that
     Attr can be attached to an Op. There is a distinguished Op, ConstantOp, that
     merely has one of these Attr attached.
 
     The MLIR canonicalizer treats constants referenced by an Op and constants
     referenced through a ConstantOp as having distinct semantics. This pass
     eliminates that distinction, so hashconsing of Ops, basic blocks, etc.
     behaves as one would expect.
   }];
   let constructor = "::fir::createAnnotateConstantOperandsPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
 }
 
-def ArrayValueCopy : Pass<"array-value-copy", "::mlir::func::FuncOp"> {
+def ArrayValueCopyPass : Pass<"array-value-copy", "::mlir::func::FuncOp"> {
   let summary = "Convert array value operations to memory operations.";
   let description = [{
     Transform the set of array value primitives to a memory-based array
     representation.
 
     The Ops `array_load`, `array_store`, `array_fetch`, and `array_update` are
     used to manage abstract aggregate array values. A simple analysis is done
     to determine if there are potential dependences between these operations.
     If not, these array operations can be lowered to work directly on the memory
     representation. If there is a potential conflict, a temporary is created
     along with appropriate copy-in/copy-out operations. Here, a more refined
     analysis might be deployed, such as using the affine framework.
 
     This pass is required before code gen to the LLVM IR dialect.
   }];
   let constructor = "::fir::createArrayValueCopyPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
 }
 
-def CharacterConversion : Pass<"character-conversion"> {
+def CharacterConversionPass : Pass<"character-conversion"> {
   let summary = "Convert CHARACTER entities with different KINDs";
   let description = [{
     Translates entities of one CHARACTER KIND to another.
 
     By default the translation is to naively zero-extend or truncate a code
     point to fit the destination size.
   }];
   let constructor = "::fir::createCharacterConversionPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
   let options = [
     Option<"useRuntimeCalls", "use-runtime-calls",
            "std::string", /*default=*/"std::string{}",
            "Generate runtime calls to a named set of conversion routines. "
            "By default, the conversions may produce unexpected results.">
   ];
 }
 
-def CFGConversion : Pass<"cfg-conversion", "::mlir::func::FuncOp"> {
+def CFGConversionPass : Pass<"cfg-conversion", "::mlir::func::FuncOp"> {
   let summary = "Convert FIR structured control flow ops to CFG ops.";
   let description = [{
     Transform the `fir.do_loop`, `fir.if`, and `fir.iterate_while` ops into
     plain old test and branch operations. Removing the high-level control
     structures can enable other optimizations.
 
     This pass is required before code gen to the LLVM IR dialect.
   }];
   let constructor = "::fir::createFirToCfgPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
   let options = [
     Option<"forceLoopToExecuteOnce", "always-execute-loop-body", "bool",
            /*default=*/"false",
            "force the body of a loop to execute at least once">
   ];
 }
 
-def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> {
+def ExternalNameConversionPass : Pass<"external-name-interop", "mlir::ModuleOp"> {
   let summary = "Convert name for external interoperability";
   let description = [{
     Demangle FIR internal name and mangle them for external interoperability.
   }];
   let constructor = "::fir::createExternalNameConversionPass()";
 }
 
-def MemRefDataFlowOpt : Pass<"fir-memref-dataflow-opt", "::mlir::func::FuncOp"> {
+def MemRefDataFlowOptPass : Pass<"fir-memref-dataflow-opt", "::mlir::func::FuncOp"> {
   let summary =
     "Perform store/load forwarding and potentially removing dead stores.";
   let description = [{
     This pass performs store to load forwarding to eliminate memory accesses and
     potentially the entire allocation if all the accesses are forwarded.
   }];
   let constructor = "::fir::createMemDataFlowOptPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
 }
 
 // This needs to be a "mlir::ModuleOp" pass, because it inserts simplified
 // functions into the module, which is invalid if a finer grain mlir::Operation
 // is used as the pass specification says to not touch things outside hte scope
 // of the operation being processed.
-def SimplifyIntrinsics : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
+def SimplifyIntrinsicsPass : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
   let summary = "Intrinsics simplification";
   let description = [{
     Qualifying intrinsics calls are replaced with calls to a specialized and
     simplified function. The simplified function is added to the current module.
     This function can be inlined by a general purpose inlining pass.
   }];
   let constructor = "::fir::createSimplifyIntrinsicsPass()";
 
   let options = [
     Option<"enableExperimental", "enable-experimental", "bool",
            /*default=*/"false",
            "Enable experimental code that may not always work correctly">
   ];
 }
 
-def MemoryAllocationOpt : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
+def MemoryAllocationOptPass : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
   let summary = "Convert stack to heap allocations and vice versa.";
   let description = [{
     Convert stack allocations to heap allocations and vice versa based on
     estimated size, lifetime, usage patterns, the call tree, etc.
   }];
   let dependentDialects = [ "fir::FIROpsDialect" ];
   let options = [
     Option<"dynamicArrayOnHeap", "dynamic-array-on-heap",
            "bool", /*default=*/"false",
            "Allocate all arrays with runtime determined size on heap.">,
     Option<"maxStackArraySize", "maximum-array-alloc-size",
            "std::size_t", /*default=*/"~static_cast<std::size_t>(0)",
            "Set maximum number of elements of an array allocated on the stack.">
   ];
   let constructor = "::fir::createMemoryAllocationPass()";
 }
 
-def SimplifyRegionLite : Pass<"simplify-region-lite", "mlir::ModuleOp"> {
+def SimplifyRegionLitePass : Pass<"simplify-region-lite", "mlir::ModuleOp"> {
   let summary = "Region simplification";
   let description = [{
     Run region DCE and erase unreachable blocks in regions.
   }];
   let constructor = "::fir::createSimplifyRegionLitePass()";
 }
 
-def AlgebraicSimplification : Pass<"flang-algebraic-simplification"> {
+def AlgebraicSimplificationPass : Pass<"flang-algebraic-simplification"> {
   let summary = "";
   let description = [{
     Run algebraic simplifications for Math/Complex/etc. dialect operations.
     This is a flang specific pass, because we may want to "tune"
     the rewrite patterns specifically for Fortran (e.g. increase
     the limit for constant exponent value that defines the cases
     when pow(x, constant) is transformed into a set of multiplications, etc.).
   }];
   let dependentDialects = [ "mlir::math::MathDialect" ];
   let constructor = "::fir::createAlgebraicSimplificationPass()";
 }
 
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/include/flang/Tools/CLOptions.inc

inline void createDefaultFIROptimizerPassPipeline(
   llvm::StringMap<mlir::OpPassManager> pipelines;
   pm.addPass(
       mlir::createInlinerPass(pipelines, defaultFlangInlinerOptPipeline));
   pm.addPass(fir::createSimplifyRegionLitePass());
   pm.addPass(mlir::createCSEPass());
 
   // convert control flow to CFG form
   fir::addCfgConversionPass(pm);
-  pm.addPass(mlir::createConvertSCFToCFPass());
+  pm.addPass(mlir::createConvertSCFToControlFlowPass());
 
   pm.addPass(mlir::createCanonicalizerPass(config));
   pm.addPass(fir::createSimplifyRegionLitePass());
   pm.addPass(mlir::createCSEPass());
 }
 
 #if !defined(FLANG_EXCLUDE_CODEGEN)
 inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {

flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp

 //===-- BoxedProcedure.cpp ------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
-#include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace fir {
+#define GEN_PASS_DEF_BOXEDPROCEDUREPASS
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-procedure-pointer"
 
 using namespace fir;
 
 namespace {
 /// Options to the procedure pointer pass.
 struct BoxedProcedureOptions {
   // Lower the boxproc abstraction to function pointers and thunks where

 /// There are any number of possible implementations possible.
 ///
 /// The implementation used here is to convert `boxproc` values to function
 /// pointers everywhere. If a `boxproc` value includes a frame pointer to the
 /// host procedure's data, then a thunk will be created at runtime to capture
 /// the frame pointer during execution. In LLVM IR, the frame pointer is
 /// designated with the `nest` attribute. The thunk's address will then be used
 /// as the call target instead of the original function's address directly.
-class BoxedProcedurePass : public BoxedProcedurePassBase<BoxedProcedurePass> {
+class BoxedProcedurePass : public fir::impl::BoxedProcedurePassBase<BoxedProcedurePass> {
 public:
   BoxedProcedurePass() { options = {true}; }
   BoxedProcedurePass(bool useThunks) { options = {useThunks}; }
 
   inline mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     if (options.useThunks) {

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 //===-- CodeGen.cpp -- bridge to lower to LLVM ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
+
 #include "CGOps.h"
-#include "PassDetail.h"
 #include "flang/ISO_Fortran_binding.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Support/TypeCode.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
 #include "mlir/Conversion/MathToLibm/MathToLibm.h"
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "llvm/ADT/ArrayRef.h"
 
+namespace fir {
+#define GEN_PASS_DEF_FIRTOLLVMLOWERINGPASS
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-codegen"
 
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
 #include "TypeConverter.h"
 
 // TODO: This should really be recovered from the specified target.
 static constexpr unsigned defaultAlign = 8;
 

 
 } // namespace
 
 namespace {
 /// Convert FIR dialect to LLVM dialect
 ///
 /// This pass lowers all FIR dialect operations to LLVM IR dialect. An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
-class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
+class FIRToLLVMLowering : public fir::impl::FIRToLLVMLoweringPassBase<FIRToLLVMLowering> {
 public:
   FIRToLLVMLowering() = default;
   FIRToLLVMLowering(fir::FIRToLLVMPassOptions options) : options{options} {}
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto mod = getModule();
     if (!forcedTargetTriple.empty())

flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp

 //===-- PreCGRewrite.cpp --------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
-#include "CGOps.h"
-#include "PassDetail.h"
 #include "flang/Optimizer/CodeGen/CodeGen.h"
+
+#include "CGOps.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_CODEGENREWRITEPASS
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+} // namespace fir
+
 //===----------------------------------------------------------------------===//
 // Codegen rewrite: rewriting of subgraphs of ops
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "flang-codegen-rewrite"
 
 static void populateShape(llvm::SmallVectorImpl<mlir::Value> &vec,
                           fir::ShapeOp shape) {
auto xArrCoor = rewriter.create<fir::cg::XArrayCoorOp>(
         arrCoor.getTypeparams());
     LLVM_DEBUG(llvm::dbgs()
                << "rewriting " << arrCoor << " to " << xArrCoor << '\n');
     rewriter.replaceOp(arrCoor, xArrCoor.getOperation()->getResults());
     return mlir::success();
   }
 };
 
-class CodeGenRewrite : public fir::CodeGenRewriteBase<CodeGenRewrite> {
+class CodeGenRewrite : public fir::impl::CodeGenRewritePassBase<CodeGenRewrite> {
 public:
   void runOn(mlir::Operation *op, mlir::Region &region) {
     auto &context = getContext();
     mlir::OpBuilder rewriter(&context);
     mlir::ConversionTarget target(context);
     target.addLegalDialect<mlir::arith::ArithmeticDialect, fir::FIROpsDialect,
                            fir::FIRCodeGenDialect, mlir::func::FuncDialect>();
     target.addIllegalOp<fir::ArrayCoorOp>();

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

 //===-- TargetRewrite.cpp -------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Target rewrite: rewriting of ops to make target-specific lowerings manifest.
 // LLVM expects different lowering idioms to be used for distinct target
 // triples. These distinctions are handled by this pass.
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+
 #include "Target.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
-#include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_TARGETREWRITEPASS
+#include "flang/Optimizer/CodeGen/CGPasses.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-target-rewrite"
 
 namespace {
 
 /// Fixups for updating a FuncOp's arguments and return values.
 struct FixupTy {
   enum class Codes {
     ArgumentAsLoad,
struct FixupTy {
   std::size_t second{};
   llvm::Optional<std::function<void(mlir::func::FuncOp)>> finalizer{};
 }; // namespace
 
 /// Target-specific rewriting of the FIR. This is a prerequisite pass to code
 /// generation that traverses the FIR and modifies types and operations to a
 /// form that is appropriate for the specific target. LLVM IR has specific
 /// idioms that are used for distinct target processor and ABI combinations.
-class TargetRewrite : public fir::TargetRewriteBase<TargetRewrite> {
+class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
 public:
   TargetRewrite(const fir::TargetRewriteOptions &options) {
     noCharacterConversion = options.noCharacterConversion;
     noComplexConversion = options.noComplexConversion;
   }
 
   void runOnOperation() override final {
     auto &context = getContext();

flang/lib/Optimizer/Transforms/AbstractResult.cpp

 //===- AbstractResult.cpp - Conversion of Abstract Function Result --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace fir {
+#define GEN_PASS_DEF_ABSTRACTRESULTONFUNCOPTPASS
+#define GEN_PASS_DEF_ABSTRACTRESULTONGLOBALOPTPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-abstract-result-opt"
 
 namespace fir {
 namespace {
 
 static mlir::Type getResultArgumentType(mlir::Type resultType,
                                         bool shouldBoxResult) {
   return llvm::TypeSwitch<mlir::Type, mlir::Type>(resultType)
if (mlir::failed(
       mlir::emitError(op.getLoc(), "error in converting abstract results\n");
       this->signalPassFailure();
     }
   }
 };
 
 class AbstractResultOnFuncOpt
     : public AbstractResultOptTemplate<AbstractResultOnFuncOpt,
-                                       fir::AbstractResultOnFuncOptBase> {
+                                       fir::impl::AbstractResultOnFuncOptPassBase> {
 public:
   void runOnSpecificOperation(mlir::func::FuncOp func, bool shouldBoxResult,
                               mlir::RewritePatternSet &patterns,
                               mlir::ConversionTarget &target) {
     auto loc = func.getLoc();
     auto *context = &getContext();
     // Convert function type itself if it has an abstract result.
     auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
return mlir::TypeSwitch<mlir::Type, bool>(type)
         return fir::hasAbstractResult(
             pointer.getEleTy().cast<mlir::FunctionType>());
       })
       .Default([](auto &&) { return false; });
 }
 
 class AbstractResultOnGlobalOpt
     : public AbstractResultOptTemplate<AbstractResultOnGlobalOpt,
-                                       fir::AbstractResultOnGlobalOptBase> {
+                                       fir::impl::AbstractResultOnGlobalOptPassBase> {
 public:
   void runOnSpecificOperation(fir::GlobalOp global, bool,
                               mlir::RewritePatternSet &,
                               mlir::ConversionTarget &) {
     if (containsFunctionTypeWithAbstractResult(global.getType())) {
       TODO(global->getLoc(), "support for procedure pointers");
     }
   }

flang/lib/Optimizer/Transforms/AffineDemotion.cpp

 // It is used after the AffinePromotion pass.
 // It is not part of the production pipeline and would need more work in order
 // to be used in production.
 // More information can be found in this presentation:
 // https://slides.com/rajanwalia/deck
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Visitors.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_AFFINEDIALECTDEMOTIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-affine-demotion"
 
 using namespace fir;
 using namespace mlir;
 
 namespace {
 
 class AffineLoadConversion : public OpConversionPattern<mlir::AffineLoadOp> {
matchAndRewrite(memref::AllocOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<fir::AllocaOp>(op, convertMemRef(op.getType()),
                                                op.memref());
     return success();
   }
 };
 
 class AffineDialectDemotion
-    : public AffineDialectDemotionBase<AffineDialectDemotion> {
+    : public fir::impl::AffineDialectDemotionPassBase<AffineDialectDemotion> {
 public:
   void runOnOperation() override {
     auto *context = &getContext();
     auto function = getOperation();
     LLVM_DEBUG(llvm::dbgs() << "AffineDemotion: running on function:\n";
                function.print(llvm::dbgs()););
 
     mlir::RewritePatternSet patterns(context);

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

 // to affine dialect operations.
 // It is not part of the production pipeline and would need more work in order
 // to be used in production.
 // More information can be found in this presentation:
 // https://slides.com/rajanwalia/deck
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Visitors.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_AFFINEDIALECTPROMOTIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-affine-promotion"
 
 using namespace fir;
 using namespace mlir;
 
 namespace {
 struct AffineLoopAnalysis;
 struct AffineIfAnalysis;
matchAndRewrite(fir::IfOp op,
     rewriter.replaceOp(op, affineIf.getOperation()->getResults());
     return success();
   }
 };
 
 /// Promote fir.do_loop and fir.if to affine.for and affine.if, in the cases
 /// where such a promotion is possible.
 class AffineDialectPromotion
-    : public AffineDialectPromotionBase<AffineDialectPromotion> {
+    : public fir::impl::AffineDialectPromotionPassBase<AffineDialectPromotion> {
 public:
   void runOnOperation() override {
 
     auto *context = &getContext();
     auto function = getOperation();
     markAllAnalysesPreserved();
     auto functionAnalysis = AffineFunctionAnalysis(function);
     mlir::RewritePatternSet patterns(context);

flang/lib/Optimizer/Transforms/AlgebraicSimplification.cpp

 //===- AlgebraicSimplification.cpp - Simplify algebraic expressions -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 // This file defines a pass that applies algebraic simplifications
 // to operations of Math/Complex/etc. dialects that are used by Flang.
 // It is done as a Flang specific pass, because we may want to tune
 // the parameters of the patterns for Fortran programs.
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Math/Transforms/Passes.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace fir {
+#define GEN_PASS_DEF_ALGEBRAICSIMPLIFICATIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 using namespace mlir;
 
 namespace {
 struct AlgebraicSimplification
-    : public fir::AlgebraicSimplificationBase<AlgebraicSimplification> {
+    : public fir::impl::AlgebraicSimplificationPassBase<
+          AlgebraicSimplification> {
   AlgebraicSimplification(const GreedyRewriteConfig &rewriteConfig) {
     config = rewriteConfig;
   }
 
   void runOnOperation() override;
 
   mlir::GreedyRewriteConfig config;
 };

flang/lib/Optimizer/Transforms/AnnotateConstant.cpp

 //===-- AnnotateConstant.cpp ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+// #include "PassDetail.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/IR/BuiltinAttributes.h"
 
+namespace fir {
+#define GEN_PASS_DEF_ANNOTATECONSTANTOPERANDSPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-annotate-constant"
 
 using namespace fir;
 
 namespace {
 struct AnnotateConstantOperands
-    : AnnotateConstantOperandsBase<AnnotateConstantOperands> {
+    : impl::AnnotateConstantOperandsPassBase<AnnotateConstantOperands> {
   void runOnOperation() override {
     auto *context = &getContext();
     mlir::Dialect *firDialect = context->getLoadedDialect("fir");
     getOperation()->walk([&](mlir::Operation *op) {
       // We filter out other dialects even though they may undergo merging of
       // non-equal constant values by the canonicalizer as well.
       if (op->getDialect() == firDialect) {
         llvm::SmallVector<mlir::Attribute> attrs;

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

 //===-- ArrayValueCopy.cpp ------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Builder/Array.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Factory.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_ARRAYVALUECOPYPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-array-value-copy"
 
 using namespace fir;
 using namespace mlir;
 
 using OperationUseMapT = llvm::DenseMap<mlir::Operation *, mlir::Operation *>;
 
 namespace {
matchAndRewrite(ArrayAmendOp amend,
     auto loc = amend.getLoc();
     auto undef = rewriter.create<UndefOp>(loc, amend.getType());
     rewriter.replaceOp(amend, undef.getResult());
     return mlir::success();
   }
 };
 
 class ArrayValueCopyConverter
-    : public ArrayValueCopyBase<ArrayValueCopyConverter> {
+    : public fir::impl::ArrayValueCopyPassBase<ArrayValueCopyConverter> {
 public:
   void runOnOperation() override {
     auto func = getOperation();
     LLVM_DEBUG(llvm::dbgs() << "\n\narray-value-copy pass on function '"
                             << func.getName() << "'\n");
     auto *context = &getContext();
 
     // Perform the conflict analysis.

flang/lib/Optimizer/Transforms/CharacterConversion.cpp

 //===- CharacterConversion.cpp -- convert between character encodings -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/Debug.h"
 
+namespace fir {
+#define GEN_PASS_DEF_CHARACTERCONVERSIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-character-conversion"
 
 namespace {
 
 // TODO: Future hook to select some set of runtime calls.
 struct CharacterConversionOptions {
   std::string runtimeName;
 };
matchAndRewrite(fir::CharConvertOp conv,
     rewriter.restoreInsertionPoint(insPt);
     return mlir::success();
   }
 };
 
 /// Rewrite the `fir.char_convert` op into a loop. This pass must be run only on
 /// fir::CharConvertOp.
 class CharacterConversion
-    : public fir::CharacterConversionBase<CharacterConversion> {
+    : public fir::impl::CharacterConversionPassBase<CharacterConversion> {
 public:
   void runOnOperation() override {
     CharacterConversionOptions clOpts{useRuntimeCalls.getValue()};
     if (clOpts.runtimeName.empty()) {
       auto *context = &getContext();
       auto *func = getOperation();
       mlir::RewritePatternSet patterns(context);
       patterns.insert<CharacterConvertConversion>(context);

flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp

 //===- ExternalNameConversion.cpp -- convert name with external convention ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace fir {
+#define GEN_PASS_DEF_EXTERNALNAMECONVERSIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Helper functions
 //===----------------------------------------------------------------------===//
 
 /// Mangle the name with gfortran convention.
 std::string
if (fir::NameUniquer::isExternalFacingUniquedName(result)) {
       rewriter.replaceOpWithNewOp<fir::AddrOfOp>(op, op.getResTy().getType(),
                                                  newName);
     }
     return success();
   }
 };
 
 class ExternalNameConversionPass
-    : public fir::ExternalNameConversionBase<ExternalNameConversionPass> {
+    : public fir::impl::ExternalNameConversionPassBase<
+          ExternalNameConversionPass> {
 public:
   mlir::ModuleOp getModule() { return getOperation(); }
   void runOnOperation() override;
 };
 } // namespace
 
 void ExternalNameConversionPass::runOnOperation() {
   auto op = getOperation();

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

 //===- MemRefDataFlowOpt.cpp - Memory DataFlow Optimization pass ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 
+namespace fir {
+#define GEN_PASS_DEF_MEMREFDATAFLOWOPTPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "fir-memref-dataflow-opt"
 
 using namespace mlir;
 
 namespace {
 
 template <typename OpT>
 static std::vector<OpT> getSpecificUsers(mlir::Value v) {
llvm::Optional<ReadOp> findReadForWrite(WriteOp storeOp,
     }
     return {};
   }
 
 private:
   mlir::DominanceInfo *domInfo;
 };
 
-class MemDataFlowOpt : public fir::MemRefDataFlowOptBase<MemDataFlowOpt> {
+class MemDataFlowOpt
+    : public fir::impl::MemRefDataFlowOptPassBase<MemDataFlowOpt> {
 public:
   void runOnOperation() override {
     mlir::func::FuncOp f = getOperation();
 
     auto *domInfo = &getAnalysis<mlir::DominanceInfo>();
     LoadStoreForwarding<fir::LoadOp, fir::StoreOp> lsf(domInfo);
     f.walk([&](fir::LoadOp loadOp) {
       auto maybeStore = lsf.findStoreToForward(

flang/lib/Optimizer/Transforms/MemoryAllocation.cpp

 //===- MemoryAllocation.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace fir {
+#define GEN_PASS_DEF_MEMORYALLOCATIONOPTPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-memory-allocation-opt"
 
 // Number of elements in an array does not determine where it is allocated.
 static constexpr std::size_t unlimitedArraySize = ~static_cast<std::size_t>(0);
 
 namespace {
 struct MemoryAllocationOptions {
   // Always move dynamic array allocations to the heap. This may result in more

 /// workarounds for conditions such as environments with limited stack space.
 ///
 /// Currently, implements two conversions from stack to heap allocation.
 ///   1. If a stack allocation is an array larger than some threshold value
 ///      make it a heap allocation.
 ///   2. If a stack allocation is an array with a runtime evaluated size make
 ///      it a heap allocation.
 class MemoryAllocationOpt
-    : public fir::MemoryAllocationOptBase<MemoryAllocationOpt> {
+    : public fir::impl::MemoryAllocationOptPassBase<MemoryAllocationOpt> {
 public:
   MemoryAllocationOpt() {
     // Set options with default values. (See Passes.td.) Note that the
     // command-line options, e.g. dynamicArrayOnHeap,  are not set yet.
     options = {dynamicArrayOnHeap, maxStackArraySize};
   }
 
   MemoryAllocationOpt(bool dynOnHeap, std::size_t maxStackSize) {

flang/lib/Optimizer/Transforms/PassDetail.h

-//===- PassDetail.h - Optimizer Transforms Pass class details ---*- 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 FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
-#define FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
-
-#include "flang/Optimizer/Dialect/FIRDialect.h"
-#include "flang/Optimizer/Dialect/FIROps.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
-#include "mlir/Dialect/Math/IR/Math.h"
-#include "mlir/Dialect/OpenACC/OpenACC.h"
-#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Pass/PassRegistry.h"
-
-namespace fir {
-
-#define GEN_PASS_CLASSES
-#include "flang/Optimizer/Transforms/Passes.h.inc"
-
-} // namespace fir
-
-#endif // FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

 //===-- RewriteLoop.cpp ---------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/CommandLine.h"
 
+namespace fir {
+#define GEN_PASS_DEF_CFGCONVERSIONPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 using namespace fir;
 using namespace mlir;
 
 namespace {
 
 // Conversion of fir control ops to more primitive control-flow.
 //
 // FIR loops that cannot be converted to the affine dialect will remain as
auto args = whileOp.getFinalValue()
                     ? conditionBlock->getArguments()
                     : conditionBlock->getArguments().drop_front();
     rewriter.replaceOp(whileOp, args);
     return success();
   }
 };
 
 /// Convert FIR structured control flow ops to CFG ops.
-class CfgConversion : public CFGConversionBase<CfgConversion> {
+class CfgConversion : public fir::impl::CFGConversionPassBase<CfgConversion> {
 public:
   void runOnOperation() override {
     auto *context = &getContext();
     mlir::RewritePatternSet patterns(context);
     patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(
         context, forceLoopToExecuteOnce);
     mlir::ConversionTarget target(*context);
     target.addLegalDialect<mlir::AffineDialect, mlir::cf::ControlFlowDialect,

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

 //  for higher dimension arrays, of course)
 ///
 /// The general idea is that besides making the call simpler, it can also be
 /// inlined by other passes that run after this pass, which further improves
 /// performance, particularly when the work done in the function is trivial
 /// and small in size.
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace fir {
+#define GEN_PASS_DEF_SIMPLIFYINTRINSICSPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 #define DEBUG_TYPE "flang-simplify-intrinsics"
 
 namespace {
 
 class SimplifyIntrinsicsPass
-    : public fir::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
+    : public fir::impl::SimplifyIntrinsicsPassBase<SimplifyIntrinsicsPass> {
   using FunctionTypeGeneratorTy =
       std::function<mlir::FunctionType(fir::FirOpBuilder &)>;
   using FunctionBodyGeneratorTy =
       std::function<void(fir::FirOpBuilder &, mlir::func::FuncOp &)>;
 
 public:
   /// Generate a new function implementing a simplified version
   /// of a Fortran runtime function defined by \p basename name.

flang/lib/Optimizer/Transforms/SimplifyRegionLite.cpp

 //===- SimplifyRegionLite.cpp -- region simplification lite ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
 
+namespace fir {
+#define GEN_PASS_DEF_SIMPLIFYREGIONLITEPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
 namespace {
 
 class SimplifyRegionLitePass
-    : public fir::SimplifyRegionLiteBase<SimplifyRegionLitePass> {
+    : public fir::impl::SimplifyRegionLitePassBase<SimplifyRegionLitePass> {
 public:
   void runOnOperation() override;
 };
 
 class DummyRewriter : public mlir::PatternRewriter {
 public:
   DummyRewriter(mlir::MLIRContext *ctx) : mlir::PatternRewriter(ctx) {}
 };

mlir/include/mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h

 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTAMDGPUTOROCDLPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 void populateAMDGPUToROCDLConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns,
                                              amdgpu::Chipset chipset);
 
-std::unique_ptr<Pass> createConvertAMDGPUToROCDLPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_AMDGPUTOROCDL_AMDGPUTOROCDL_H_

mlir/include/mlir/Conversion/AffineToStandard/AffineToStandard.h

 class OpBuilder;
 class Pass;
 class RewritePattern;
 class Value;
 class ValueRange;
 
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTAFFINETOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of patterns to convert from the Affine dialect to the Standard
 /// dialect, in particular convert structured affine control flow into CFG
 /// branch-based control flow.
 void populateAffineToStdConversionPatterns(RewritePatternSet &patterns);
 
 /// Collect a set of patterns to convert vector-related Affine ops to the Vector
 /// dialect.
 void populateAffineToVectorConversionPatterns(RewritePatternSet &patterns);
 
 /// Emit code that computes the lower bound of the given affine loop using
 /// standard arithmetic operations.
 Value lowerAffineLowerBound(AffineForOp op, OpBuilder &builder);
 
 /// Emit code that computes the upper bound of the given affine loop using
 /// standard arithmetic operations.
 Value lowerAffineUpperBound(AffineForOp op, OpBuilder &builder);
 
-/// Lowers affine control flow operations (ForStmt, IfStmt and AffineApplyOp)
-/// to equivalent lower-level constructs (flow of basic blocks and arithmetic
-/// primitives).
-std::unique_ptr<Pass> createLowerAffinePass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H

mlir/include/mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h

 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTARITHMETICTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 namespace arith {
 void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                 RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createConvertArithmeticToLLVMPass();
 } // namespace arith
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H

mlir/include/mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h

 #include <memory>
 
 namespace mlir {
 
 class SPIRVTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTARITHMETICTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 namespace arith {
 void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                        RewritePatternSet &patterns);
 
-std::unique_ptr<OperationPass<>> createConvertArithmeticToSPIRVPass();
 } // namespace arith
+
+std::unique_ptr<OperationPass<>> createConvertArithmeticToSPIRVPass();
+
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H

mlir/include/mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h

 //===- ArmNeon2dToIntr.h - convert Arm Neon 2d ops to intrinsics ----------===//
 //
 // 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_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
 #define MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_
 
-#include "mlir/Pass/Pass.h"
+#include <memory>
 
 namespace mlir {
+class Pass;
+class RewritePatternSet;
+
+#define GEN_PASS_DECL_CONVERTARMNEON2DTOINTRPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Populates patterns for the lowering of Arm NEON 2D ops to intrinsics.
 /// See createConvertArmNeon2dToIntrPass.
 void populateConvertArmNeon2dToIntrPatterns(RewritePatternSet &patterns);
 
-/// Creates a pass to lower Arm NEON 2D ops to intrinsics, i.e.
-/// equivalent ops operating on flattened 1D vectors and mapping more
-/// directly to the corresponding Arm NEON instruction.
-std::unique_ptr<Pass> createConvertArmNeon2dToIntrPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ARMNEON2DTOINTR_ARMNEON2DTOINTR_H_

mlir/include/mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h

 class ConversionTarget;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class MLIRContext;
 class TypeConverter;
 class RewritePatternSet;
 
-/// Create a pass to convert Async operations to the LLVM dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
+#define GEN_PASS_DECL_CONVERTASYNCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
 
 /// Populates patterns for async structural type conversions.
 ///
 /// A "structural" type conversion is one where the underlying ops are
 /// completely agnostic to the actual types involved and simply need to update
 /// their types. An example of this is async.execute -- the async.execute op and
 /// the corresponding async.yield ops need to update their types accordingly to
 /// the TypeConverter, but otherwise don't care what type conversions are
 /// happening.
 void populateAsyncStructuralTypeConversionsAndLegality(
     TypeConverter &typeConverter, RewritePatternSet &patterns,
     ConversionTarget &target);
 
+/// Create a pass to convert Async operations to the LLVM dialect.
+std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
+
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ASYNCTOLLVM_ASYNCTOLLVM_H

mlir/include/mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h

 #define MLIR_CONVERSION_BUFFERIZATIONTOMEMREF_BUFFERIZATIONTOMEMREF_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTBUFFERIZATIONTOMEMREFPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of patterns to convert memory-related operations from the
 /// Bufferization dialect to the MemRef dialect.
 void populateBufferizationToMemRefConversionPatterns(
     RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createBufferizationToMemRefPass();
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_BUFFERIZATIONTOMEMREF_BUFFERIZATIONTOMEMREF_H

mlir/include/mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h

 
 #include "mlir/Conversion/LLVMCommon/StructBuilder.h"
 
 namespace mlir {
 class LLVMTypeConverter;
 class Pass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTCOMPLEXTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 class ComplexStructBuilder : public StructBuilder {
 public:
   /// Construct a helper for the given complex number value.
   using StructBuilder::StructBuilder;
   /// Build IR creating an `undef` value of the complex number type.
   static ComplexStructBuilder undef(OpBuilder &builder, Location loc,
                                     Type type);
 
   // Build IR extracting the real value from the complex number struct.
   Value real(OpBuilder &builder, Location loc);
   // Build IR inserting the real value into the complex number struct.
   void setReal(OpBuilder &builder, Location loc, Value real);
 
   // Build IR extracting the imaginary value from the complex number struct.
   Value imaginary(OpBuilder &builder, Location loc);
   // Build IR inserting the imaginary value into the complex number struct.
   void setImaginary(OpBuilder &builder, Location loc, Value imaginary);
 };
 
 /// Populate the given list with patterns that convert from Complex to LLVM.
 void populateComplexToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns);
 
-/// Create a pass to convert Complex operations to the LLVMIR dialect.
-std::unique_ptr<Pass> createConvertComplexToLLVMPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_COMPLEXTOLLVM_COMPLEXTOLLVM_H_

mlir/include/mlir/Conversion/ComplexToLibm/ComplexToLibm.h

 //===- ComplexToLibm.h - Utils to convert from the complex dialect --------===//
 //
 // 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_CONVERSION_COMPLEXTOLIBM_COMPLEXTOLIBM_H_
 #define MLIR_CONVERSION_COMPLEXTOLIBM_COMPLEXTOLIBM_H_
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTCOMPLEXTOLIBMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Populate the given list with patterns that convert from Complex to Libm
 /// calls.
 void populateComplexToLibmConversionPatterns(RewritePatternSet &patterns,
                                              PatternBenefit benefit);
 
 /// Create a pass to convert Complex operations to libm calls.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertComplexToLibmPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_COMPLEXTOLIBM_COMPLEXTOLIBM_H_

mlir/include/mlir/Conversion/ComplexToStandard/ComplexToStandard.h

 //===- ComplexToStandard.h - Utils to convert from the complex dialect ----===//
 //
 // 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_CONVERSION_COMPLEXTOSTANDARD_COMPLEXTOSTANDARD_H_
 #define MLIR_CONVERSION_COMPLEXTOSTANDARD_COMPLEXTOSTANDARD_H_
 
 #include <memory>
 
 namespace mlir {
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTCOMPLEXTOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Populate the given list with patterns that convert from Complex to Standard.
 void populateComplexToStandardConversionPatterns(RewritePatternSet &patterns);
 
-/// Create a pass to convert Complex operations to the Standard dialect.
-std::unique_ptr<Pass> createConvertComplexToStandardPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_COMPLEXTOSTANDARD_COMPLEXTOSTANDARD_H_

mlir/include/mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h

 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 namespace cf {
 /// Collect the patterns to convert from the ControlFlow dialect to LLVM. The
 /// conversion patterns capture the LLVMTypeConverter by reference meaning the
 /// references have to remain alive during the entire pattern lifetime.
 void populateControlFlowToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                  RewritePatternSet &patterns);
 
-/// Creates a pass to convert the ControlFlow dialect into the LLVMIR dialect.
-std::unique_ptr<Pass> createConvertControlFlowToLLVMPass();
 } // namespace cf
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_CONTROLFLOWTOLLVM_CONTROLFLOWTOLLVM_H

mlir/include/mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.h

 #ifndef MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRVPASS_H
 #define MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert ControlFlow ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertControlFlowToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_CONTROLFLOWTOSPIRV_CONTROLFLOWTOSPIRVPASS_H

mlir/include/mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h

 //===- ConvertFuncToLLVMPass.h - Pass entrypoint ----------------*- 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_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
 #define MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_
 
 #include <memory>
+#include <string>
 
 namespace mlir {
 class LowerToLLVMOptions;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTFUNCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert the Func dialect into the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertFuncToLLVMPass();
 std::unique_ptr<OperationPass<ModuleOp>>
 createConvertFuncToLLVMPass(const LowerToLLVMOptions &options);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_FUNCTOLLVM_CONVERTFUNCTOLLVMPASS_H_

mlir/include/mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h

 #ifndef MLIR_CONVERSION_FUNCTOSPIRV_FUNCTOSPIRVPASS_H
 #define MLIR_CONVERSION_FUNCTOSPIRV_FUNCTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTFUNCTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert Func ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertFuncToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_FUNCTOSPIRV_FUNCTOSPIRVPASS_H

mlir/include/mlir/Conversion/GPUCommon/GPUCommonPass.h

 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 
 namespace LLVM {
 class LLVMDialect;
 } // namespace LLVM
 
+#define GEN_PASS_DECL_CONVERTGPUTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 using OwnedBlob = std::unique_ptr<std::vector<char>>;
 using BlobGenerator =
     std::function<OwnedBlob(const std::string &, Location, StringRef)>;
 using LoweringCallback = std::function<std::unique_ptr<llvm::Module>(
     Operation *, llvm::LLVMContext &, StringRef)>;
 
+/// Collect a set of patterns to convert from the GPU dialect to LLVM and
+/// populate converter for gpu types.
+void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
+                                         RewritePatternSet &patterns,
+                                         StringRef gpuBinaryAnnotation = {},
+                                         bool kernelBarePtrCallConv = false);
+
 /// Creates a pass to convert a GPU operations into a sequence of GPU runtime
 /// calls.
 ///
 /// This pass does not generate code to call GPU runtime APIs directly but
 /// instead uses a small wrapper library that exports a stable and conveniently
 /// typed ABI on top of GPU runtimes such as CUDA or ROCm (HIP).
 std::unique_ptr<OperationPass<ModuleOp>>
-createGpuToLLVMConversionPass(bool kernelBarePtrCallConv = false);
-
-/// Collect a set of patterns to convert from the GPU dialect to LLVM and
-/// populate converter for gpu types.
-void populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
-                                         RewritePatternSet &patterns,
-                                         StringRef gpuBinaryAnnotation = {},
-                                         bool kernelBarePtrCallConv = false);
+createConvertGpuToLLVMPass(bool kernelBarePtrCallConv = false);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_

mlir/include/mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h

 template <typename OpT>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 class MMAMatrixType;
 } // namespace gpu
 
+#define GEN_PASS_DECL_CONVERTGPUTONVVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 LLVM::LLVMStructType convertMMAToLLVMType(gpu::MMAMatrixType type);
 
 /// Configure target to convert from the GPU dialect to NVVM.
 void configureGpuToNVVMConversionLegality(ConversionTarget &target);
 
 /// Collect a set of patterns to convert from the GPU dialect to NVVM.
 void populateGpuToNVVMConversionPatterns(LLVMTypeConverter &converter,
                                          RewritePatternSet &patterns);
 
 /// Collect a set of patterns to convert WMMA ops from GPU dialect to NVVM.
 void populateGpuWMMAToNVVMConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns);
 
 /// Creates a pass that lowers GPU dialect operations to NVVM counterparts. The
 /// index bitwidth used for the lowering of the device side index computations
 /// is configurable.
-std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createLowerGpuOpsToNVVMOpsPass(
+std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createConvertGpuToNVVMPass(
     unsigned indexBitwidth = kDeriveIndexBitwidthFromDataLayout);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_

mlir/include/mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h

 
 template <typename OpT>
 class OperationPass;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 
+#define GEN_PASS_DECL_CONVERTGPUTOROCDLPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of patterns to convert from the GPU dialect to ROCDL.
 /// If `runtime` is Unknown, gpu.printf will not be lowered
 /// The resulting pattern set should be run over a gpu.module op
 void populateGpuToROCDLConversionPatterns(LLVMTypeConverter &converter,
                                           RewritePatternSet &patterns,
                                           gpu::amd::Runtime runtime);
 
 /// Configure target to convert from the GPU dialect to ROCDL.
 void configureGpuToROCDLConversionLegality(ConversionTarget &target);
 
 /// Creates a pass that lowers GPU dialect operations to ROCDL counterparts. The
 /// index bitwidth used for the lowering of the device side index computations
 /// is configurable.
-std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
-createLowerGpuOpsToROCDLOpsPass(
+std::unique_ptr<OperationPass<gpu::GPUModuleOp>> createConvertGpuToROCDLPass(
     const std::string &chipset = "gfx900",
     unsigned indexBitwidth = kDeriveIndexBitwidthFromDataLayout,
     bool useBarePtrCallConv = false,
     gpu::amd::Runtime runtime = gpu::amd::Runtime::Unknown);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUTOROCDL_GPUTOROCDLPASS_H_

mlir/include/mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h

 #include <memory>
 
 namespace mlir {
 
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTGPUTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert GPU kernel ops to corresponding SPIR-V ops. For a
 /// gpu.func to be converted, it should have a spv.entry_point_abi attribute.
 /// If `mapMemorySpace` is true, performs MemRef memory space to SPIR-V mapping
 /// according to default Vulkan rules first.
 std::unique_ptr<OperationPass<ModuleOp>>
 createConvertGPUToSPIRVPass(bool mapMemorySpace = false);
 
 } // namespace mlir
 #endif // MLIR_CONVERSION_GPUTOSPIRV_GPUTOSPIRVPASS_H

mlir/include/mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h

 #include <memory>
 
 namespace mlir {
 
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTVULKANLAUNCHFUNCTOVULKANCALLSPASS
+#define GEN_PASS_DECL_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNCPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 std::unique_ptr<OperationPass<ModuleOp>>
 createConvertVulkanLaunchFuncToVulkanCallsPass();
 
 std::unique_ptr<OperationPass<mlir::ModuleOp>>
 createConvertGpuLaunchFuncToVulkanLaunchFuncPass();
 
 } // namespace mlir
 #endif // MLIR_CONVERSION_GPUTOVULKAN_CONVERTGPUTOVULKANPASS_H

mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h

 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTLINALGTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Populate the given list with patterns that convert from Linalg to LLVM.
 void populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             RewritePatternSet &patterns);
 
 /// Create a pass to convert Linalg operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertLinalgToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_

mlir/include/mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h

 //===- LinalgToSPIRVPass.h -  Linalg to SPIR-V Passes -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Provides passes to convert Linalg dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
 #define MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H
 
-#include "mlir/Pass/Pass.h"
+#include <memory>
 
 namespace mlir {
 class ModuleOp;
+template <typename T>
+class OperationPass;
+
+#define GEN_PASS_DECL_CONVERTLINALGTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
 
 /// Creates and returns a pass to convert Linalg ops to SPIR-V ops.
-std::unique_ptr<OperationPass<ModuleOp>> createLinalgToSPIRVPass();
+std::unique_ptr<OperationPass<ModuleOp>> createConvertLinalgToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_LINALGTOSPIRV_LINALGTOSPIRVPASS_H

mlir/include/mlir/Conversion/LinalgToStandard/LinalgToStandard.h

 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTLINALGTOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 namespace linalg {
 
 //===----------------------------------------------------------------------===//
 // Patterns to convert a LinalgOp to func.call @external library implementation.
 //===----------------------------------------------------------------------===//
 // These patterns are exposed individually because they are expected to be
 // typically used individually.
 

mlir/include/mlir/Conversion/MathToFuncs/MathToFuncs.h

 //===- MathToFuncs.h - Math to outlined impl conversion ---------*- 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_CONVERSION_MATHTOFUNCS_MATHTOFUNCS_H
 #define MLIR_CONVERSION_MATHTOFUNCS_MATHTOFUNCS_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
-// Pass to convert some Math operations into calls of functions
-// containing software implementation of these operations.
-std::unique_ptr<Pass> createConvertMathToFuncsPass();
+#define GEN_PASS_DECL_CONVERTMATHTOFUNCSPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MATHTOFUNCS_MATHTOFUNCS_H

mlir/include/mlir/Conversion/MathToLLVM/MathToLLVM.h

 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTMATHTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 void populateMathToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                           RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createConvertMathToLLVMPass();
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MATHTOLLVM_MATHTOLLVM_H

mlir/include/mlir/Conversion/MathToLibm/MathToLibm.h

 //===- MathToLibm.h - Utils to convert from the complex dialect --------===//
 //
 // 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_CONVERSION_MATHTOLIBM_MATHTOLIBM_H_
 #define MLIR_CONVERSION_MATHTOLIBM_MATHTOLIBM_H_
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTMATHTOLIBMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Populate the given list with patterns that convert from Math to Libm calls.
 /// If log1pBenefit is present, use it instead of benefit for the Log1p op.
 void populateMathToLibmConversionPatterns(
     RewritePatternSet &patterns, PatternBenefit benefit,
     llvm::Optional<PatternBenefit> log1pBenefit = llvm::None);
 
 /// Create a pass to convert Math operations to libm calls.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertMathToLibmPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MATHTOLIBM_MATHTOLIBM_H_

mlir/include/mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h

 #ifndef MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H
 #define MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTMATHTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert Math ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertMathToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H

mlir/include/mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h

 
 #include <memory>
 
 namespace mlir {
 class Pass;
 class LLVMTypeConverter;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTMEMREFTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of patterns to convert memory-related operations from the
 /// MemRef dialect to the LLVM dialect.
 void populateMemRefToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createMemRefToLLVMPass();
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MEMREFTOLLVM_MEMREFTOLLVM_H

mlir/include/mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h

 #define MLIR_CONVERSION_MEMREFTOSPIRV_MEMREFTOSPIRVPASS_H
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_MAPMEMREFSTORAGECLASSPASS
+#define GEN_PASS_DECL_CONVERTMEMREFTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to map numeric MemRef memory spaces to symbolic SPIR-V
 /// storage classes. The mapping is read from the command-line option.
 std::unique_ptr<OperationPass<>> createMapMemRefStorageClassPass();
 
 /// Creates a pass to convert MemRef ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertMemRefToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_MEMREFTOSPIRV_MEMREFTOSPIRVPASS_H

mlir/include/mlir/Conversion/NVGPUToNVVM/NVGPUToNVVM.h

 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTNVGPUTONVVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 void populateNVGPUToNVVMConversionPatterns(LLVMTypeConverter &converter,
                                            RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createConvertNVGPUToNVVMPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_NVGPUTONVVM_NVGPUTONVVMPASS_H_

mlir/include/mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h

 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTOPENACCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 static constexpr unsigned kPtrBasePosInDataDescriptor = 0;
 static constexpr unsigned kPtrPosInDataDescriptor = 1;
 static constexpr unsigned kSizePosInDataDescriptor = 2;
 
 /// Helper class to produce LLVM dialect operations inserting
 /// elements to a Data descriptor. Wraps a Value pointing to the descriptor.
 /// The Value may be null, in which case none of the operations are valid.
 ///

mlir/include/mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h

 #include <memory>
 
 namespace mlir {
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTOPENACCTOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect the patterns to convert from the OpenACC dialect to OpenACC with
 /// SCF dialect.
 void populateOpenACCToSCFConversionPatterns(RewritePatternSet &patterns);
 
 /// Create a pass to convert the OpenACC dialect into the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenACCToSCFPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_OPENACCTOSCF_CONVERTOPENACCTOSCF_H

mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h

 class LLVMTypeConverter;
 class ConversionTarget;
 class MLIRContext;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTOOPENMPTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Configure dynamic conversion legality of regionless operations from OpenMP
 /// to LLVM.
 void configureOpenMPToLLVMConversionLegality(ConversionTarget &target,
                                              LLVMTypeConverter &typeConverter);
 
 /// Populate the given list with patterns that convert from OpenMP to LLVM.
 void populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             RewritePatternSet &patterns);
 
 /// Create a pass to convert OpenMP operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenMPToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H

mlir/include/mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h

 
 #include <memory>
 
 namespace mlir {
 class ModuleOp;
 template <typename OpT>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTPDLTOPDLINTERPPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates and returns a pass to convert PDL ops to PDL interpreter ops.
 std::unique_ptr<OperationPass<ModuleOp>> createPDLToPDLInterpPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_PDLTOPDLINTERP_PDLTOPDLINTERP_H

mlir/include/mlir/Conversion/Passes.td

 #define MLIR_CONVERSION_PASSES
 
 include "mlir/Pass/PassBase.td"
 
 //===----------------------------------------------------------------------===//
 // AffineToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertAffineToStandard : Pass<"lower-affine"> {
+def ConvertAffineToStandardPass : Pass<"lower-affine"> {
   let summary = "Lower Affine operations to a combination of Standard and SCF "
                 "operations";
   let description = [{
 
     Convert operations from the affine dialect into operations from the SCF and
     standard dialects.
 
     `affine.for` operations are converted to `scf.for` operations that are free
let description = [{
     #### Invariants
 
     -   Functions without a body are not modified.
     -   The semantics of the other functions is preserved.
     -   Individual operations other than those mentioned above are not modified
         if they do not depend on the loop iterator value or on the result of
         `affine.apply`.
   }];
-  let constructor = "mlir::createLowerAffinePass()";
   let dependentDialects = [
     "memref::MemRefDialect",
     "scf::SCFDialect",
     "vector::VectorDialect"
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // AMDGPUToROCDL
 //===----------------------------------------------------------------------===//
 
-def ConvertAMDGPUToROCDL : Pass<"convert-amdgpu-to-rocdl"> {
+def ConvertAMDGPUToROCDLPass : Pass<"convert-amdgpu-to-rocdl"> {
   let summary = "Convert AMDGPU dialect to ROCDL dialect";
   let description = [{
     This pass converts supported AMDGPU ops to ROCDL dialect intrinsics.
   }];
-  let constructor = "mlir::createConvertAMDGPUToROCDLPass()";
   let dependentDialects = [
     "LLVM::LLVMDialect",
     "ROCDL::ROCDLDialect",
   ];
   let options = [Option<"chipset", "chipset", "std::string",
                         /*default=*/"\"gfx000\"",
                         "Chipset that these operations will run on">];
 }
 
 //===----------------------------------------------------------------------===//
 // ArithmeticToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertArithmeticToLLVM : Pass<"convert-arith-to-llvm"> {
+def ConvertArithmeticToLLVMPass : Pass<"convert-arith-to-llvm"> {
   let summary = "Convert Arithmetic dialect to LLVM dialect";
   let description = [{
     This pass converts supported Arithmetic ops to LLVM dialect instructions.
   }];
-  let constructor = "mlir::arith::createConvertArithmeticToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ArithmeticToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertArithmeticToSPIRV : Pass<"convert-arith-to-spirv"> {
+def ConvertArithmeticToSPIRVPass : Pass<"convert-arith-to-spirv"> {
   let summary = "Convert Arithmetic dialect to SPIR-V dialect";
-  let constructor = "mlir::arith::createConvertArithmeticToSPIRVPass()";
+  let constructor = "mlir::createConvertArithmeticToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ArmNeon2dToIntr
 //===----------------------------------------------------------------------===//
 
-def ConvertArmNeon2dToIntr : Pass<"arm-neon-2d-to-intr"> {
+def ConvertArmNeon2dToIntrPass : Pass<"arm-neon-2d-to-intr"> {
   let summary = "Convert Arm NEON structured ops to intrinsics";
-  let constructor = "mlir::createConvertArmNeon2dToIntrPass()";
+  let description = [{
+      Lower Arm NEON 2D ops to intrinsics, i.e. equivalent ops operating on
+      flattened 1D vectors and mapping more directly to the corresponding Arm
+      NEON instruction.
+  }];
   let dependentDialects = ["arm_neon::ArmNeonDialect", "vector::VectorDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // AsyncToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertAsyncToLLVM : Pass<"convert-async-to-llvm", "ModuleOp"> {
+def ConvertAsyncToLLVMPass : Pass<"convert-async-to-llvm", "ModuleOp"> {
   let summary = "Convert the operations from the async dialect into the LLVM "
                 "dialect";
   let description = [{
     Convert `async.execute` operations to LLVM coroutines and use async runtime
     API to execute them.
   }];
   let constructor = "mlir::createConvertAsyncToLLVMPass()";
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "LLVM::LLVMDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // BufferizationToMemRef
 //===----------------------------------------------------------------------===//
 
-def ConvertBufferizationToMemRef : Pass<"convert-bufferization-to-memref"> {
+def ConvertBufferizationToMemRefPass : Pass<"convert-bufferization-to-memref"> {
   let summary = "Convert operations from the Bufferization dialect to the "
                 "MemRef dialect";
   let description = [{
 
     This pass converts bufferization operations into memref operations.
 
     In the current state, this pass only transforms a `bufferization.clone`
     operation into `memref.alloc` and `memref.copy` operations. This conversion
let description = [{
     transform remaining operations and to proceed in other dialects (memref
     e.g.).
 
     Note that this pass only transforms the operation without any further
     analyses. This pass does not consider any memory analysis or optimization
     and hence does not resolve any memory leaks.
 
   }];
-  let constructor = "mlir::createBufferizationToMemRefPass()";
   let dependentDialects = ["arith::ArithmeticDialect", "memref::MemRefDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertComplexToLLVM : Pass<"convert-complex-to-llvm"> {
+def ConvertComplexToLLVMPass : Pass<"convert-complex-to-llvm"> {
   let summary = "Convert Complex dialect to LLVM dialect";
-  let constructor = "mlir::createConvertComplexToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToLibm
 //===----------------------------------------------------------------------===//
 
-def ConvertComplexToLibm : Pass<"convert-complex-to-libm", "ModuleOp"> {
+def ConvertComplexToLibmPass : Pass<"convert-complex-to-libm", "ModuleOp"> {
   let summary = "Convert Complex dialect to libm calls";
   let description = [{
     This pass converts supported Complex ops to libm calls.
   }];
   let constructor = "mlir::createConvertComplexToLibmPass()";
   let dependentDialects = [
     "func::FuncDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ComplexToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertComplexToStandard : Pass<"convert-complex-to-standard"> {
+def ConvertComplexToStandardPass : Pass<"convert-complex-to-standard"> {
   let summary = "Convert Complex dialect to standard dialect";
-  let constructor = "mlir::createConvertComplexToStandardPass()";
   let dependentDialects = ["math::MathDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ControlFlowToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertControlFlowToLLVM : Pass<"convert-cf-to-llvm", "ModuleOp"> {
+def ConvertControlFlowToLLVMPass : Pass<"convert-cf-to-llvm", "ModuleOp"> {
   let summary = "Convert ControlFlow operations to the LLVM dialect";
   let description = [{
     Convert ControlFlow operations into LLVM IR dialect operations.
 
     If other operations are present and their results are required by the LLVM
     IR dialect operations, the pass will fail.  Any LLVM IR operations or types
     already present in the IR will be kept as is.
   }];
-  let constructor = "mlir::cf::createConvertControlFlowToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // ControlFlowToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertControlFlowToSPIRV : Pass<"convert-cf-to-spirv"> {
+def ConvertControlFlowToSPIRVPass : Pass<"convert-cf-to-spirv"> {
   let summary = "Convert ControlFlow dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertControlFlowToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // FuncToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertFuncToLLVM : Pass<"convert-func-to-llvm", "ModuleOp"> {
+def ConvertFuncToLLVMPass : Pass<"convert-func-to-llvm", "ModuleOp"> {
   let summary = "Convert from the Func dialect to the LLVM dialect";
   let description = [{
     Convert Func dialect operations into the LLVM IR dialect operations.
 
     #### Input invariant
 
     -   no `tensor` types;
     -   all `vector` are one-dimensional;
Option<"dataLayout", "data-layout", "std::string",
            "expected on the produced module">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // FuncToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertFuncToSPIRV : Pass<"convert-func-to-spirv"> {
+def ConvertFuncToSPIRVPass : Pass<"convert-func-to-spirv"> {
   let summary = "Convert Func dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertFuncToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUCommon
 //===----------------------------------------------------------------------===//
 
-def GpuToLLVMConversionPass : Pass<"gpu-to-llvm", "ModuleOp"> {
+def ConvertGpuToLLVMPass : Pass<"gpu-to-llvm", "ModuleOp"> {
   let summary = "Convert GPU dialect to LLVM dialect with GPU runtime calls";
-  let constructor = "mlir::createGpuToLLVMConversionPass()";
+  let constructor = "mlir::createConvertGpuToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
-def LowerHostCodeToLLVM : Pass<"lower-host-to-llvm", "ModuleOp"> {
+def LowerHostCodeToLLVMPass : Pass<"lower-host-to-llvm", "ModuleOp"> {
   let summary = "Lowers the host module code and `gpu.launch_func` to LLVM";
   let constructor = "mlir::createLowerHostCodeToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUToNVVM
 //===----------------------------------------------------------------------===//
 
-def ConvertGpuOpsToNVVMOps : Pass<"convert-gpu-to-nvvm", "gpu::GPUModuleOp"> {
+def ConvertGpuToNVVMPass : Pass<"convert-gpu-to-nvvm", "gpu::GPUModuleOp"> {
   let summary = "Generate NVVM operations for gpu operations";
-  let constructor = "mlir::createLowerGpuOpsToNVVMOpsPass()";
+  let constructor = "mlir::createConvertGpuToNVVMPass()";
   let dependentDialects = [
     "cf::ControlFlowDialect",
     "memref::MemRefDialect",
     "NVVM::NVVMDialect",
   ];
   let options = [
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUToROCDL
 //===----------------------------------------------------------------------===//
 
-def ConvertGpuOpsToROCDLOps : Pass<"convert-gpu-to-rocdl", "gpu::GPUModuleOp"> {
+def ConvertGpuToROCDLPass : Pass<"convert-gpu-to-rocdl", "gpu::GPUModuleOp"> {
   let summary = "Generate ROCDL operations for gpu operations";
-  let constructor = "mlir::createLowerGpuOpsToROCDLOpsPass()";
+  let constructor = "mlir::createConvertGpuToROCDLPass()";
   let dependentDialects = ["ROCDL::ROCDLDialect"];
   let options = [
     Option<"chipset", "chipset", "std::string",
            /*default=*/"\"gfx000\"",
            "Chipset that these operations will run on">,
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
Option<"runtime", "runtime", "::mlir::gpu::amd::Runtime",
           )}]>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertGPUToSPIRV : Pass<"convert-gpu-to-spirv", "ModuleOp"> {
+def ConvertGPUToSPIRVPass : Pass<"convert-gpu-to-spirv", "ModuleOp"> {
   let summary = "Convert GPU dialect to SPIR-V dialect";
   let description = [{
     This pass converts supported GPU device ops to SPIR-V ops. It does not
     handle GPU host ops.
 
     A `gpu.func` op can have parameters to pass in resources. But in SPIR-V
     entry functions cannot take parameters; they use descriptors to access
     resources. By default, parameters to a `gpu.func` op will be converted to
     global variables. These global variables will be assigned sequential binding
     numbers following their order in the original `gpu.func` op, starting from
     0, in set 0. One can attach `spv.interface_var_abi` to those parameters
     to control the set and binding if wanted.
   }];
   let constructor = "mlir::createConvertGPUToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUToVulkan
 //===----------------------------------------------------------------------===//
 
-def ConvertGpuLaunchFuncToVulkanLaunchFunc
+def ConvertGpuLaunchFuncToVulkanLaunchFuncPass
     : Pass<"convert-gpu-launch-to-vulkan-launch", "ModuleOp"> {
   let summary = "Convert gpu.launch_func to vulkanLaunch external call";
   let description = [{
     This pass is only intended for the mlir-vulkan-runner.
   }];
   let constructor = "mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
-def ConvertVulkanLaunchFuncToVulkanCalls
+def ConvertVulkanLaunchFuncToVulkanCallsPass
     : Pass<"launch-func-to-vulkan", "ModuleOp"> {
   let summary = "Convert vulkanLaunch external call to Vulkan runtime external "
                 "calls";
   let description = [{
     This pass is only intended for the mlir-vulkan-runner.
   }];
   let constructor = "mlir::createConvertVulkanLaunchFuncToVulkanCallsPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // LinalgToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertLinalgToLLVM : Pass<"convert-linalg-to-llvm", "ModuleOp"> {
+def ConvertLinalgToLLVMPass : Pass<"convert-linalg-to-llvm", "ModuleOp"> {
   let summary = "Convert the operations from the linalg dialect into the LLVM "
                 "dialect";
   let constructor = "mlir::createConvertLinalgToLLVMPass()";
   let dependentDialects = ["scf::SCFDialect", "LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // LinalgToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertLinalgToStandard : Pass<"convert-linalg-to-std", "ModuleOp"> {
+def ConvertLinalgToStandardPass : Pass<"convert-linalg-to-std", "ModuleOp"> {
   let summary = "Convert the operations from the linalg dialect into the "
                 "Standard dialect";
   let constructor = "mlir::createConvertLinalgToStandardPass()";
   let dependentDialects = ["func::FuncDialect", "memref::MemRefDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // LinalgToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertLinalgToSPIRV : Pass<"convert-linalg-to-spirv", "ModuleOp"> {
+def ConvertLinalgToSPIRVPass : Pass<"convert-linalg-to-spirv", "ModuleOp"> {
   let summary = "Convert Linalg dialect to SPIR-V dialect";
   let description = [{
     This pass converts supported Linalg ops to SPIR-V ops. It's quite
     experimental and are expected to migrate to other proper conversions.
   }];
-  let constructor = "mlir::createLinalgToSPIRVPass()";
+  let constructor = "mlir::createConvertLinalgToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToLibm
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToLibm : Pass<"convert-math-to-libm", "ModuleOp"> {
+def ConvertMathToLibmPass : Pass<"convert-math-to-libm", "ModuleOp"> {
   let summary = "Convert Math dialect to libm calls";
   let description = [{
     This pass converts supported Math ops to libm calls.
   }];
   let constructor = "mlir::createConvertMathToLibmPass()";
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "func::FuncDialect",
     "vector::VectorDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToLLVM : Pass<"convert-math-to-llvm"> {
+def ConvertMathToLLVMPass : Pass<"convert-math-to-llvm"> {
   let summary = "Convert Math dialect to LLVM dialect";
   let description = [{
     This pass converts supported Math ops to LLVM dialect intrinsics.
   }];
-  let constructor = "mlir::createConvertMathToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToSPIRV : Pass<"convert-math-to-spirv"> {
+def ConvertMathToSPIRVPass : Pass<"convert-math-to-spirv"> {
   let summary = "Convert Math dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertMathToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // MathToFuncs
 //===----------------------------------------------------------------------===//
 
-def ConvertMathToFuncs : Pass<"convert-math-to-funcs", "ModuleOp"> {
+def ConvertMathToFuncsPass : Pass<"convert-math-to-funcs", "ModuleOp"> {
   let summary = "Convert Math operations to calls of outlined implementations.";
   let description = [{
     This pass converts supported Math ops to calls of compiler generated
     functions implementing these operations in software.
     The LLVM dialect is used for LinkonceODR linkage of the generated functions.
   }];
-  let constructor = "mlir::createConvertMathToFuncsPass()";
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "cf::ControlFlowDialect",
     "func::FuncDialect",
     "vector::VectorDialect",
     "LLVM::LLVMDialect",
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertMemRefToLLVM : Pass<"convert-memref-to-llvm", "ModuleOp"> {
+def ConvertMemRefToLLVMPass : Pass<"convert-memref-to-llvm", "ModuleOp"> {
   let summary = "Convert operations from the MemRef dialect to the LLVM "
                 "dialect";
-  let constructor = "mlir::createMemRefToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"useAlignedAlloc", "use-aligned-alloc", "bool", /*default=*/"false",
            "Use aligned_alloc in place of malloc for heap allocations">,
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
     Option<"useGenericFunctions", "use-generic-functions",
            "bool",
            /*default=*/"false",
            "Use generic allocation and deallocation functions instead of the "
            "classic 'malloc', 'aligned_alloc' and 'free' functions">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefToSPIRV
 //===----------------------------------------------------------------------===//
 
-def MapMemRefStorageClass : Pass<"map-memref-spirv-storage-class"> {
+def MapMemRefStorageClassPass : Pass<"map-memref-spirv-storage-class"> {
   let summary = "Map numeric MemRef memory spaces to SPIR-V storage classes";
   let constructor = "mlir::createMapMemRefStorageClassPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"clientAPI", "client-api", "std::string", /*default=*/"\"vulkan\"",
            "The client API to use for populating mappings">
   ];
 }
 
-def ConvertMemRefToSPIRV : Pass<"convert-memref-to-spirv"> {
+def ConvertMemRefToSPIRVPass : Pass<"convert-memref-to-spirv"> {
   let summary = "Convert MemRef dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertMemRefToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"boolNumBits", "bool-num-bits",
            "int", /*default=*/"8",
            "The number of bits to store a boolean value">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // NVGPUToNVVM
 //===----------------------------------------------------------------------===//
 
-def ConvertNVGPUToNVVM : Pass<"convert-nvgpu-to-nvvm"> {
+def ConvertNVGPUToNVVMPass : Pass<"convert-nvgpu-to-nvvm"> {
   let summary = "Convert NVGPU dialect to NVVM dialect";
   let description = [{
     This pass converts supported NVGPU ops to NVVM dialect intrinsics.
   }];
-  let constructor = "mlir::createConvertNVGPUToNVVMPass()";
   let dependentDialects = [
     "NVVM::NVVMDialect",
   ];
 }
 
 
 //===----------------------------------------------------------------------===//
 // OpenACCToSCF
 //===----------------------------------------------------------------------===//
 
-def ConvertOpenACCToSCF : Pass<"convert-openacc-to-scf", "ModuleOp"> {
+def ConvertOpenACCToSCFPass : Pass<"convert-openacc-to-scf", "ModuleOp"> {
   let summary = "Convert the OpenACC ops to OpenACC with SCF dialect";
   let constructor = "mlir::createConvertOpenACCToSCFPass()";
   let dependentDialects = ["scf::SCFDialect", "acc::OpenACCDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // OpenACCToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertOpenACCToLLVM : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
+def ConvertOpenACCToLLVMPass : Pass<"convert-openacc-to-llvm", "ModuleOp"> {
   let summary = "Convert the OpenACC ops to LLVM dialect";
   let constructor = "mlir::createConvertOpenACCToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // OpenMPToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertOpenMPToLLVM : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
+def ConvertOpenMPToLLVMPass : Pass<"convert-openmp-to-llvm", "ModuleOp"> {
   let summary = "Convert the OpenMP ops to OpenMP ops with LLVM dialect";
   let constructor = "mlir::createConvertOpenMPToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // PDLToPDLInterp
 //===----------------------------------------------------------------------===//
 
-def ConvertPDLToPDLInterp : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> {
+def ConvertPDLToPDLInterpPass : Pass<"convert-pdl-to-pdl-interp", "ModuleOp"> {
   let summary = "Convert PDL ops to PDL interpreter ops";
   let constructor = "mlir::createPDLToPDLInterpPass()";
   let dependentDialects = ["pdl_interp::PDLInterpDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ReconcileUnrealizedCasts
 //===----------------------------------------------------------------------===//
 
-def ReconcileUnrealizedCasts : Pass<"reconcile-unrealized-casts"> {
+def ReconcileUnrealizedCastsPass : Pass<"reconcile-unrealized-casts"> {
   let summary = "Simplify and eliminate unrealized conversion casts";
   let description = [{
     Eliminate `unrealized_conversion_cast` operations, commonly introduced by
     partial dialect conversions, that transitively convert a value to another
     value of the same type, that is:
 
     ```
     %0 = "producer.op"() : () -> !type.A
     %1 = unrealized_conversion_cast %0 : !type.A to !type.B
     %2 = unrealized_conversion_cast %1 : !type.B to !type.C
     %3 = unrealized_conversion_cast %2 : !type.C to !type.A
     "consumer.op"(%3) : (!type.A) -> ()
     ```
 
     Such situations appear when the consumer operation is converted by one pass
     and the producer operation is converted by another pass, each of which
     produces an unrealized cast. This pass can be used to clean up the IR.
   }];
-  let constructor = "mlir::createReconcileUnrealizedCastsPass()";
 }
 
 //===----------------------------------------------------------------------===//
 // SCFToControlFlow
 //===----------------------------------------------------------------------===//
 
-def SCFToControlFlow : Pass<"convert-scf-to-cf"> {
+def ConvertSCFToControlFlowPass : Pass<"convert-scf-to-cf"> {
   let summary = "Convert SCF dialect to ControlFlow dialect, replacing structured"
                 " control flow with a CFG";
-  let constructor = "mlir::createConvertSCFToCFPass()";
   let dependentDialects = ["cf::ControlFlowDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // SCFToOpenMP
 //===----------------------------------------------------------------------===//
 
-def ConvertSCFToOpenMP : Pass<"convert-scf-to-openmp", "ModuleOp"> {
+def ConvertSCFToOpenMPPass : Pass<"convert-scf-to-openmp", "ModuleOp"> {
   let summary = "Convert SCF parallel loop to OpenMP parallel + workshare "
                 "constructs.";
   let constructor = "mlir::createConvertSCFToOpenMPPass()";
   let dependentDialects = ["omp::OpenMPDialect", "LLVM::LLVMDialect",
                            "memref::MemRefDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // SCFToSPIRV
 //===----------------------------------------------------------------------===//
 
-def SCFToSPIRV : Pass<"convert-scf-to-spirv"> {
+def ConvertSCFToSPIRVPass : Pass<"convert-scf-to-spirv"> {
   let summary = "Convert SCF dialect to SPIR-V dialect.";
   let description = [{
     This pass converts SCF ops into SPIR-V structured control flow ops.
     SPIR-V structured control flow ops does not support yielding values.
     So for SCF ops yielding values, SPIR-V variables are created for
     holding the values and load/store operations are emitted for updating
     them.
   }];
   let constructor = "mlir::createConvertSCFToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // SCFToGPU
 //===----------------------------------------------------------------------===//
 
-def ConvertAffineForToGPU
+def ConvertAffineForToGPUPass
     : InterfacePass<"convert-affine-for-to-gpu", "FunctionOpInterface"> {
   let summary = "Convert top-level AffineFor Ops to GPU kernels";
   let constructor = "mlir::createAffineForToGPUPass()";
   let dependentDialects = ["gpu::GPUDialect"];
   let options = [
     Option<"numBlockDims", "gpu-block-dims", "unsigned", /*default=*/"1u",
            "Number of GPU block dimensions for mapping">,
     Option<"numThreadDims", "gpu-thread-dims", "unsigned", /*default=*/"1u",
            "Number of GPU thread dimensions for mapping">
   ];
 }
 
-def ConvertParallelLoopToGpu : Pass<"convert-parallel-loops-to-gpu"> {
+def ConvertParallelLoopToGpuPass : Pass<"convert-parallel-loops-to-gpu"> {
   let summary = "Convert mapped scf.parallel ops to gpu launch operations";
-  let constructor = "mlir::createParallelLoopToGpuPass()";
+  let description = [{
+      Convert `scf.parallel` operations into a `gpu.launch` operation. The
+      mapping of loop dimensions to launch dimensions is derived from mapping
+      attributes. See `ParallelToGpuLaunchLowering::matchAndRewrite` for a
+      description of the used attributes.
+  }];
   let dependentDialects = ["AffineDialect", "gpu::GPUDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeToStandard
 //===----------------------------------------------------------------------===//
 
-def ConvertShapeToStandard : Pass<"convert-shape-to-std", "ModuleOp"> {
+def ConvertShapeToStandardPass : Pass<"convert-shape-to-std", "ModuleOp"> {
   let summary = "Convert operations from the shape dialect into the standard "
                 "dialect";
   let constructor = "mlir::createConvertShapeToStandardPass()";
   let dependentDialects = [
     "scf::SCFDialect",
   ];
 }
 
-def ConvertShapeConstraints : Pass<"convert-shape-constraints"> {
+def ConvertShapeConstraintsPass : Pass<"convert-shape-constraints"> {
   let summary = "Convert shape constraint operations to the standard dialect";
   let description = [{
     This pass eliminates shape constraints from the program, converting them to
     eager (side-effecting) error handling code.
 
     This pass is separate from the regular convert-shape-to-standard, despite
     converting between the same dialects, because converting shape constraints
     can happen at a different part of the program than general shape
     computation lowering.
   }];
-  let constructor = "mlir::createConvertShapeConstraintsPass()";
   let dependentDialects = ["cf::ControlFlowDialect", "scf::SCFDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // SPIRVToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertSPIRVToLLVM : Pass<"convert-spirv-to-llvm", "ModuleOp"> {
+def ConvertSPIRVToLLVMPass : Pass<"convert-spirv-to-llvm", "ModuleOp"> {
   let summary = "Convert SPIR-V dialect to LLVM dialect";
   let description = [{
     See https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/
     for more details.
   }];
   let constructor = "mlir::createConvertSPIRVToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // TensorToLinalg
 //===----------------------------------------------------------------------===//
 
-def ConvertTensorToLinalg : Pass<"convert-tensor-to-linalg", "ModuleOp"> {
+def ConvertTensorToLinalgPass : Pass<"convert-tensor-to-linalg", "ModuleOp"> {
   let summary = "Convert some Tensor dialect ops to Linalg dialect";
   let constructor = "mlir::createConvertTensorToLinalgPass()";
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "linalg::LinalgDialect",
   ];
 }
 
-
 //===----------------------------------------------------------------------===//
 // TensorToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertTensorToSPIRV : Pass<"convert-tensor-to-spirv"> {
+def ConvertTensorToSPIRVPass : Pass<"convert-tensor-to-spirv"> {
   let summary = "Convert Tensor dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertTensorToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
   let options = [
     Option<"emulateNon32BitScalarTypes", "emulate-non-32-bit-scalar-types",
            "bool", /*default=*/"true",
            "Emulate non-32-bit scalar types with 32-bit ones if "
            "missing native support">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToArith
 //===----------------------------------------------------------------------===//
 
-def TosaToArith : Pass<"tosa-to-arith"> {
+def ConvertTosaToArithPass : Pass<"tosa-to-arith"> {
   let summary = "Lower TOSA to the Arith dialect";
   let dependentDialects = [
     "arith::ArithmeticDialect",
   ];
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     operations in the Arith dialect. The ApplyScale operator is optionally
     included as it is often preserved until the final invocation.
   }];
 
   let options = [
     Option<"includeApplyRescale", "include-apply-rescale",
            "bool", /*default=*/"false",
            "Whether to include the lowering for tosa.apply_rescale to arith">,
     Option<"use32Bit", "use-32-bit",
            "bool", /*default=*/"false",
            "Whether to prioritze lowering to 32-bit operations">
   ];
-
-  let constructor = "tosa::createTosaToArith()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToLinalg
 //===----------------------------------------------------------------------===//
 
-def TosaToLinalg
+def ConvertTosaToLinalgPass
     : InterfacePass<"tosa-to-linalg", "FunctionOpInterface"> {
   let summary = "Lower TOSA to LinAlg on tensors";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     tensor operations in LinAlg.
   }];
-
-  let constructor = "tosa::createTosaToLinalg()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToLinalgNamed
 //===----------------------------------------------------------------------===//
 
-def TosaToLinalgNamed
+def ConvertTosaToLinalgNamedPass
     : InterfacePass<"tosa-to-linalg-named", "FunctionOpInterface"> {
   let summary = "Lower TOSA to LinAlg named operations";
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     Linalg named operations.
   }];
-
-  let constructor = "tosa::createTosaToLinalgNamed()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToSCF
 //===----------------------------------------------------------------------===//
 
-def TosaToSCF : Pass<"tosa-to-scf"> {
+def ConvertTosaToSCFPass : Pass<"tosa-to-scf"> {
   let summary = "Lower TOSA to the SCF dialect";
   let dependentDialects = ["tensor::TensorDialect, scf::SCFDialect"];
   let description = [{
     Pass that converts TOSA's control flow operations to the equivalent SCF
     operations.
   }];
-
-  let constructor = "tosa::createTosaToSCF()";
 }
 
 //===----------------------------------------------------------------------===//
 // TosaToTensor
 //===----------------------------------------------------------------------===//
 
-def TosaToTensor : Pass<"tosa-to-tensor"> {
+def ConvertTosaToTensorPass : Pass<"tosa-to-tensor"> {
   let summary = "Lower TOSA to the Tensor dialect";
   let dependentDialects = [
     "tensor::TensorDialect",
   ];
   let description = [{
     Pass that converts TOSA operations to the equivalent operations using the
     operations in the Tensor dialect.
   }];
-
-  let constructor = "tosa::createTosaToTensor()";
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToGPU
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToGPU : Pass<"convert-vector-to-gpu"> {
+def ConvertVectorToGPUPass : Pass<"convert-vector-to-gpu"> {
   let summary = "Lower the operations from the vector dialect into the GPU "
                 "dialect";
   let constructor = "mlir::createConvertVectorToGPUPass()";
   let dependentDialects = [
     "memref::MemRefDialect", "gpu::GPUDialect", "AffineDialect",
     "vector::VectorDialect", "nvgpu::NVGPUDialect"
   ];
 
   let options = [
     Option<"useNvGpu", "use-nvgpu", "bool", /*default=*/"false",
       "convert to NvGPU ops instead of GPU dialect ops">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToSCF
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToSCF : Pass<"convert-vector-to-scf"> {
+def ConvertVectorToSCFPass : Pass<"convert-vector-to-scf"> {
   let summary = "Lower the operations from the vector dialect into the SCF "
                 "dialect";
   let constructor = "mlir::createConvertVectorToSCFPass()";
   let dependentDialects = [
     "AffineDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
Option<"lowerTensors", "lower-tensors", "bool", /*default=*/"false",
            "Lower transfer ops that operate on tensors">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToLLVM : Pass<"convert-vector-to-llvm", "ModuleOp"> {
+def ConvertVectorToLLVMPass : Pass<"convert-vector-to-llvm", "ModuleOp"> {
   let summary = "Lower the operations from the vector dialect into the LLVM "
                 "dialect";
   let description = [{
 
     Convert operations from the vector dialect into the LLVM IR dialect
     operations. The lowering pass provides several options to control
     the kinds of optimizations that are allowed. It also provides options
     that enable the use of one or more architectural-specific dialects
let options = [
      "dialect.">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToSPIRV
 //===----------------------------------------------------------------------===//
 
-def ConvertVectorToSPIRV : Pass<"convert-vector-to-spirv"> {
+def ConvertVectorToSPIRVPass : Pass<"convert-vector-to-spirv"> {
   let summary = "Convert Vector dialect to SPIR-V dialect";
   let constructor = "mlir::createConvertVectorToSPIRVPass()";
   let dependentDialects = ["spirv::SPIRVDialect"];
 }
 
 #endif // MLIR_CONVERSION_PASSES

mlir/include/mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h

 #define MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 class RewritePatternSet;
 
-/// Creates a pass that eliminates noop `unrealized_conversion_cast` operation
-/// sequences.
-std::unique_ptr<Pass> createReconcileUnrealizedCastsPass();
+#define GEN_PASS_DECL_RECONCILEUNREALIZEDCASTSPASS
+#include "mlir/Conversion/Passes.h.inc"
 
 /// Populates `patterns` with rewrite patterns that eliminate noop
 /// `unrealized_conversion_cast` operation sequences.
 void populateReconcileUnrealizedCastsPatterns(RewritePatternSet &patterns);
+
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_RECONCILEUNREALIZEDCASTS_RECONCILEUNREALIZEDCASTS_H_

mlir/include/mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h

 #define MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTSCFTOCONTROLFLOWPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Collect a set of patterns to convert SCF operations to CFG branch-based
 /// operations within the ControlFlow dialect.
 void populateSCFToControlFlowConversionPatterns(RewritePatternSet &patterns);
 
-/// Creates a pass to convert SCF operations to CFG branch-based operation in
-/// the ControlFlow dialect.
-std::unique_ptr<Pass> createConvertSCFToCFPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOCONTROLFLOW_SCFTOCONTROLFLOW_H_

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPUPass.h

 
 #include <memory>
 
 namespace mlir {
 template <typename T>
 class InterfacePass;
 class Pass;
 
+#define GEN_PASS_DECL_CONVERTAFFINEFORTOGPUPASS
+#define GEN_PASS_DECL_CONVERTPARALLELLOOPTOGPUPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Create a pass that converts loop nests into GPU kernels.  It considers
 /// top-level affine.for operations as roots of loop nests and converts them to
 /// the gpu.launch operations if possible.
 ///
 /// No check on the size of the block or grid, or on the validity of
 /// parallelization is performed, it is under the responsibility of the caller
 /// to strip-mine the loops and to perform the dependence analysis before
 /// calling the conversion.
 std::unique_ptr<InterfacePass<FunctionOpInterface>>
 createAffineForToGPUPass(unsigned numBlockDims, unsigned numThreadDims);
 std::unique_ptr<InterfacePass<FunctionOpInterface>> createAffineForToGPUPass();
 
-/// Creates a pass that converts scf.parallel operations into a gpu.launch
-/// operation. The mapping of loop dimensions to launch dimensions is derived
-/// from mapping attributes. See ParallelToGpuLaunchLowering::matchAndRewrite
-/// for a description of the used attributes.
-std::unique_ptr<Pass> createParallelLoopToGpuPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOGPU_SCFTOGPUPASS_H_

mlir/include/mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h

 
 #include <memory>
 
 namespace mlir {
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTSCFTOOPENMPPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 std::unique_ptr<OperationPass<ModuleOp>> createConvertSCFToOpenMPPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOOPENMP_SCFTOOPENMP_H

mlir/include/mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h

 #ifndef MLIR_CONVERSION_SCFTOSPIRV_SCFTOSPIRVPASS_H
 #define MLIR_CONVERSION_SCFTOSPIRV_SCFTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTSCFTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert SCF ops into SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertSCFToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SCFTOSPIRV_SCFTOSPIRVPASS_H

mlir/include/mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h

 
 #include <memory>
 
 namespace mlir {
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_LOWERHOSTCODETOLLVMPASS
+#define GEN_PASS_DECL_CONVERTSPIRVTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to emulate `gpu.launch_func` call in LLVM dialect and lower
 /// the host module code to LLVM.
 ///
 /// This transformation creates a sequence of global variables that are later
 /// linked to the variables in the kernel module, and a series of copies to/from
 /// them to emulate the memory transfer from the host or to the device sides. It
 /// also converts the remaining Arithmetic, Func, and MemRef dialects into LLVM
 /// dialect, emitting C wrappers.
 std::unique_ptr<OperationPass<ModuleOp>> createLowerHostCodeToLLVMPass();
 
 /// Creates a pass to convert SPIR-V operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertSPIRVToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H

mlir/include/mlir/Conversion/ShapeToStandard/ShapeToStandard.h

 namespace mlir {
 
 class ModuleOp;
 class Pass;
 template <typename T>
 class OperationPass;
 class RewritePatternSet;
 
-void populateShapeToStandardConversionPatterns(RewritePatternSet &patterns);
+#define GEN_PASS_DECL_CONVERTSHAPECONSTRAINTSPASS
+#define GEN_PASS_DECL_CONVERTSHAPETOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
 
-std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
+void populateShapeToStandardConversionPatterns(RewritePatternSet &patterns);
 
 void populateConvertShapeConstraintsConversionPatterns(
     RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createConvertShapeConstraintsPass();
+std::unique_ptr<OperationPass<ModuleOp>> createConvertShapeToStandardPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SHAPETOSTANDARD_SHAPETOSTANDARD_H_

mlir/include/mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h

 #ifndef MLIR_CONVERSION_TENSORTOLINALG_TENSORTOLINALGPASS_H
 #define MLIR_CONVERSION_TENSORTOLINALG_TENSORTOLINALGPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTTENSORTOLINALGPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert Tensor ops to Linalg ops.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertTensorToLinalgPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TENSORTOLINALG_TENSORTOLINALGPASS_H

mlir/include/mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h

 #ifndef MLIR_CONVERSION_TENSORTOSPIRV_TENSORTOSPIRVPASS_H
 #define MLIR_CONVERSION_TENSORTOSPIRV_TENSORTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTTENSORTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert Tensor ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertTensorToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TENSORTOSPIRV_TENSORTOSPIRVPASS_H

mlir/include/mlir/Conversion/TosaToArith/TosaToArith.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H
 #define MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-namespace tosa {
 
-std::unique_ptr<Pass> createTosaToArith();
+#define GEN_PASS_DECL_CONVERTTOSATOARITHPASS
+#include "mlir/Conversion/Passes.h.inc"
+
+namespace tosa {
 
 void populateTosaToArithConversionPatterns(RewritePatternSet *patterns);
 
 void populateTosaRescaleToArithConversionPatterns(RewritePatternSet *patterns,
                                                   bool include32Bit = false);
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TOSATOARITH_TOSATOARITH_H

mlir/include/mlir/Conversion/TosaToLinalg/TosaToLinalg.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 #define MLIR_CONVERSION_TOSATOLINALG_TOSATOLINALG_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-namespace tosa {
 
-std::unique_ptr<Pass> createTosaToLinalg();
-std::unique_ptr<Pass> createTosaToLinalgNamed();
+#define GEN_PASS_DECL_CONVERTTOSATOLINALGPASS
+#define GEN_PASS_DECL_CONVERTTOSATOLINALGNAMEDPASS
+#include "mlir/Conversion/Passes.h.inc"
+
+namespace tosa {
 
 /// Populates passes to convert from TOSA to Linalg on buffers. At the end of
 /// the pass, the function will only contain linalg ops or standard ops if the
 /// pipeline succeeds.  The option to disable decompositions is available for
 /// benchmarking performance improvements from the canonicalizations.
 void addTosaToLinalgPasses(OpPassManager &pm,
                            bool disableTosaDecompositions = false);
 

mlir/include/mlir/Conversion/TosaToSCF/TosaToSCF.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_TOSATOSCF_TOSATOSCF_H
 #define MLIR_CONVERSION_TOSATOSCF_TOSATOSCF_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-namespace tosa {
 
-std::unique_ptr<Pass> createTosaToSCF();
+#define GEN_PASS_DECL_CONVERTTOSATOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+
+namespace tosa {
 
 void populateTosaToSCFConversionPatterns(RewritePatternSet *patterns);
 
 /// Populates passes to convert from TOSA to SCF.
 void addTosaToSCFPasses(OpPassManager &pm);
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TOSATOSCF_TOSATOSCF_H

mlir/include/mlir/Conversion/TosaToTensor/TosaToTensor.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H
 #define MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-namespace tosa {
 
-std::unique_ptr<Pass> createTosaToTensor();
+#define GEN_PASS_DECL_CONVERTTOSATOTENSORPASS
+#include "mlir/Conversion/Passes.h.inc"
+
+namespace tosa {
 
 void populateTosaToTensorConversionPatterns(RewritePatternSet *patterns);
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_TOSATOTENSOR_TOSATOTENSOR_H

mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h

 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
 class Pass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTVECTORTOGPUPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Patterns to transform vector ops into a canonical form to convert to MMA
 /// matrix operations. If `useNvGpu` is true, then the patterns will populated
 /// will prepare for conversion to `nvgpu` mma operations rather than the `gpu`
 /// dialect WMMA operations.
 void populatePrepareVectorToMMAPatterns(RewritePatternSet &patterns,
                                         bool useNvGpu = false);
 
 /// Convert vector ops to MMA matrix operations nested under `rootOp`. This will

mlir/include/mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h

 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
 template <typename T>
 class OperationPass;
 
+#define GEN_PASS_DECL_CONVERTVECTORTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Options to control Vector to LLVM lowering.
 ///
 /// This should kept in sync with VectorToLLVM options defined for the
 /// ConvertVectorToLLVM pass in include/mlir/Conversion/Passes.td
 struct LowerVectorToLLVMOptions {
   LowerVectorToLLVMOptions() {}
 
   LowerVectorToLLVMOptions &enableReassociateFPReductions(bool b = true) {

mlir/include/mlir/Conversion/VectorToSCF/VectorToSCF.h

 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 class MLIRContext;
 class Pass;
 class RewritePatternSet;
 
+#define GEN_PASS_DECL_CONVERTVECTORTOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// When lowering an N-d vector transfer op to an (N-1)-d vector transfer op,
 /// a temporary buffer is created through which individual (N-1)-d vector are
 /// staged. This pattern can be applied multiple time, until the transfer op
 /// is 1-d.
 /// This is consistent with the lack of an LLVM instruction to dynamically
 /// index into an aggregate (see the Vector dialect lowering to LLVM deep dive).
 ///
 /// An instruction such as:

mlir/include/mlir/Conversion/VectorToSPIRV/VectorToSPIRVPass.h

 #ifndef MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H
 #define MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_CONVERTVECTORTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+
 /// Creates a pass to convert Vector Ops to SPIR-V ops.
 std::unique_ptr<OperationPass<>> createConvertVectorToSPIRVPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_VECTORTOSPIRV_VECTORTOSPIRVPASS_H

mlir/include/mlir/Dialect/Affine/Passes.h

 } // namespace func
 
 class AffineForOp;
 
 /// Fusion mode to attempt. The default mode `Greedy` does both
 /// producer-consumer and sibling fusion.
 enum FusionMode { Greedy, ProducerConsumer, Sibling };
 
+#define GEN_PASS_DECL_AFFINEDATACOPYGENERATIONPASS
+#define GEN_PASS_DECL_AFFINELOOPFUSIONPASS
+#define GEN_PASS_DECL_AFFINELOOPINVARIANTCODEMOTIONPASS
+#define GEN_PASS_DECL_AFFINELOOPTILINGPASS
+#define GEN_PASS_DECL_AFFINELOOPUNROLLPASS
+#define GEN_PASS_DECL_AFFINELOOPUNROLLANDJAMPASS
+#define GEN_PASS_DECL_AFFINEPIPELINEDATATRANSFERPASS
+#define GEN_PASS_DECL_AFFINESCALARREPLACEMENTPASS
+#define GEN_PASS_DECL_AFFINEVECTORIZEPASS
+#define GEN_PASS_DECL_AFFINEPARALLELIZEPASS
+#define GEN_PASS_DECL_AFFINELOOPNORMALIZEPASS
+#define GEN_PASS_DECL_LOOPCOALESCINGPASS
+#define GEN_PASS_DECL_SIMPLIFYAFFINESTRUCTURESPASS
+#define GEN_PASS_DECL_AFFINEEXPANDINDEXOPSPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+
 /// Creates a simplification pass for affine structures (maps and sets). In
 /// addition, this pass also normalizes memrefs to have the trivial (identity)
 /// layout map.
 std::unique_ptr<OperationPass<func::FuncOp>>
 createSimplifyAffineStructuresPass();
 
 /// Creates a loop invariant code motion pass that hoists loop invariant
 /// operations out of affine loops.

mlir/include/mlir/Dialect/Affine/Passes.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_AFFINE_PASSES
 #define MLIR_DIALECT_AFFINE_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def AffineDataCopyGeneration : Pass<"affine-data-copy-generate", "func::FuncOp"> {
+def AffineDataCopyGenerationPass : Pass<"affine-data-copy-generate", "func::FuncOp"> {
   let summary = "Generate explicit copying for affine memory operations";
   let constructor = "mlir::createAffineDataCopyGenerationPass()";
   let dependentDialects = ["memref::MemRefDialect"];
   let options = [
     Option<"fastMemoryCapacity", "fast-mem-capacity", "uint64_t",
            /*default=*/"std::numeric_limits<uint64_t>::max()",
            "Set fast memory space capacity in KiB (default: unlimited)">,
     Option<"fastMemorySpace", "fast-mem-space", "unsigned",
Option<"skipNonUnitStrideLoops", "skip-non-unit-stride-loops", "bool",
            /*default=*/"false", "Testing purposes: avoid non-unit stride loop "
                                 "choice depths for copy placement">,
     Option<"tagMemorySpace", "tag-mem-space", "unsigned",
            /*default=*/"0",
            "Tag memory space identifier for copy generation (default: 0)">,
   ];
 }
 
-def AffineLoopFusion : Pass<"affine-loop-fusion", "func::FuncOp"> {
+def AffineLoopFusionPass : Pass<"affine-loop-fusion", "func::FuncOp"> {
   let summary = "Fuse affine loop nests";
   let description = [{
     This pass performs fusion of loop nests using a slicing-based approach. It
     combines two fusion strategies: producer-consumer fusion and sibling fusion.
     Producer-consumer fusion is aimed at fusing pairs of loops where the first
     one writes to a memref that the second reads. Sibling fusion targets pairs
     of loops that share no dependences between them but that load from the same
     memref. The fused loop nests, when possible, are rewritten to access
Option<"affineFusionMode", "mode", "enum FusionMode",
            "clEnumValN( mlir::FusionMode::ProducerConsumer, "
            "\"producer\", \"Perform only producer-consumer fusion\"), "
            "clEnumValN( mlir::FusionMode::Sibling, "
            "\"sibling\", \"Perform only sibling fusion\"))">,
     ];
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
-def AffineLoopInvariantCodeMotion
+def AffineLoopInvariantCodeMotionPass
     : Pass<"affine-loop-invariant-code-motion", "func::FuncOp"> {
   let summary = "Hoist loop invariant instructions outside of affine loops";
   let constructor = "mlir::createAffineLoopInvariantCodeMotionPass()";
 }
 
-def AffineLoopTiling : Pass<"affine-loop-tile", "func::FuncOp"> {
+def AffineLoopTilingPass : Pass<"affine-loop-tile", "func::FuncOp"> {
   let summary = "Tile affine loop nests";
   let constructor = "mlir::createLoopTilingPass()";
   let options = [
     Option<"cacheSizeInKiB", "cache-size", "uint64_t", /*default=*/"512",
            "Set size of cache to tile for in KiB (default: 512)">,
     Option<"separate", "separate", "bool", /*default=*/"false",
            "Separate full and partial tiles (default: false)">,
     Option<"tileSize", "tile-size", "unsigned", /*default=*/"",
            "Use this tile size for all loops">,
     ListOption<"tileSizes", "tile-sizes", "unsigned",
                "List of tile sizes for each perfect nest "
                "(overridden by -tile-size)">,
   ];
 }
 
-def AffineLoopUnroll : Pass<"affine-loop-unroll", "func::FuncOp"> {
+def AffineLoopUnrollPass : Pass<"affine-loop-unroll", "func::FuncOp"> {
   let summary = "Unroll affine loops";
   let constructor = "mlir::createLoopUnrollPass()";
   let options = [
     Option<"unrollFactor", "unroll-factor", "unsigned", /*default=*/"4",
            "Use this unroll factor for all loops being unrolled">,
     Option<"unrollUpToFactor", "unroll-up-to-factor", "bool",
            /*default=*/"false", "Allow unrolling up to the factor specified">,
     Option<"unrollFull", "unroll-full", "bool", /*default=*/"false",
            "Fully unroll loops">,
     Option<"numRepetitions", "unroll-num-reps", "unsigned", /*default=*/"1",
            "Unroll innermost loops repeatedly this many times">,
     Option<"unrollFullThreshold", "unroll-full-threshold", "unsigned",
            /*default=*/"1",
            "Unroll all loops with trip count less than or equal to this">,
     Option<"cleanUpUnroll", "cleanup-unroll", "bool", /*default=*/"false",
            "Fully unroll the cleanup loop when possible.">,
   ];
 }
 
-def AffineLoopUnrollAndJam : Pass<"affine-loop-unroll-jam", "func::FuncOp"> {
+def AffineLoopUnrollAndJamPass : Pass<"affine-loop-unroll-jam", "func::FuncOp"> {
   let summary = "Unroll and jam affine loops";
   let constructor = "mlir::createLoopUnrollAndJamPass()";
   let options = [
     Option<"unrollJamFactor", "unroll-jam-factor", "unsigned",
            /*default=*/"4",
            "Use this unroll jam factor for all loops (default 4)">,
   ];
 }
 
-def AffinePipelineDataTransfer
+def AffinePipelineDataTransferPass
     : Pass<"affine-pipeline-data-transfer", "func::FuncOp"> {
   let summary = "Pipeline non-blocking data transfers between explicitly "
                 "managed levels of the memory hierarchy";
   let description = [{
     This pass performs a transformation to overlap non-blocking DMA operations
     in a loop with computations through double buffering. This is achieved by
     advancing dma_start operations with respect to other operations.
 
module {
         return
       }
     }
     ```
   }];
   let constructor = "mlir::createPipelineDataTransferPass()";
 }
 
-def AffineScalarReplacement : Pass<"affine-scalrep", "func::FuncOp"> {
+def AffineScalarReplacementPass : Pass<"affine-scalrep", "func::FuncOp"> {
   let summary = "Replace affine memref acceses by scalars by forwarding stores "
                 "to loads and eliminating redundant loads";
   let description = [{
     This pass performs store to load forwarding and redundant load elimination
     for affine memref accesses and potentially eliminates the entire memref
     if all its accesses are forwarded.
 
     Input
module {
         return %0 : memref<10x10xf32>
       }
     }
     ```
   }];
   let constructor = "mlir::createAffineScalarReplacementPass()";
 }
 
-def AffineVectorize : Pass<"affine-super-vectorize", "func::FuncOp"> {
+def AffineVectorizePass : Pass<"affine-super-vectorize", "func::FuncOp"> {
   let summary = "Vectorize to a target independent n-D vector abstraction";
   let constructor = "mlir::createSuperVectorizePass()";
   let dependentDialects = ["vector::VectorDialect"];
   let options = [
     ListOption<"vectorSizes", "virtual-vector-size", "int64_t",
                "Specify an n-D virtual vector size for vectorization">,
     // Optionally, the fixed mapping from loop to fastest varying MemRef
     // dimension for all the MemRefs within a loop pattern:
     //   the index represents the loop depth, the value represents the k^th
     //   fastest varying memory dimension.
     // This is voluntarily restrictive and is meant to precisely target a
     // particular loop/op pair, for testing purposes.
     ListOption<"fastestVaryingPattern", "test-fastest-varying", "int64_t",
                "Specify a 1-D, 2-D or 3-D pattern of fastest varying memory "
                "dimensions to match. See defaultPatterns in Vectorize.cpp for "
                "a description and examples. This is used for testing purposes">,
     Option<"vectorizeReductions", "vectorize-reductions", "bool",
            /*default=*/"false",
            "Vectorize known reductions expressed via iter_args. "
            "Switched off by default.">
   ];
 }
 
-def AffineParallelize : Pass<"affine-parallelize", "func::FuncOp"> {
+def AffineParallelizePass : Pass<"affine-parallelize", "func::FuncOp"> {
   let summary = "Convert affine.for ops into 1-D affine.parallel";
   let constructor = "mlir::createAffineParallelizePass()";
   let options = [
     Option<"maxNested", "max-nested", "unsigned", /*default=*/"-1u",
            "Maximum number of nested parallel loops to produce. "
            "Defaults to unlimited (UINT_MAX).">,
     Option<"parallelReductions", "parallel-reductions", "bool",
            /*default=*/"false",
            "Whether to parallelize reduction loops. Defaults to false.">
   ];
 }
 
-def AffineLoopNormalize : Pass<"affine-loop-normalize", "func::FuncOp"> {
+def AffineLoopNormalizePass : Pass<"affine-loop-normalize", "func::FuncOp"> {
   let summary = "Apply normalization transformations to affine loop-like ops";
   let constructor = "mlir::createAffineLoopNormalizePass()";
 }
 
-def LoopCoalescing : Pass<"affine-loop-coalescing", "func::FuncOp"> {
+def LoopCoalescingPass : Pass<"affine-loop-coalescing", "func::FuncOp"> {
   let summary = "Coalesce nested loops with independent bounds into a single "
                 "loop";
   let constructor = "mlir::createLoopCoalescingPass()";
   let dependentDialects = ["arith::ArithmeticDialect"];
 }
 
-def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> {
+def SimplifyAffineStructuresPass : Pass<"affine-simplify-structures", "func::FuncOp"> {
   let summary = "Simplify affine expressions in maps/sets and normalize "
                 "memrefs";
   let constructor = "mlir::createSimplifyAffineStructuresPass()";
 }
 
-def AffineExpandIndexOps : Pass<"affine-expand-index-ops"> {
+def AffineExpandIndexOpsPass : Pass<"affine-expand-index-ops"> {
   let summary = "Lower affine operations operating on indices into more fundamental operations";
   let constructor = "mlir::createAffineExpandIndexOpsPass()";
 }
 
 #endif // MLIR_DIALECT_AFFINE_PASSES

mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- 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_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace arith {
 
+#define GEN_PASS_DECL_ARITHMETICBUFFERIZEPASS
+#define GEN_PASS_DECL_ARITHMETICEXPANDOPSPASS
+#define GEN_PASS_DECL_ARITHMETICUNSIGNEDWHENEQUIVALENTPASS
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+
 /// Create a pass to bufferize Arithmetic ops.
 std::unique_ptr<Pass> createArithmeticBufferizePass();
 
 /// Create a pass to bufferize arith.constant ops.
 std::unique_ptr<Pass> createConstantBufferizePass(uint64_t alignment = 0);
 
 /// Add patterns to expand Arithmetic ops for LLVM lowering.
 void populateArithmeticExpandOpsPatterns(RewritePatternSet &patterns);

mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.td

 //===-- Passes.td - Arithmetic pass definition file --------*- tablegen -*-===//
 //
 // 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_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
 #define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def ArithmeticBufferize : Pass<"arith-bufferize", "ModuleOp"> {
+def ArithmeticBufferizePass : Pass<"arith-bufferize", "ModuleOp"> {
   let summary = "Bufferize Arithmetic dialect ops.";
   let description = [{
     This pass bufferizes arith dialect ops.
 
     This pass needs to be a module pass because it inserts memref.global
     ops into the module, which cannot be done safely from a function pass due to
     multi-threading. Most other bufferization passes can run in parallel at
     function granularity.
   }];
   let constructor = "mlir::arith::createArithmeticBufferizePass()";
   let options = [
     Option<"alignment", "alignment", "unsigned", /*default=*/"0",
            "Create global memrefs with a specified alignment">,
   ];
 }
 
-def ArithmeticExpandOps : Pass<"arith-expand"> {
+def ArithmeticExpandOpsPass : Pass<"arith-expand"> {
   let summary = "Legalize Arithmetic ops to be convertible to LLVM.";
   let constructor = "mlir::arith::createArithmeticExpandOpsPass()";
 }
 
-def ArithmeticUnsignedWhenEquivalent : Pass<"arith-unsigned-when-equivalent"> {
+def ArithmeticUnsignedWhenEquivalentPass : Pass<"arith-unsigned-when-equivalent"> {
   let summary = "Replace signed ops with unsigned ones where they are proven equivalent";
   let description = [{
     Replace signed ops with their unsigned equivalents when integer range analysis
     determines that their arguments and results are all guaranteed to be
     non-negative when interpreted as signed integers. When this occurs,
     we know that the semantics of the signed and unsigned operations are the same,
     since they share the same behavior when their operands and results  are in the
     range [0, signed_max(type)].
 
     The affect ops include division, remainder, shifts, min, max, and integer
     comparisons.
   }];
   let constructor = "mlir::arith::createArithmeticUnsignedWhenEquivalentPass()";
 }
 
 #endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Async/Passes.h

 #ifndef MLIR_DIALECT_ASYNC_PASSES_H_
 #define MLIR_DIALECT_ASYNC_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 class ModuleOp;
 
+#define GEN_PASS_DECL_ASYNCPARALLELFORPASS
+#define GEN_PASS_DECL_ASYNCTOASYNCRUNTIMEPASS
+#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGPASS
+#define GEN_PASS_DECL_ASYNCRUNTIMEREFCOUNTINGOPTPASS
+#define GEN_PASS_DECL_ASYNCRUNTIMEPOLICYBASEDREFCOUNTINGPASS
+#include "mlir/Dialect/Async/Passes.h.inc"
+
 std::unique_ptr<Pass> createAsyncParallelForPass();
 
 std::unique_ptr<Pass> createAsyncParallelForPass(bool asyncDispatch,
                                                  int32_t numWorkerThreads,
                                                  int32_t minTaskSize);
 
 std::unique_ptr<OperationPass<ModuleOp>> createAsyncToAsyncRuntimePass();
 

mlir/include/mlir/Dialect/Async/Passes.td

 //===-- Passes.td - Async pass definition file -------------*- tablegen -*-===//
 //
 // 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_DIALECT_ASYNC_PASSES
 #define MLIR_DIALECT_ASYNC_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def AsyncParallelFor : Pass<"async-parallel-for", "ModuleOp"> {
+def AsyncParallelForPass : Pass<"async-parallel-for", "ModuleOp"> {
   let summary = "Convert scf.parallel operations to multiple async compute ops "
                 "executed concurrently for non-overlapping iteration ranges";
   let constructor = "mlir::createAsyncParallelForPass()";
 
   let options = [
     Option<"asyncDispatch", "async-dispatch",
       "bool", /*default=*/"true",
       "Dispatch async compute tasks using recursive work splitting. If `false` "
def AsyncParallelForPass : Pass<"async-parallel-for", "ModuleOp"> {
 
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "async::AsyncDialect",
     "scf::SCFDialect"
   ];
 }
 
-def AsyncToAsyncRuntime : Pass<"async-to-async-runtime", "ModuleOp"> {
+def AsyncToAsyncRuntimePass : Pass<"async-to-async-runtime", "ModuleOp"> {
   let summary = "Lower high level async operations (e.g. async.execute) to the"
                 "explicit async.runtime and async.coro operations";
   let constructor = "mlir::createAsyncToAsyncRuntimePass()";
   let options = [
     // Temporary for bringup, should become the default.
     Option<"eliminateBlockingAwaitOps", "eliminate-blocking-await-ops", "bool",
             /*default=*/"false",
            "Rewrite functions with blocking async.runtime.await as coroutines "
            "with async.runtime.await_and_resume.">,
   ];
   let dependentDialects = ["async::AsyncDialect"];
 }
 
-def AsyncRuntimeRefCounting : Pass<"async-runtime-ref-counting"> {
+def AsyncRuntimeRefCountingPass : Pass<"async-runtime-ref-counting"> {
   let summary = "Automatic reference counting for Async runtime operations";
   let description = [{
     This pass works at the async runtime abtraction level, after all
     `async.execute` and `async.await` operations are lowered to the async
     runtime API calls, and async coroutine operations.
 
     It relies on the LLVM coroutines switched-resume lowering semantics for
     the correct placing of the reference counting operations.
 
     See: https://llvm.org/docs/Coroutines.html#switched-resume-lowering
   }];
 
   let constructor = "mlir::createAsyncRuntimeRefCountingPass()";
   let dependentDialects = ["async::AsyncDialect"];
 }
 
-def AsyncRuntimeRefCountingOpt : Pass<"async-runtime-ref-counting-opt"> {
+def AsyncRuntimeRefCountingOptPass : Pass<"async-runtime-ref-counting-opt"> {
   let summary = "Optimize automatic reference counting operations for the"
                 "Async runtime by removing redundant operations";
   let constructor = "mlir::createAsyncRuntimeRefCountingOptPass()";
   let dependentDialects = ["async::AsyncDialect"];
 }
 
-def AsyncRuntimePolicyBasedRefCounting
+def AsyncRuntimePolicyBasedRefCountingPass
     : Pass<"async-runtime-policy-based-ref-counting"> {
   let summary = "Policy based reference counting for Async runtime operations";
   let description = [{
     This pass works at the async runtime abtraction level, after all
     `async.execute` and `async.await` operations are lowered to the async
     runtime API calls, and async coroutine operations.
 
     This pass doesn't rely on reference counted values liveness analysis, and

mlir/include/mlir/Dialect/Bufferization/Transforms/Passes.h

 
 namespace bufferization {
 struct OneShotBufferizationOptions;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
+#define GEN_PASS_DECL_BUFFERDEALLOCATIONPASS
+#define GEN_PASS_DECL_BUFFERHOISTINGPASS
+#define GEN_PASS_DECL_BUFFERLOOPHOISTINGPASS
+#define GEN_PASS_DECL_BUFFERRESULTSTOOUTPARAMSPASS
+#define GEN_PASS_DECL_FINALIZINGBUFFERIZEPASS
+#define GEN_PASS_DECL_BUFFERIZATIONBUFFERIZEPASS
+#define GEN_PASS_DECL_DROPEQUIVALENTBUFFERRESULTSPASS
+#define GEN_PASS_DECL_ONESHOTBUFFERIZEPASS
+#define GEN_PASS_DECL_PROMOTEBUFFERSTOSTACKPASS
+#define GEN_PASS_DECL_TENSORCOPYINSERTIONPASS
+#define GEN_PASS_DECL_ALLOCTENSORELIMINATIONPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+
 /// Creates an instance of the BufferDeallocation pass to free all allocated
 /// buffers.
 std::unique_ptr<Pass> createBufferDeallocationPass();
 
 /// Run buffer deallocation.
 LogicalResult deallocateBuffers(Operation *op);
 
 /// Creates a pass that moves allocations upwards to reduce the number of

mlir/include/mlir/Dialect/Bufferization/Transforms/Passes.td

 //===-- Passes.td - Bufferization passes definition file ---*- tablegen -*-===//
 //
 // 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_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES
 #define MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def BufferDeallocation : Pass<"buffer-deallocation", "func::FuncOp"> {
+def BufferDeallocationPass : Pass<"buffer-deallocation", "func::FuncOp"> {
   let summary = "Adds all required dealloc operations for all allocations in "
                 "the input program";
   let description = [{
     This pass implements an algorithm to automatically introduce all required
     deallocation operations for all buffers in the input program. This ensures
     that the resulting program does not have any memory leaks.
 
 
let description = [{
 
     }
     ```
 
   }];
   let constructor = "mlir::bufferization::createBufferDeallocationPass()";
 }
 
-def BufferHoisting : Pass<"buffer-hoisting", "func::FuncOp"> {
+def BufferHoistingPass : Pass<"buffer-hoisting", "func::FuncOp"> {
   let summary = "Optimizes placement of allocation operations by moving them "
                 "into common dominators and out of nested regions";
   let description = [{
     This pass implements an approach to aggressively move allocations upwards
     into common dominators and out of nested regions.
   }];
   let constructor = "mlir::bufferization::createBufferHoistingPass()";
 }
 
-def BufferLoopHoisting : Pass<"buffer-loop-hoisting", "func::FuncOp"> {
+def BufferLoopHoistingPass : Pass<"buffer-loop-hoisting", "func::FuncOp"> {
   let summary = "Optimizes placement of allocation operations by moving them "
                 "out of loop nests";
   let description = [{
     This pass implements an approach to aggressively move allocations upwards
     out of loop nests. It does not move allocations into common dominators.
   }];
   let constructor = "mlir::bufferization::createBufferLoopHoistingPass()";
 }
 
-def BufferResultsToOutParams : Pass<"buffer-results-to-out-params", "ModuleOp">  {
+def BufferResultsToOutParamsPass : Pass<"buffer-results-to-out-params", "ModuleOp">  {
   let summary = "Converts memref-typed function results to out-params";
   let description = [{
     Some calling conventions prefer to pass output memrefs as "out params". The
     conversion to this calling convention must be done as an atomic
     transformation of the entire program (hence this is a module pass).
 
     For example, if a call is rewritten, the callee needs to be rewritten
     otherwise the IR will end up invalid. Thus, this transformation
     require an atomic change to the entire program (e.g. the whole module).
 
     This pass is expected to run immediately after bufferization is finished.
     At that point, tensor-typed results will have been converted to memref-typed
     results, and can be consistently converted to out params.
 
     All memref-typed results are appended to the function argument list.
 
     The main issue with this pass (and the out-param calling convention) is that
     buffers for results need to be allocated in the caller. This currently only
     works for static shaped memrefs.
   }];
   let constructor = "mlir::bufferization::createBufferResultsToOutParamsPass()";
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
-def FinalizingBufferize : Pass<"finalizing-bufferize", "func::FuncOp"> {
+def FinalizingBufferizePass : Pass<"finalizing-bufferize", "func::FuncOp"> {
   let summary = "Finalize a partial bufferization";
   let description = [{
     A bufferize pass that finalizes a partial bufferization by removing
     remaining `bufferization.to_tensor` and `bufferization.to_buffer` operations.
 
     The removal of those operations is only possible if the operations only
     exist in pairs, i.e., all uses of `bufferization.to_tensor` operations are
     `bufferization.to_buffer` operations.
 
     This pass will fail if not all operations can be removed or if any operation
     with tensor typed operands remains.
   }];
   let constructor = "mlir::bufferization::createFinalizingBufferizePass()";
 }
 
-def BufferizationBufferize : Pass<"bufferization-bufferize", "func::FuncOp"> {
+def BufferizationBufferizePass : Pass<"bufferization-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the `bufferization` dialect";
   let constructor = "mlir::bufferization::createBufferizationBufferizePass()";
 }
 
-def DropEquivalentBufferResults : Pass<"drop-equivalent-buffer-results", "ModuleOp">  {
+def DropEquivalentBufferResultsPass : Pass<"drop-equivalent-buffer-results", "ModuleOp">  {
   let summary = "Remove MemRef return values that are equivalent to a bbArg";
   let description = [{
     This pass removes MemRef return values from functions if they are equivalent
     to a function bbArg. In that case, the return value is redundant and the
     respective CallOp operand can be used at the call site.
 
     Note: If a bbArg buffer is not returned directly but casted to beforehand,
     the buffer is still considered equivalent.
   }];
   let constructor = "mlir::bufferization::createDropEquivalentBufferResultsPass()";
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
-def OneShotBufferize : Pass<"one-shot-bufferize", "ModuleOp"> {
+def OneShotBufferizePass : Pass<"one-shot-bufferize", "ModuleOp"> {
   let summary = "One-Shot Bufferize";
   let description = [{
     This pass bufferizes all ops that implement `BufferizableOpInterface`. It
     first performs an inplacability analysis on SSA use-def chains of tensor
     values to determine which OpOperands may bufferize in-place, i.e., without
     inserting a buffer copy. It then rewrites the IR, inserting a buffer
     allocation and copy for each OpOperand that was decided to bufferize
     out-of-place.
Option<"printConflicts", "print-conflicts", "bool",
            "test-analysis-only.">,
     Option<"unknownTypeConversion", "unknown-type-conversion", "std::string",
            /*default=*/"\"fully-dynamic-layout-map\"",
            "Controls layout maps for non-inferrable memref types.">,
   ];
   let constructor = "mlir::bufferization::createOneShotBufferizePass()";
 }
 
-def PromoteBuffersToStack : Pass<"promote-buffers-to-stack", "func::FuncOp"> {
+def PromoteBuffersToStackPass : Pass<"promote-buffers-to-stack", "func::FuncOp"> {
   let summary = "Promotes heap-based allocations to automatically managed "
                 "stack-based allocations";
   let description = [{
     This pass implements a simple algorithm to convert heap-based memory
     allocations to stack-based ones. It uses a built-in heuristic to decide
     whether it makes sense to convert an allocation. Furthermore, dynamic
     shaped buffers that are limited by the rank of the tensor can be
     converted. They are only transformed if they are considered to be small.
   }];
   let constructor = "mlir::bufferization::createPromoteBuffersToStackPass()";
   let options = [
     Option<"maxAllocSizeInBytes", "max-alloc-size-in-bytes", "unsigned",
            /*default=*/"1024",
            "Maximal size in bytes to promote allocations to stack.">,
     Option<"maxRankOfAllocatedMemRef", "max-rank-of-allocated-memref", "unsigned",
            /*default=*/"1",
            "Maximal memref rank to promote dynamic buffers.">,
   ];
 }
 
-def TensorCopyInsertion : Pass<"tensor-copy-insertion"> {
+def TensorCopyInsertionPass : Pass<"tensor-copy-insertion"> {
   let summary = "Make all tensor IR inplaceable by inserting copies";
   let description = [{
     This pass runs One-Shot Analysis and inserts copies for all OpOperands that
     were decided to bufferize out-of-place. After running this pass, a
     bufferization can write to buffers directly (without making copies) and no
     longer has to care about potential read-after-write conflicts.
 
     Note: By default, all newly inserted tensor copies/allocs (i.e., newly
let options = [
     Option<"mustInferMemorySpace", "must-infer-memory-space", "bool",
            /*default=*/"false",
            "The memory space of an memref types must always be inferred. If "
            "unset, a default memory space of 0 is used otherwise.">,
   ];
   let constructor = "mlir::bufferization::createTensorCopyInsertionPass()";
 }
 
-def AllocTensorElimination : Pass<"eliminate-alloc-tensors"> {
+def AllocTensorEliminationPass : Pass<"eliminate-alloc-tensors"> {
   let summary = "Try to eliminate all alloc_tensor ops.";
   let description = [{
     This pass tries to eliminate all insert_slice op-anchored alloc_tensor ops.
     I.e., when a value that is equivalent to an alloc_tensor op is inserted into
     another tensor, this pass tries to rewrite the IR in such a way that the
     destination tensor of the insert_slice op is used directly instead of the
     alloc_tensor result.
   }];
   let constructor = "mlir::bufferization::createAllocTensorEliminationPass()";
 }
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Func/Transforms/Passes.h

 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
 } // namespace bufferization
 
 class RewritePatternSet;
 
 namespace func {
+
+#define GEN_PASS_DECL_FUNCBUFFERIZEPASS
+#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+
 /// Creates an instance of func bufferization pass.
 std::unique_ptr<Pass> createFuncBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Func/Transforms/Passes.h.inc"
 
 } // namespace func
 } // namespace mlir
 
 #endif // MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Func/Transforms/Passes.td

 //===-- Passes.td - Func pass definition file --------------*- tablegen -*-===//
 //
 // 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_DIALECT_FUNC_TRANSFORMS_PASSES_TD
 #define MLIR_DIALECT_FUNC_TRANSFORMS_PASSES_TD
 
 include "mlir/Pass/PassBase.td"
 
-def FuncBufferize : Pass<"func-bufferize", "ModuleOp"> {
+def FuncBufferizePass : Pass<"func-bufferize", "ModuleOp"> {
   let summary = "Bufferize func/call/return ops";
   let description = [{
     A bufferize pass that bufferizes func.func and func.call ops.
 
     Because this pass updates func.func ops, it must be a module pass. It is
     useful to keep this pass separate from other bufferizations so that the
     other ones can be run at function-level in parallel.
 

mlir/include/mlir/Dialect/GPU/Transforms/Passes.h

 class Module;
 } // namespace llvm
 
 namespace mlir {
 namespace func {
 class FuncOp;
 } // namespace func
 
+#define GEN_PASS_DECL_GPULAUNCHSINKINDEXCOMPUTATIONSPASS
+#define GEN_PASS_DECL_GPUKERNELOUTLININGPASS
+#define GEN_PASS_DECL_GPUASYNCREGIONPASS
+#define GEN_PASS_DECL_GPUMAPPARALLELLOOPSPASS
+#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
+
 /// Pass that moves ops which are likely an index computation into gpu.launch
 /// body.
 std::unique_ptr<Pass> createGpuLauchSinkIndexComputationsPass();
 
 /// Replaces `gpu.launch` with `gpu.launch_func` by moving the region into
 /// a separate kernel function.
 std::unique_ptr<OperationPass<ModuleOp>>
 createGpuKernelOutliningPass(StringRef dataLayoutStr = StringRef());

mlir/include/mlir/Dialect/GPU/Transforms/Passes.td

 //===-- Passes.td - GPU pass definition file ---------------*- tablegen -*-===//
 //
 // 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_DIALECT_GPU_PASSES
 #define MLIR_DIALECT_GPU_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def GpuLaunchSinkIndexComputations : Pass<"gpu-launch-sink-index-computations"> {
+def GpuLaunchSinkIndexComputationsPass : Pass<"gpu-launch-sink-index-computations"> {
   let summary = "Sink index computations into gpu.launch body";
   let constructor = "mlir::createGpuLauchSinkIndexComputationsPass()";
   let dependentDialects = ["mlir::gpu::GPUDialect"];
 }
 
-def GpuKernelOutlining : Pass<"gpu-kernel-outlining", "ModuleOp"> {
+def GpuKernelOutliningPass : Pass<"gpu-kernel-outlining", "ModuleOp"> {
   let summary = "Outline gpu.launch bodies to kernel functions";
   let constructor = "mlir::createGpuKernelOutliningPass()";
   let dependentDialects = ["mlir::DLTIDialect"];
 }
 
 def GpuAsyncRegionPass : Pass<"gpu-async-region", "func::FuncOp"> {
   let summary = "Make GPU ops async";
   let constructor = "mlir::createGpuAsyncRegionPass()";

mlir/include/mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h

 #include <memory>
 
 namespace mlir {
 class Operation;
 class Pass;
 
 namespace LLVM {
 
+#define GEN_PASS_DECL_LLVMLEGALIZEFOREXPORTPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
 /// Make argument-taking successors of each block distinct.  PHI nodes in LLVM
 /// IR use the predecessor ID to identify which value to take. They do not
 /// support different values coming from the same predecessor. If a block has
 /// another block as a successor more than once with different values, insert
 /// a new dummy block for LLVM PHI nodes to tell the sources apart.
 void ensureDistinctSuccessors(Operation *op);
 
 /// Creates a pass that legalizes the LLVM dialect operations so that they can
 /// be translated to LLVM IR.
 std::unique_ptr<Pass> createLegalizeForExportPass();
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_LEGALIZEFOREXPORT_H

mlir/include/mlir/Dialect/LLVMIR/Transforms/OptimizeForNVVM.h

 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace NVVM {
 
+#define GEN_PASS_DECL_NVVMOPTIMIZEFORTARGETPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
 /// Creates a pass that optimizes LLVM IR for the NVVM target.
 std::unique_ptr<Pass> createOptimizeForTargetPass();
 
 } // namespace NVVM
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_OPTIMIZENVVM_H

mlir/include/mlir/Dialect/LLVMIR/Transforms/Passes.td

 //===-- Passes.td - LLVM pass definition file --------------*- tablegen -*-===//
 //
 // 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_DIALECT_LLVMIR_TRANSFORMS_PASSES
 #define MLIR_DIALECT_LLVMIR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def LLVMLegalizeForExport : Pass<"llvm-legalize-for-export"> {
+def LLVMLegalizeForExportPass : Pass<"llvm-legalize-for-export"> {
   let summary = "Legalize LLVM dialect to be convertible to LLVM IR";
   let constructor = "::mlir::LLVM::createLegalizeForExportPass()";
 }
 
-def LLVMRequestCWrappers
+def LLVMRequestCWrappersPass
     : Pass<"llvm-request-c-wrappers", "::mlir::func::FuncOp"> {
   let summary = "Request C wrapper emission for all functions";
   let description = [{
     Annotate every builtin function in the module with the LLVM dialect
     attribute that instructs the conversion to LLVM to emit the C wrapper for
     the function. This pass is expected to be applied immediately before the
     conversion of builtin functions to LLVM to avoid the attribute being
     dropped by other passes.
   }];
   let constructor = "::mlir::LLVM::createRequestCWrappersPass()";
 }
 
-def NVVMOptimizeForTarget : Pass<"llvm-optimize-for-nvvm-target"> {
+def NVVMOptimizeForTargetPass : Pass<"llvm-optimize-for-nvvm-target"> {
   let summary = "Optimize NVVM IR";
   let constructor = "::mlir::NVVM::createOptimizeForTargetPass()";
 }
 
 #endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/LLVMIR/Transforms/RequestCWrappers.h

 #define MLIR_DIALECT_LLVMIR_TRANSFORMS_REQUESTCWRAPPERS_H
 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace LLVM {
+
+#define GEN_PASS_DECL_LLVMREQUESTCWRAPPERSPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
 std::unique_ptr<Pass> createRequestCWrappersPass();
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_REQUESTCWRAPPERS_H

mlir/include/mlir/Dialect/Linalg/Passes.h

 namespace func {
 class FuncOp;
 } // namespace func
 
 namespace bufferization {
 struct OneShotBufferizationOptions;
 } // namespace bufferization
 
+#define GEN_PASS_DECL_CONVERTELEMENTWISETOLINALGPASS
+#define GEN_PASS_DECL_LINALGINITTENSORTOALLOCTENSORPASS
+#define GEN_PASS_DECL_LINALGFOLDUNITEXTENTDIMSPASS
+#define GEN_PASS_DECL_LINALGELEMENTWISEOPFUSIONPASS
+#define GEN_PASS_DECL_LINALGNAMEDOPCONVERSIONPASS
+#define GEN_PASS_DECL_LINALGINLINESCALAROPERANDSPASS
+#define GEN_PASS_DECL_LINALGLOWERTOAFFINELOOPSPASS
+#define GEN_PASS_DECL_LINALGLOWERTOLOOPSPASS
+#define GEN_PASS_DECL_LINALGLOWERTOPARALLELLOOPSPASS
+#define GEN_PASS_DECL_LINALGBUFFERIZEPASS
+#define GEN_PASS_DECL_LINALGTILINGPASS
+#define GEN_PASS_DECL_LINALGGENERALIZATIONPASS
+#define GEN_PASS_DECL_LINALGDETENSORIZEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYTILEANDFUSEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYTILEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYPADPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYDECOMPOSEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYPEELPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYVECTORIZEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYENABLEPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYLOWERVECTORSPASS
+#define GEN_PASS_DECL_LINALGSTRATEGYREMOVEMARKERSPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+
 std::unique_ptr<Pass> createConvertElementwiseToLinalgPass();
 
 std::unique_ptr<Pass> createLinalgFoldUnitExtentDimsPass();
 
 std::unique_ptr<Pass> createLinalgElementwiseOpFusionPass();
 std::unique_ptr<Pass> createFoldReshapeOpsByLinearizationPass();
 
 std::unique_ptr<Pass> createLinalgNamedOpConversionPass();

mlir/include/mlir/Dialect/Linalg/Passes.td

 //===-- Passes.td - Linalg pass definition file ------------*- tablegen -*-===//
 //
 // 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_DIALECT_LINALG_PASSES
 #define MLIR_DIALECT_LINALG_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def ConvertElementwiseToLinalg : Pass<"convert-elementwise-to-linalg", ""> {
+def ConvertElementwiseToLinalgPass : Pass<"convert-elementwise-to-linalg", ""> {
   let summary = "Convert ElementwiseMappable ops to linalg";
   let description = [{
     Convert ops with the `ElementwiseMappable` trait to linalg parallel loops.
 
     This pass only converts ops that operate on ranked tensors. It can be
     run on op which contains linalg ops (most commonly a
     FunctionOpInterface op).
   }];
   let constructor = "mlir::createConvertElementwiseToLinalgPass()";
   let dependentDialects = ["linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
-def LinalgInitTensorToAllocTensor : Pass<"linalg-init-tensor-to-alloc-tensor"> {
+def LinalgInitTensorToAllocTensorPass : Pass<"linalg-init-tensor-to-alloc-tensor"> {
   let summary = "Replace all init_tensor ops by alloc_tensor ops.";
   let description = [{
     init_tensor ops return a tensor of unspecified contents who's only purpose
     is to carry the tensor shape. This pass converts such ops to
     bufferization.alloc_tensor ops, which bufferize to buffer allocations.
   }];
   let constructor = "mlir::createLinalgInitTensorToAllocTensorPass()";
 }
 
-def LinalgFoldUnitExtentDims : Pass<"linalg-fold-unit-extent-dims", ""> {
+def LinalgFoldUnitExtentDimsPass : Pass<"linalg-fold-unit-extent-dims", ""> {
   let summary = "Remove unit-extent dimension in Linalg ops on tensors";
   let constructor = "mlir::createLinalgFoldUnitExtentDimsPass()";
   let options = [
     Option<"foldOneTripLoopsOnly", "fold-one-trip-loops-only", "bool",
             /*default=*/"false",
            "Only folds the one-trip loops from Linalg ops on tensors "
            "(for testing purposes only)">
   ];
   let dependentDialects = [
     "linalg::LinalgDialect", "AffineDialect", "memref::MemRefDialect"
   ];
 }
 
-def LinalgElementwiseOpFusion : Pass<"linalg-fuse-elementwise-ops"> {
+def LinalgElementwiseOpFusionPass : Pass<"linalg-fuse-elementwise-ops"> {
   let summary = "Fuse elementwise operations on tensors";
   let constructor = "mlir::createLinalgElementwiseOpFusionPass()";
   let dependentDialects = [
     "AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"
   ];
 }
 
-def LinalgNamedOpConversion: Pass<"linalg-named-op-conversion"> {
+def LinalgNamedOpConversionPass : Pass<"linalg-named-op-conversion"> {
   let summary = "Convert from one named linalg op to another.";
   let constructor = "mlir::createLinalgNamedOpConversionPass()";
   let dependentDialects = ["linalg::LinalgDialect", "tensor::TensorDialect"];
 }
 
-def LinalgInlineScalarOperands : Pass<"linalg-inline-scalar-operands", "func::FuncOp"> {
+def LinalgInlineScalarOperandsPass : Pass<"linalg-inline-scalar-operands", "func::FuncOp"> {
   let summary = "Inline scalar operands into linalg generic ops";
   let constructor = "mlir::createLinalgInlineScalarOperandsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect"
   ];
 }
 
-def LinalgLowerToAffineLoops : Pass<"convert-linalg-to-affine-loops", "func::FuncOp"> {
+def LinalgLowerToAffineLoopsPass : Pass<"convert-linalg-to-affine-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into affine "
                 "loops";
   let constructor = "mlir::createConvertLinalgToAffineLoopsPass()";
   let dependentDialects = [
     "AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
-def LinalgLowerToLoops : Pass<"convert-linalg-to-loops", "func::FuncOp"> {
+def LinalgLowerToLoopsPass : Pass<"convert-linalg-to-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into loops";
   let constructor = "mlir::createConvertLinalgToLoopsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect",
     "scf::SCFDialect",
     "AffineDialect"
   ];
 }
 
-def LinalgLowerToParallelLoops
+def LinalgLowerToParallelLoopsPass
     : Pass<"convert-linalg-to-parallel-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into parallel "
                 "loops";
   let constructor = "mlir::createConvertLinalgToParallelLoopsPass()";
   let dependentDialects = [
     "AffineDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
 }
 
-def LinalgBufferize : Pass<"linalg-bufferize", "func::FuncOp"> {
+def LinalgBufferizePass : Pass<"linalg-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the linalg dialect";
   let constructor = "mlir::createLinalgBufferizePass()";
   let dependentDialects = [
     "AffineDialect",
     "bufferization::BufferizationDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
   ];
 }
 
-def LinalgTiling : Pass<"linalg-tile", "func::FuncOp"> {
+def LinalgTilingPass : Pass<"linalg-tile", "func::FuncOp"> {
   let summary = "Tile operations in the linalg dialect";
   let constructor = "mlir::createLinalgTilingPass()";
   let dependentDialects = [
     "AffineDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
   let options = [
     ListOption<"tileSizes", "tile-sizes", "int64_t", "Tile sizes">,
     Option<"loopType", "loop-type", "std::string", /*default=*/"\"for\"",
            "Specify the type of loops to generate: for, parallel">
   ];
 }
 
-def LinalgGeneralization : Pass<"linalg-generalize-named-ops", "func::FuncOp"> {
+def LinalgGeneralizationPass : Pass<"linalg-generalize-named-ops", "func::FuncOp"> {
   let summary = "Convert named ops into generic ops";
   let constructor = "mlir::createLinalgGeneralizationPass()";
   let dependentDialects = ["linalg::LinalgDialect"];
 }
 
-def LinalgDetensorize : Pass<"linalg-detensorize", ""> {
+def LinalgDetensorizePass : Pass<"linalg-detensorize", ""> {
   let summary = "Detensorize linalg ops";
   let constructor = "mlir::createLinalgDetensorizePass()";
   let dependentDialects = [];
 
   let description = [{
     Detensoring is the process through which a tensor value is converted to one
     or potentially more primitive value(s). During this process, operations with
     such detensored operands are also converted to an equivalent form that works

mlir/include/mlir/Dialect/MemRef/Transforms/Passes.h

 /// }
 /// ```
 LogicalResult multiBuffer(memref::AllocOp allocOp, unsigned multiplier);
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
+#define GEN_PASS_DECL_EXPANDOPSPASS
+#define GEN_PASS_DECL_FOLDMEMREFALIASOPSPASS
+#define GEN_PASS_DECL_NORMALIZEMEMREFSPASS
+#define GEN_PASS_DECL_RESOLVERANKEDSHAPETYPERESULTDIMSPASS
+#define GEN_PASS_DECL_RESOLVESHAPEDTYPERESULTDIMSPASS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+
 /// Creates an instance of the ExpandOps pass that legalizes memref dialect ops
 /// to be convertible to LLVM. For example, `memref.reshape` gets converted to
 /// `memref_reinterpret_cast`.
 std::unique_ptr<Pass> createExpandOpsPass();
 
 /// Creates an operation pass to fold memref aliasing ops into consumer
 /// load/store ops into `patterns`.
 std::unique_ptr<Pass> createFoldMemRefAliasOpsPass();

mlir/include/mlir/Dialect/MemRef/Transforms/Passes.td

 //===-- Passes.td - MemRef transformation definition file --*- tablegen -*-===//
 //
 // 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_DIALECT_MEMREF_TRANSFORMS_PASSES
 #define MLIR_DIALECT_MEMREF_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def ExpandOps : Pass<"memref-expand"> {
+def ExpandOpsPass : Pass<"memref-expand"> {
   let summary = "Legalize memref operations to be convertible to LLVM.";
   let constructor = "mlir::memref::createExpandOpsPass()";
 }
 
-def FoldMemRefAliasOps : Pass<"fold-memref-alias-ops"> {
+def FoldMemRefAliasOpsPass : Pass<"fold-memref-alias-ops"> {
   let summary = "Fold memref alias ops into consumer load/store ops";
   let description = [{
     The pass folds loading/storing from/to memref aliasing ops to loading/storing
     from/to the original memref.
   }];
   let constructor = "mlir::memref::createFoldMemRefAliasOpsPass()";
   let dependentDialects = [
       "AffineDialect", "memref::MemRefDialect", "vector::VectorDialect"
   ];
 }
 
-def NormalizeMemRefs : Pass<"normalize-memrefs", "ModuleOp"> {
+def NormalizeMemRefsPass : Pass<"normalize-memrefs", "ModuleOp"> {
   let summary = "Normalize memrefs";
    let description = [{
     This pass transforms memref types with a non-trivial
     [layout map](https://mlir.llvm.org/docs/LangRef/#layout-map) into
     memref types with an identity layout map, e.g. (i, j) -> (i, j). This
     pass is inter-procedural, in the sense that it can modify function
     interfaces and call sites that pass memref types. In order to modify
     memref types while preserving the original behavior, users of those
let description = [{
     return
   }
   ```
   }];
   let constructor = "mlir::memref::createNormalizeMemRefsPass()";
   let dependentDialects = ["AffineDialect"];
 }
 
-def ResolveRankedShapeTypeResultDims :
+def ResolveRankedShapeTypeResultDimsPass :
     Pass<"resolve-ranked-shaped-type-result-dims"> {
   let summary = "Resolve memref.dim of result values of ranked shape type";
   let description = [{
     The pass resolves memref.dim of result of operations that
     implement the `ReifyRankedShapedTypeOpInterface` in terms of
     shapes of its operands.
   }];
   let constructor =
       "mlir::memref::createResolveRankedShapeTypeResultDimsPass()";
   let dependentDialects = [
     "memref::MemRefDialect", "tensor::TensorDialect"
   ];
 }
 
-def ResolveShapedTypeResultDims : Pass<"resolve-shaped-type-result-dims"> {
+def ResolveShapedTypeResultDimsPass : Pass<"resolve-shaped-type-result-dims"> {
   let summary = "Resolve memref.dim of result values";
   let description = [{
     The pass resolves memref.dim of result of operations that
     implement the `InferShapedTypeOpInterface` or
     `ReifyRankedShapedTypeOpInterface` in terms of shapes of its
     operands.
   }];
   let constructor = "mlir::memref::createResolveShapedTypeResultDimsPass()";
   let dependentDialects = [
     "AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
   ];
 }
 
 #endif // MLIR_DIALECT_MEMREF_TRANSFORMS_PASSES
 

mlir/include/mlir/Dialect/NVGPU/Passes.h

 #ifndef MLIR_DIALECT_NVGPU_PASSES_H_
 #define MLIR_DIALECT_NVGPU_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace nvgpu {
 
+#define GEN_PASS_DECL_OPTIMIZESHAREDMEMORYPASS
+#include "mlir/Dialect/NVGPU/Passes.h.inc"
+
 /// Create a pass to optimize shared memory reads and writes.
 std::unique_ptr<Pass> createOptimizeSharedMemoryPass();
 
 } // namespace nvgpu
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/NVGPU/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_NVGPU_PASSES_H_

mlir/include/mlir/Dialect/NVGPU/Passes.td

 //===-- Passes.td - NvGpu pass definition file ------------*- tablegen -*-===//
 //
 // 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_DIALECT_NVGPU_PASSES_TD_
 #define MLIR_DIALECT_NVGPU_PASSES_TD_
 
 include "mlir/Pass/PassBase.td"
 
-def OptimizeSharedMemory : Pass<"nvgpu-optimize-shared-memory"> {
+def OptimizeSharedMemoryPass : Pass<"nvgpu-optimize-shared-memory"> {
   let summary = "Optimizes accesses to shard memory memrefs in order to reduce bank conflicts.";
   let constructor = "mlir::nvgpu::createOptimizeSharedMemoryPass()";
   let dependentDialects = [
     "memref::MemRefDialect", "vector::VectorDialect"
   ];
 }
 
 #endif // MLIR_DIALECT_NVGPU_PASSES_TD_

mlir/include/mlir/Dialect/SCF/Transforms/Passes.h

 
 #ifndef MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
-/// Creates a pass that bufferizes the SCF dialect.
-std::unique_ptr<Pass> createSCFBufferizePass();
-
-/// Creates a pass that specializes for loop for unrolling and
-/// vectorization.
-std::unique_ptr<Pass> createForLoopSpecializationPass();
-
-/// Creates a pass that peels for loops at their upper bounds for
-/// better vectorization.
-std::unique_ptr<Pass> createForLoopPeelingPass();
-
-/// Creates a pass that canonicalizes affine.min and affine.max operations
-/// inside of scf.for loops with known lower and upper bounds.
-std::unique_ptr<Pass> createSCFForLoopCanonicalizationPass();
-
-/// Creates a pass that transforms a single ParallelLoop over N induction
-/// variables into another ParallelLoop over less than N induction variables.
-std::unique_ptr<Pass> createParallelLoopCollapsingPass();
-
-/// Creates a loop fusion pass which fuses parallel loops.
-std::unique_ptr<Pass> createParallelLoopFusionPass();
-
-/// Creates a pass that specializes parallel loop for unrolling and
-/// vectorization.
-std::unique_ptr<Pass> createParallelLoopSpecializationPass();
-
-/// Creates a pass which tiles innermost parallel loops.
-/// If noMinMaxBounds, the upper bound of the inner loop will
-/// be a same value among different outter loop iterations, and
-/// an additional inbound check will be emitted inside the internal
-/// loops.
-std::unique_ptr<Pass>
-createParallelLoopTilingPass(llvm::ArrayRef<int64_t> tileSize = {},
-                             bool noMinMaxBounds = false);
-
-/// Creates a pass which folds arith ops on induction variable into
-/// loop range.
-std::unique_ptr<Pass> createForLoopRangeFoldingPass();
-
-// Creates a pass which lowers for loops into while loops.
-std::unique_ptr<Pass> createForToWhileLoopPass();
+#define GEN_PASS_DECL_SCFBUFFERIZEPASS
+#define GEN_PASS_DECL_SCFFORLOOPCANONICALIZATIONPASS
+#define GEN_PASS_DECL_SCFFORLOOPPEELINGPASS
+#define GEN_PASS_DECL_SCFFORLOOPSPECIALIZATIONPASS
+#define GEN_PASS_DECL_SCFPARALLELLOOPFUSIONPASS
+#define GEN_PASS_DECL_SCFPARALLELLOOPCOLLAPSINGPASS
+#define GEN_PASS_DECL_SCFPARALLELLOOPSPECIALIZATIONPASS
+#define GEN_PASS_DECL_SCFPARALLELLOOPTILINGPASS
+#define GEN_PASS_DECL_SCFFORLOOPRANGEFOLDINGPASS
+#define GEN_PASS_DECL_SCFFORTOWHILELOOPPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SCF_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/SCF/Transforms/Passes.td

 //===-- Passes.td - SCF pass definition file ---------------*- tablegen -*-===//
 //
 // 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_DIALECT_SCF_PASSES
 #define MLIR_DIALECT_SCF_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def SCFBufferize : Pass<"scf-bufferize"> {
+def SCFBufferizePass : Pass<"scf-bufferize"> {
   let summary = "Bufferize the scf dialect.";
-  let constructor = "mlir::createSCFBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 
 // Note: Making these canonicalization patterns would require a dependency
 // of the SCF dialect on the Affine/Tensor/MemRef dialects or vice versa.
-def SCFForLoopCanonicalization
+def SCFForLoopCanonicalizationPass
     : Pass<"scf-for-loop-canonicalization"> {
   let summary = "Canonicalize operations within scf.for loop bodies";
-  let constructor = "mlir::createSCFForLoopCanonicalizationPass()";
+  let description = [{
+      Canonicalize `affine.min` and `affine.max` operations inside of `scf.for`
+      loops with known lower and upper bounds.
+  }];
   let dependentDialects = ["AffineDialect", "tensor::TensorDialect",
                            "memref::MemRefDialect"];
 }
 
-def SCFForLoopPeeling : Pass<"scf-for-loop-peeling"> {
+def SCFForLoopPeelingPass : Pass<"scf-for-loop-peeling"> {
   let summary = "Peel `for` loops at their upper bounds.";
-  let constructor = "mlir::createForLoopPeelingPass()";
+  let description = [{
+     Peel for loops at their upper bounds for better vectorization.
+  }];
   let options = [
     Option<"skipPartial", "skip-partial", "bool",
            /*default=*/"true",
            "Do not peel loops inside of the last, partial iteration of another "
            "already peeled loop.">
   ];
   let dependentDialects = ["AffineDialect"];
 }
 
-def SCFForLoopSpecialization : Pass<"scf-for-loop-specialization"> {
+def SCFForLoopSpecializationPass : Pass<"scf-for-loop-specialization"> {
   let summary = "Specialize `for` loops for vectorization";
-  let constructor = "mlir::createForLoopSpecializationPass()";
 }
 
-def SCFParallelLoopFusion : Pass<"scf-parallel-loop-fusion"> {
+def SCFParallelLoopFusionPass : Pass<"scf-parallel-loop-fusion"> {
   let summary = "Fuse adjacent parallel loops";
-  let constructor = "mlir::createParallelLoopFusionPass()";
 }
 
-def SCFParallelLoopCollapsing : Pass<"scf-parallel-loop-collapsing"> {
+def SCFParallelLoopCollapsingPass : Pass<"scf-parallel-loop-collapsing"> {
   let summary = "Collapse parallel loops to use less induction variables";
-  let constructor = "mlir::createParallelLoopCollapsingPass()";
+  let description = [{
+      Transforms a single `ParallelLoop` over N induction variables into
+      another `ParallelLoop` over less than N induction variables.
+  }];
   let options = [
     ListOption<"clCollapsedIndices0", "collapsed-indices-0", "unsigned",
                "Which loop indices to combine 0th loop index">,
     ListOption<"clCollapsedIndices1", "collapsed-indices-1", "unsigned",
                "Which loop indices to combine into the position 1 loop index">,
     ListOption<"clCollapsedIndices2", "collapsed-indices-2", "unsigned",
                "Which loop indices to combine into the position 2 loop index">,
   ];
 }
 
-def SCFParallelLoopSpecialization
+def SCFParallelLoopSpecializationPass
     : Pass<"scf-parallel-loop-specialization"> {
   let summary = "Specialize parallel loops for vectorization";
-  let constructor = "mlir::createParallelLoopSpecializationPass()";
+  let description = [{
+     Specialize parallel loop for unrolling and vectorization.
+  }];
 }
 
-def SCFParallelLoopTiling : Pass<"scf-parallel-loop-tiling"> {
+def SCFParallelLoopTilingPass : Pass<"scf-parallel-loop-tiling"> {
   let summary = "Tile parallel loops";
-  let constructor = "mlir::createParallelLoopTilingPass()";
+  let description = [{
+      Tile innermost parallel loops.
+      If `noMinMaxBounds`, the upper bound of the inner loop will be a same
+      value among different outter loop iterations, and an additional inbound
+      check will be emitted inside the internal loops.
+  }];
   let options = [
     ListOption<"tileSizes", "parallel-loop-tile-sizes", "int64_t",
                "Factors to tile parallel loops by">,
     Option<"noMinMaxBounds", "no-min-max-bounds", "bool",
            /*default=*/"false",
            "Perform tiling with fixed upper bound with inbound check "
            "inside the internal loops">
   ];
   let dependentDialects = ["AffineDialect"];
 }
 
-def SCFForLoopRangeFolding : Pass<"scf-for-loop-range-folding"> {
+def SCFForLoopRangeFoldingPass : Pass<"scf-for-loop-range-folding"> {
   let summary = "Fold add/mul ops into loop range";
-  let constructor = "mlir::createForLoopRangeFoldingPass()";
+  let description = [{
+      Fold arith ops on induction variable into loop range.
+  }];
 }
 
-def SCFForToWhileLoop : Pass<"scf-for-to-while"> {
+def SCFForToWhileLoopPass : Pass<"scf-for-to-while"> {
   let summary = "Convert SCF for loops to SCF while loops";
-  let constructor = "mlir::createForToWhileLoopPass()";
   let description = [{
     This pass transforms SCF.ForOp operations to SCF.WhileOp. The For loop
     condition is placed in the 'before' region of the while operation, and the
     induction variable incrementation and loop body in the 'after' region.
     The loop carried values of the while op are the induction variable (IV) of
     the for-loop + any iter_args specified for the for-loop.
     Any 'yield' ops in the for-loop are rewritten to additionally yield the
     (incremented) induction variable.

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h

 namespace spirv {
 
 class ModuleOp;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
+#define GEN_PASS_DECL_SPIRVDECORATECOMPOSITETYPELAYOUTPASS
+#define GEN_PASS_DECL_SPIRVCANONICALIZEGLPASS
+#define GEN_PASS_DECL_SPIRVLOWERABIATTRIBUTESPASS
+#define GEN_PASS_DECL_SPIRVREWRITEINSERTSPASS
+#define GEN_PASS_DECL_SPIRVUNIFYALIASEDRESOURCEPASS
+#define GEN_PASS_DECL_SPIRVUPDATEVCEPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+
 /// Creates a pass to run canoncalization patterns that involve GL ops.
 /// These patterns cannot be run in default canonicalization because GL ops
 /// aren't always available. So they should be involed specifically when needed.
 std::unique_ptr<OperationPass<>> createCanonicalizeGLPass();
 
 /// Creates a module pass that converts composite types used by objects in the
 /// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
 /// classes with layout information.

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td

 //===-- Passes.td - SPIRV pass definition file -------------*- tablegen -*-===//
 //
 // 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_DIALECT_SPIRV_TRANSFORMS_PASSES
 #define MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def SPIRVCompositeTypeLayout
-    : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
+def SPIRVDecorateCompositeTypeLayoutPass
+    : Pass<"decorate-spirv-composite-type-layout", "mlir::ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
   let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
 }
 
-def SPIRVCanonicalizeGL : Pass<"spirv-canonicalize-gl", ""> {
+def SPIRVCanonicalizeGLPass : Pass<"spirv-canonicalize-gl", ""> {
   let summary = "Run canonicalization involving GLSL ops";
   let constructor = "mlir::spirv::createCanonicalizeGLPass()";
 }
 
-def SPIRVLowerABIAttributes : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
+def SPIRVLowerABIAttributesPass : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
   let constructor = "mlir::spirv::createLowerABIAttributesPass()";
 }
 
 def SPIRVRewriteInsertsPass : Pass<"spirv-rewrite-inserts", "spirv::ModuleOp"> {
   let summary = "Rewrite sequential chains of spv.CompositeInsert operations into "
                 "spv.CompositeConstruct operations";
   let constructor = "mlir::spirv::createRewriteInsertsPass()";
 }
 
 def SPIRVUnifyAliasedResourcePass
     : Pass<"spirv-unify-aliased-resource", "spirv::ModuleOp"> {
   let summary = "Unify access of multiple aliased resources into access of one "
                 "single resource";
   let constructor = "mlir::spirv::createUnifyAliasedResourcePass()";
 }
 
-def SPIRVUpdateVCE : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
+def SPIRVUpdateVCEPass : Pass<"spirv-update-vce", "spirv::ModuleOp"> {
   let summary = "Deduce and attach minimal (version, capabilities, extensions) "
                 "requirements to spv.module ops";
   let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
 }
 
 #endif // MLIR_DIALECT_SPIRV_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

 class ConversionTarget;
 class TypeConverter;
 namespace func {
 class FuncOp;
 } // namespace func
 } // namespace mlir
 
 namespace mlir {
+
+#define GEN_PASS_DECL_SHAPETOSHAPELOWERINGPASS
+#define GEN_PASS_DECL_REMOVESHAPECONSTRAINTSPASS
+#define GEN_PASS_DECL_SHAPEBUFFERIZEPASS
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+
 /// Creates an instance of the ShapeToShapeLowering pass that legalizes Shape
 /// dialect to be convertible to Arithmetic. For example, `shape.num_elements`
 /// get transformed to `shape.reduce`, which can be lowered to SCF and
 /// Arithmetic.
 std::unique_ptr<Pass> createShapeToShapeLowering();
 
 /// Collects a set of patterns to rewrite ops within the Shape dialect.
 void populateShapeRewritePatterns(RewritePatternSet &patterns);

mlir/include/mlir/Dialect/Shape/Transforms/Passes.td

 //===-- Passes.td - ShapeOps pass definition file ----------*- tablegen -*-===//
 //
 // 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_DIALECT_SHAPE_TRANSFORMS_PASSES
 #define MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def RemoveShapeConstraints : Pass<"remove-shape-constraints", "func::FuncOp"> {
+def RemoveShapeConstraintsPass : Pass<"remove-shape-constraints", "func::FuncOp"> {
   let summary = "Replace all cstr_ ops with a true witness";
   let constructor = "mlir::createRemoveShapeConstraintsPass()";
 }
 
-def ShapeToShapeLowering : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
+def ShapeToShapeLoweringPass : Pass<"shape-to-shape-lowering", "func::FuncOp"> {
   let summary = "Legalize Shape dialect to be convertible to Arithmetic";
   let constructor = "mlir::createShapeToShapeLowering()";
 }
 
 // TODO: Generalize this to allow any type conversions desired.
-def ShapeBufferize : Pass<"shape-bufferize", "func::FuncOp"> {
+def ShapeBufferizePass : Pass<"shape-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the shape dialect.";
   let constructor = "mlir::createShapeBufferizePass()";
   let dependentDialects = ["bufferization::BufferizationDialect",
                            "memref::MemRefDialect"];
 }
 #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.h

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 namespace bufferization {
 struct OneShotBufferizationOptions;
 } // namespace bufferization
 
+#define GEN_PASS_DECL_SPARSIFICATIONPASS
+#define GEN_PASS_DECL_SPARSETENSORCONVERSIONPASS
+#define GEN_PASS_DECL_SPARSETENSORCODEGENPASS
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+
 //===----------------------------------------------------------------------===//
 // The Sparsification pass.
 //===----------------------------------------------------------------------===//
 
 /// Defines a parallelization strategy. Any independent loop is a candidate
 /// for parallelization. The loop is made parallel if (1) allowed by the
 /// strategy (e.g., AnyStorageOuterLoop considers either a dense or sparse
 /// outermost loop only), and (2) the generated code is an actual for-loop

mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.td

 //===-- Passes.td - Sparse tensor pass definition file -----*- tablegen -*-===//
 //
 // 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_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES
 #define MLIR_DIALECT_SPARSETENSOR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def Sparsification : Pass<"sparsification", "ModuleOp"> {
+def SparsificationPass : Pass<"sparsification", "ModuleOp"> {
   let summary = "Automatically generate sparse tensor code from sparse tensor types";
   let description = [{
     A pass that implements the core functionality of a **sparse compiler**.
     Each Linalg operation (MLIR's tensor index notation) that operates on
     sparse tensor types is converted into code in which the sparsity is
     explicit both in terms of co-iterating looping logic as well as
     selected sparse storage schemes.
 
Option<"vectorLength", "vl", "int32_t", "1",
            "Set the vector length">,
     Option<"enableSIMDIndex32", "enable-simd-index32", "bool", "false",
            "Enable i32 indexing into vectors (for efficiency)">,
     Option<"enableVLAVectorization", "enable-vla-vectorization", "bool",
            "false", "Enable vector length agnostic vectorization">
   ];
 }
 
-def SparseTensorConversion : Pass<"sparse-tensor-conversion", "ModuleOp"> {
+def SparseTensorConversionPass : Pass<"sparse-tensor-conversion", "ModuleOp"> {
   let summary = "Convert sparse tensors and primitives to library calls";
   let description = [{
     A pass that converts sparse tensor primitives into calls into a runtime
     support library. Sparse tensor types are converted into opaque pointers
     to the underlying sparse storage schemes.
 
     The use of opaque pointers together with runtime support library keeps
     the conversion relatively simple, but at the expense of IR opacity,
let dependentDialects = [
     "vector::VectorDialect",
   ];
   let options = [
     Option<"sparseToSparse", "s2s-strategy", "int32_t", "0",
            "Set the strategy for sparse-to-sparse conversion">,
   ];
 }
 
-def SparseTensorCodegen : Pass<"sparse-tensor-codegen", "ModuleOp"> {
+def SparseTensorCodegenPass : Pass<"sparse-tensor-codegen", "ModuleOp"> {
   let summary = "Convert sparse tensors and primitives to actual code";
   let description = [{
     A pass that converts sparse tensor types and primitives to actual
     compiler visible buffers and compiler IR that implements these
     primitives on the selected sparse tensor storage schemes.
 
     This pass provides an alternative to the SparseTensorConversion pass,
     eliminating the dependence on a runtime support library, and providing

mlir/include/mlir/Dialect/Tensor/Transforms/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- 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_DIALECT_TENSOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-/// Creates an instance of `tensor` dialect bufferization pass.
-std::unique_ptr<Pass> createTensorBufferizePass();
+namespace tensor {
+
+#define GEN_PASS_DECL_TENSORBUFFERIZEPASS
+#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
-namespace tensor {
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
 } // namespace tensor
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/Tensor/Transforms/Passes.td

 //===-- Passes.td - pass definition file -------------------*- tablegen -*-===//
 //
 // 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_DIALECT_TENSOR_TRANSFORMS_PASSES
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def TensorBufferize : Pass<"tensor-bufferize", "func::FuncOp"> {
+def TensorBufferizePass : Pass<"tensor-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the `tensor` dialect";
-  let constructor = "mlir::createTensorBufferizePass()";
 }
 
 #endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Tosa/Transforms/PassDetail.h

-//===- PassDetail.h - TOSA Pass class details -------------------*- 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_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H
-#define MLIR_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Dialect/Tensor/IR/Tensor.h"
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H

mlir/include/mlir/Dialect/Tosa/Transforms/Passes.h

 #define MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H
 
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace tosa {
 
+#define GEN_PASS_DECL_TOSALAYERWISECONSTANTFOLDPASS
+#define GEN_PASS_DECL_TOSAINFERSHAPESPASS
+#define GEN_PASS_DECL_TOSAMAKEBROADCASTABLEPASS
+#define GEN_PASS_DECL_TOSAOPTIONALDECOMPOSITIONSPASS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+
 // Expose Rewrite Functions that decompose TOSA Ops into further TOSA Ops.
 // The rewrites can be selectively added to a conversion pass.
 void populateTosaDecomposeConv2D(MLIRContext *ctx, RewritePatternSet &patterns);
 void populateTosaDecomposeTransposeConv(MLIRContext *ctx,
                                         RewritePatternSet &patterns);
 void populateTosaDecomposeDepthwise(MLIRContext *ctx,
                                     RewritePatternSet &patterns);
 void populateTosaFoldConstantTransposePatterns(MLIRContext *ctx,
                                                RewritePatternSet &patterns);
 
-std::unique_ptr<Pass> createTosaLayerwiseConstantFoldPass();
-std::unique_ptr<Pass> createTosaInferShapesPass();
-std::unique_ptr<Pass> createTosaMakeBroadcastablePass();
-std::unique_ptr<Pass> createTosaTestQuantUtilAPIPass();
-std::unique_ptr<Pass> createTosaOptionalDecompositions();
-
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Tosa/Transforms/Passes.td

 
 include "mlir/Pass/PassBase.td"
 
 def TosaLayerwiseConstantFoldPass : Pass<"tosa-layerwise-constant-fold", "func::FuncOp"> {
   let summary = "Fold layerwise operations on constant tensors";
   let description = [{
     Pass that enables folding of full-layer operations on constant tensors.
   }];
-
-  let constructor = "createTosaLayerwiseConstantFoldPass()";
 }
 
-def TosaInferShapes : Pass<"tosa-infer-shapes", "func::FuncOp"> {
+def TosaInferShapesPass : Pass<"tosa-infer-shapes", "func::FuncOp"> {
   let summary = "Propagate shapes across TOSA operations";
   let description = [{
     Pass that uses operand types and propagates shapes to TOSA operations.
     This includes legalizing rankless and dynamic shapes towards static.
   }];
-
-  let constructor = "createTosaInferShapesPass()";
   let dependentDialects = [
     "func::FuncDialect",
     "tensor::TensorDialect",
     "tosa::TosaDialect",
   ];
 }
 
-def TosaMakeBroadcastable : Pass<"tosa-make-broadcastable", "func::FuncOp"> {
+def TosaMakeBroadcastablePass : Pass<"tosa-make-broadcastable", "func::FuncOp"> {
   let summary = "TOSA rank Reshape to enable Broadcasting";
   let description = [{
     Pass that enables broadcast by making all input arrays have the same
     number of dimensions. Insert RESHAPE operations to prepend dimensions
     of size one until the number of dimensions is equal. Implements
     approach similar to step 1 of Numpy 4-step broadcasting:
     https://numpy.org/doc/stable/reference/ufuncs.html#broadcasting
   }];
-
-  let constructor = "createTosaMakeBroadcastablePass()";
 }
 
-def TosaOptionalDecompositions
+def TosaOptionalDecompositionsPass
   : Pass<"tosa-optional-decompositions", "func::FuncOp"> {
   let summary = "Applies Tosa operations optional decompositions";
   let description = [{
     Pass to apply the Tosa operations decompositions 
     exposed as populate functions in include/mlir/Dialect/Tosa/Transforms/Passes.h
   }];
-
-  let constructor = "tosa::createTosaOptionalDecompositions()";
 }
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Transform/Transforms/Passes.h

 
 #include "mlir/Pass/Pass.h"
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace transform {
-std::unique_ptr<Pass> createCheckUsesPass();
+#define GEN_PASS_DECL_CHECKUSESPASS
+#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
 } // namespace transform
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Transform/Transforms/Passes.td

 //===-- Passes.td - Transform dialect pass definitions -----*- tablegen -*-===//
 //
 // 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_DIALECT_TRANSFORM_TRANSFORMS_PASSES
 #define MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def CheckUses : Pass<"transform-dialect-check-uses"> {
+def CheckUsesPass : Pass<"transform-dialect-check-uses"> {
   let summary = "warn about potential use-after-free in the transform dialect";
   let description = [{
     This pass analyzes operations from the transform dialect and its extensions
     and warns if a transform IR value may be used by an operation after it was
     "freed" by some other operation, as described by side effects on the
     `TransformMappingResource`. This statically detects situations that lead to
     errors when interpreting the Transform IR.
 
     The pass is capable of handling branching control flow and reports all
     _potential_ use-after-free situations, e.g., a may-use-after-free is
     reported if at least one of the control flow paths between the definition of
     a value and its use contains an operation with a "free" effect on the
     `TransformMappingResource`. It does not currently perform an SCCP-style data
     flow analysis to prove that some branches are not taken, however, SCCP and
     other control flow simplifications can be performed on the transform IR
     prior to this pass provided that transform ops implement the relevant
     control flow interfaces.
   }];
-  let constructor = "::mlir::transform::createCheckUsesPass()";
 }
 
 #endif // MLIR_DIALECT_TRANSFORM_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Vector/Transforms/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- 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_DIALECT_VECTOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace vector {
-/// Creates an instance of the `vector` dialect bufferization pass.
-std::unique_ptr<Pass> createVectorBufferizePass();
+#define GEN_PASS_DECL_VECTORBUFFERIZEPASS
+#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
 } // namespace vector
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/Vector/Transforms/Passes.td

 //===-- Passes.td - Vector pass definition file ------------*- tablegen -*-===//
 //
 // 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_DIALECT_VECTOR_TRANSFORMS_PASSES
 #define MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def VectorBufferize : Pass<"vector-bufferize", "func::FuncOp"> {
+def VectorBufferizePass : Pass<"vector-bufferize", "func::FuncOp"> {
   let summary = "Bufferize Vector dialect ops";
-  let constructor = "mlir::vector::createVectorBufferizePass()";
 }
 
 #endif // MLIR_DIALECT_VECTOR_TRANSFORMS_PASSES

mlir/include/mlir/Reducer/PassDetail.h

-//===- PassDetail.h - Reducer Pass class details ----------------*- 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_REDUCER_PASSDETAIL_H
-#define MLIR_REDUCER_PASSDETAIL_H
-
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-#define GEN_PASS_CLASSES
-#include "mlir/Reducer/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // MLIR_REDUCER_PASSDETAIL_H

mlir/include/mlir/Reducer/Passes.h

 //===- Passes.h - Reducer Pass Construction and Registration ----*- 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_REDUCER_PASSES_H
 #define MLIR_REDUCER_PASSES_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
+#define GEN_PASS_DECL_REDUCTIONTREEPASS
+#define GEN_PASS_DECL_OPTREDUCTIONPASS
+#include "mlir/Reducer/Passes.h.inc"
+
 std::unique_ptr<Pass> createReductionTreePass();
 
 std::unique_ptr<Pass> createOptReductionPass();
 
 /// Generate the code for registering reducer passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Reducer/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_REDUCER_PASSES_H

mlir/include/mlir/Reducer/Passes.td

def CommonReductionPassOptions {
   list<Option> options = [
     Option<"testerName", "test", "std::string", /* default */"",
            "The location of the tester which tests the file interestingness">,
     ListOption<"testerArgs", "test-arg", "std::string",
                "arguments of the tester">,
   ];
 }
 
-def ReductionTree : Pass<"reduction-tree"> {
+def ReductionTreePass : Pass<"reduction-tree"> {
   let summary = "Reduce the input with reduction-tree algorithm";
 
   let constructor = "mlir::createReductionTreePass()";
 
   let options = [
     Option<"traversalModeId", "traversal-mode", "unsigned",
            /* default */"0",
            "The graph traversal mode, the default is single-path mode">,
   ] # CommonReductionPassOptions.options;
 }
 
-def OptReduction : Pass<"opt-reduction-pass", "ModuleOp"> {
+def OptReductionPass : Pass<"opt-reduction-pass", "ModuleOp"> {
   let summary = "A wrapper pass that reduces the file with optimization passes";
 
   let constructor = "mlir::createOptReductionPass()";
 
   let options = [
     Option<"optPass", "opt-pass", "std::string", /* default */"",
            "The optimization passes used for reduction, e.g., symbol-dce">,
   ] # CommonReductionPassOptions.options;
 }
 
 #endif // MLIR_REDUCER_PASSES

mlir/include/mlir/Transforms/LocationSnapshot.h

 
 namespace mlir {
 class Location;
 struct LogicalResult;
 class Operation;
 class OpPrintingFlags;
 class Pass;
 
+#define GEN_PASS_DECL_LOCATIONSNAPSHOTPASS
+#include "mlir/Transforms/Passes.h.inc"
+
 /// This function generates new locations from the given IR by snapshotting the
 /// IR to the given stream, and using the printed locations within that stream.
 /// The generated locations replace the current operation locations.
 void generateLocationsFromIR(raw_ostream &os, StringRef fileName, Operation *op,
                              OpPrintingFlags flags);
 /// This function generates new locations from the given IR by snapshotting the
 /// IR to the given file, and using the printed locations within that file. If
 /// `filename` is empty, a temporary file is generated instead.

mlir/include/mlir/Transforms/Passes.h

 namespace mlir {
 
 class GreedyRewriteConfig;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
+#define GEN_PASS_DECL_CANONICALIZERPASS
+#define GEN_PASS_DECL_CONTROLFLOWSINKPASS
+#define GEN_PASS_DECL_CSEPASS
+#define GEN_PASS_DECL_LOOPINVARIANTCODEMOTIONPASS
+#define GEN_PASS_DECL_STRIPDEBUGINFOPASS
+#define GEN_PASS_DECL_PRINTOPSTATSPASS
+#define GEN_PASS_DECL_INLINERPASS
+#define GEN_PASS_DECL_SCCPPASS
+#define GEN_PASS_DECL_SYMBOLDCEPASS
+#define GEN_PASS_DECL_SYMBOLPRIVATIZEPASS
+#define GEN_PASS_DECL_TOPOLOGICALSORTPASS
+#include "mlir/Transforms/Passes.h.inc"
+
 /// Creates an instance of the Canonicalizer pass, configured with default
 /// settings (which can be overridden by pass options on the command line).
 std::unique_ptr<Pass> createCanonicalizerPass();
 
 /// Creates an instance of the Canonicalizer pass with the specified config.
 /// `disabledPatterns` is a set of labels used to filter out input patterns with
 /// a debug label or debug name in this set. `enabledPatterns` is a set of
 /// labels used to filter out input patterns that do not have one of the labels
 /// in this set. Debug labels must be set explicitly on patterns or when adding
 /// them with `RewritePatternSet::addWithLabel`. Debug names may be empty, but
 /// patterns created with `RewritePattern::create` have their default debug name
 /// set to their type name.
 std::unique_ptr<Pass>
 createCanonicalizerPass(const GreedyRewriteConfig &config,
                         ArrayRef<std::string> disabledPatterns = llvm::None,
                         ArrayRef<std::string> enabledPatterns = llvm::None);
 
-/// Creates a pass to perform control-flow sinking.
-std::unique_ptr<Pass> createControlFlowSinkPass();
-
-/// Creates a pass to perform common sub expression elimination.
-std::unique_ptr<Pass> createCSEPass();
-
-/// Creates a loop invariant code motion pass that hoists loop invariant
-/// instructions out of the loop.
-std::unique_ptr<Pass> createLoopInvariantCodeMotionPass();
-
-/// Creates a pass to strip debug information from a function.
-std::unique_ptr<Pass> createStripDebugInfoPass();
-
 /// Creates a pass which prints the list of ops and the number of occurrences in
 /// the module.
 std::unique_ptr<Pass> createPrintOpStatsPass(raw_ostream &os = llvm::errs());
 
 /// Creates a pass which prints the list of ops and the number of occurrences in
 /// the module with the output format option.
 std::unique_ptr<Pass> createPrintOpStatsPass(raw_ostream &os, bool printAsJSON);
 

 /// Creates an instance of the inliner pass, and use the provided pass managers
 /// when optimizing callable operations with names matching the key type.
 /// Callable operations with a name not within the provided map will use the
 /// provided default pipeline builder.
 std::unique_ptr<Pass>
 createInlinerPass(llvm::StringMap<OpPassManager> opPipelines,
                   std::function<void(OpPassManager &)> defaultPipelineBuilder);
 
-/// Creates a pass which performs sparse conditional constant propagation over
-/// nested operations.
-std::unique_ptr<Pass> createSCCPPass();
-
-/// Creates a pass which delete symbol operations that are unreachable. This
-/// pass may *only* be scheduled on an operation that defines a SymbolTable.
-std::unique_ptr<Pass> createSymbolDCEPass();
-
 /// Creates a pass which marks top-level symbol operations as `private` unless
 /// listed in `excludeSymbols`.
 std::unique_ptr<Pass>
 createSymbolPrivatizePass(ArrayRef<std::string> excludeSymbols = {});
 
-/// Creates a pass that recursively sorts nested regions without SSA dominance
-/// topologically such that, as much as possible, users of values appear after
-/// their producers.
-std::unique_ptr<Pass> createTopologicalSortPass();
-
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Transforms/Passes.h.inc"
 
 } // namespace mlir
 
 #endif // MLIR_TRANSFORMS_PASSES_H

mlir/include/mlir/Transforms/Passes.td

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TRANSFORMS_PASSES
 #define MLIR_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 include "mlir/Rewrite/PassUtil.td"
 
-def Canonicalizer : Pass<"canonicalize"> {
+def CanonicalizerPass : Pass<"canonicalize"> {
   let summary = "Canonicalize operations";
   let description = [{
     This pass performs various types of canonicalizations over a set of
     operations. See [Operation Canonicalization](Canonicalization.md) for more
     details.
   }];
   let constructor = "mlir::createCanonicalizerPass()";
   let options = [
     Option<"topDownProcessingEnabled", "top-down", "bool",
            /*default=*/"true",
            "Seed the worklist in general top-down order">,
     Option<"enableRegionSimplification", "region-simplify", "bool",
            /*default=*/"true",
            "Seed the worklist in general top-down order">,
     Option<"maxIterations", "max-iterations", "int64_t",
            /*default=*/"10",
            "Seed the worklist in general top-down order">
   ] # RewritePassUtils.options;
 }
 
-def ControlFlowSink : Pass<"control-flow-sink"> {
+def ControlFlowSinkPass : Pass<"control-flow-sink"> {
   let summary = "Sink operations into conditional blocks";
   let description = [{
     This pass implements control-flow sink on operations that implement
     `RegionBranchOpInterface` by moving dominating operations whose only uses
     are in a conditionally-executed regions into those regions so that
     executions paths where their results are not needed do not perform
     unnecessary computations.
 
     This is similar (but opposite) to loop-invariant code motion, which hoists
     operations out of regions executed more than once. The implementation of
     control-flow sink uses a simple and conversative cost model: operations are
     never duplicated and are only moved into singly-executed regions.
 
     It is recommended to run canonicalization first to remove unreachable
     blocks: ops in unreachable blocks may prevent other operations from being
     sunk as they may contain uses of their results
   }];
-  let constructor = "::mlir::createControlFlowSinkPass()";
   let statistics = [
     Statistic<"numSunk", "num-sunk", "Number of operations sunk">,
   ];
 }
 
-def CSE : Pass<"cse"> {
+def CSEPass : Pass<"cse"> {
   let summary = "Eliminate common sub-expressions";
   let description = [{
     This pass implements a generalized algorithm for common sub-expression
     elimination. This pass relies on information provided by the
     `Memory SideEffect` interface to identify when it is safe to eliminate
     operations. See [Common subexpression elimination](https://en.wikipedia.org/wiki/Common_subexpression_elimination)
     for more general details on this optimization.
   }];
-  let constructor = "mlir::createCSEPass()";
   let statistics = [
     Statistic<"numCSE", "num-cse'd", "Number of operations CSE'd">,
     Statistic<"numDCE", "num-dce'd", "Number of operations DCE'd">
   ];
 }
 
-def Inliner : Pass<"inline"> {
+def InlinerPass : Pass<"inline"> {
   let summary = "Inline function calls";
   let constructor = "mlir::createInlinerPass()";
   let options = [
     Option<"defaultPipelineStr", "default-pipeline", "std::string",
            /*default=*/"", "The default optimizer pipeline used for callables">,
     ListOption<"opPipelineList", "op-pipelines", "OpPassManager",
                "Callable operation specific optimizer pipelines (in the form "
                "of `dialect.op(pipeline)`)">,
     Option<"maxInliningIterations", "max-iterations", "unsigned",
            /*default=*/"4",
            "Maximum number of iterations when inlining within an SCC">,
   ];
 }
 
-def LocationSnapshot : Pass<"snapshot-op-locations"> {
+def LocationSnapshotPass : Pass<"snapshot-op-locations"> {
   let summary = "Generate new locations from the current IR";
   let description = [{
     This pass allows for generating new locations from the IR during any stage
     of compilation, by snapshotting the IR to a file and using that file to
     generate new locations for the operations.
 
     Depending on the value of the `tag` option, different resulting locations
     may be generated:
let options = [
     Option<"fileName", "filename", "std::string", /*default=*/"",
            "The filename to print the generated IR">,
     Option<"tag", "tag", "std::string", /*default=*/"",
            "A tag to use when fusing the new locations with the "
            "original. If unset, the locations are replaced.">,
   ];
 }
 
-def LoopInvariantCodeMotion : Pass<"loop-invariant-code-motion"> {
+def LoopInvariantCodeMotionPass : Pass<"loop-invariant-code-motion"> {
   let summary = "Hoist loop invariant instructions outside of the loop";
-  let constructor = "mlir::createLoopInvariantCodeMotionPass()";
 }
 
-def PrintOpStats : Pass<"print-op-stats"> {
+def PrintOpStatsPass : Pass<"print-op-stats"> {
   let summary = "Print statistics of operations";
   let constructor = "mlir::createPrintOpStatsPass()";
   let options = [
     Option<"printAsJSON", "json", "bool", /*default=*/"false",
            "print the stats as JSON">
   ];
 }
 
-def SCCP : Pass<"sccp"> {
+def SCCPPass : Pass<"sccp"> {
   let summary = "Sparse Conditional Constant Propagation";
   let description = [{
     This pass implements a general algorithm for sparse conditional constant
     propagation. This algorithm detects values that are known to be constant and
     optimistically propagates this throughout the IR. Any values proven to be
     constant are replaced, and removed if possible.
 
     This implementation is based on the algorithm described by Wegman and Zadeck
     in [“Constant Propagation with Conditional Branches”](https://dl.acm.org/doi/10.1145/103135.103136) (1991).
   }];
-  let constructor = "mlir::createSCCPPass()";
 }
 
-def StripDebugInfo : Pass<"strip-debuginfo"> {
+def StripDebugInfoPass : Pass<"strip-debuginfo"> {
   let summary = "Strip debug info from all operations";
   let description = [{
     This pass strips the IR of any location information, by replacing all
     operation locations with [`unknown`](Diagnostics.md#unknown-location).
   }];
-  let constructor = "mlir::createStripDebugInfoPass()";
 }
 
-def SymbolDCE : Pass<"symbol-dce"> {
+def SymbolDCEPass : Pass<"symbol-dce"> {
   let summary = "Eliminate dead symbols";
   let description = [{
     This pass deletes all symbols that are found to be unreachable. This is done
     by computing the set of operations that are known to be live, propagating
     that liveness to other symbols, and then deleting all symbols that are not
     within this live set. Live symbols are those that have a
     [visibility](SymbolsAndSymbolTables.md#symbol-visibility) that extends
     beyond the IR, e.g. `public`, or those that are referenced by live symbols
let description = [{
     func.func public @public_function() {
       "foo.return"() {uses = [@live_private_function]} : () -> ()
     }
     ```
 
     See [Symbols and SymbolTables](SymbolsAndSymbolTables.md) for more
     information on `Symbols`.
   }];
-  let constructor = "mlir::createSymbolDCEPass()";
 
   let statistics = [
     Statistic<"numDCE", "num-dce'd", "Number of symbols DCE'd">,
   ];
 }
 
-def SymbolPrivatize : Pass<"symbol-privatize"> {
+def SymbolPrivatizePass : Pass<"symbol-privatize"> {
   let summary = "Mark symbols private";
   let description = [{
     This pass marks all top-level symbols of the operation run as `private`
     except if listed in `exclude` pass option.
   }];
   let options = [
     ListOption<"exclude", "exclude", "std::string",
        "Comma separated list of symbols that should not be marked private">
   ];
   let constructor = "mlir::createSymbolPrivatizePass()";
 }
 
-def ViewOpGraph : Pass<"view-op-graph"> {
+def ViewOpGraphPass : Pass<"view-op-graph"> {
   let summary = "Print Graphviz visualization of an operation";
   let description = [{
     This pass prints a Graphviz graph of a module.
 
     - Operations are represented as nodes;
     - Uses (data flow) as edges;
     - Control flow as dashed edges;
     - Regions/blocks as subgraphs.
Option<"printAttrs", "print-attrs", "bool",
            /*default=*/"true", "Print attributes of operations">,
     Option<"printControlFlowEdges", "print-control-flow-edges", "bool",
            /*default=*/"false", "Print control flow edges">,
     Option<"printDataFlowEdges", "print-data-flow-edges", "bool",
            /*default=*/"true", "Print data flow edges">,
     Option<"printResultTypes", "print-result-types", "bool",
             /*default=*/"true", "Print result types of operations">
   ];
-  let constructor = "mlir::createPrintOpGraphPass()";
+  let constructor = "mlir::createViewOpGraphPass()";
 }
 
-def TopologicalSort : Pass<"topological-sort"> {
+def TopologicalSortPass : Pass<"topological-sort"> {
   let summary = "Sort regions without SSA dominance in topological order";
   let description = [{
     Recursively sorts all nested regions without SSA dominance in topological
     order. The main purpose is readability, as well as potentially processing of
     certain transformations and analyses. The function sorts the operations in
     all nested regions such that, as much as possible, all users appear after
     their producers.
 
     This sort is stable. If the block is already topologically sorted, the IR
     is not changed. Operations that form a cycle are moved to the end of the
     regions in a stable order.
   }];
-
-  let constructor = "mlir::createTopologicalSortPass()";
 }
 
 #endif // MLIR_TRANSFORMS_PASSES

mlir/include/mlir/Transforms/ViewOpGraph.h

 #define MLIR_TRANSFORMS_VIEWOPGRAPH_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 class Pass;
 
+#define GEN_PASS_DECL_VIEWOPGRAPHPASS
+#include "mlir/Transforms/Passes.h.inc"
+
 /// Creates a pass to print op graphs.
-std::unique_ptr<Pass> createPrintOpGraphPass(raw_ostream &os = llvm::errs());
+std::unique_ptr<Pass> createViewOpGraphPass(raw_ostream &os = llvm::errs());
 
 } // namespace mlir
 
 #endif // MLIR_TRANSFORMS_VIEWOPGRAPH_H_

mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp

 //===- AMDGPUToROCDL.cpp - AMDGPU to ROCDL dialect conversion -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/AMDGPU/AMDGPUDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTAMDGPUTOROCDLPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::amdgpu;
 
 static Value createI32Constant(ConversionPatternRewriter &rewriter,
                                Location loc, int32_t value) {
   Type llvmI32 = rewriter.getI32Type();
   return rewriter.create<LLVM::ConstantOp>(loc, llvmI32, value);
rewriter.replaceOpWithNewOp<LLVM::InlineAsmOp>(
         /*asm_string=*/asmStr, constraints, /*has_side_effects=*/true,
         /*is_align_stack=*/false, /*asm_dialect=*/asmDialectAttr,
         /*operand_attrs=*/ArrayAttr());
     return success();
   }
 };
 
 struct ConvertAMDGPUToROCDLPass
-    : public ConvertAMDGPUToROCDLBase<ConvertAMDGPUToROCDLPass> {
-  ConvertAMDGPUToROCDLPass() = default;
+    : public impl::ConvertAMDGPUToROCDLPassBase<ConvertAMDGPUToROCDLPass> {
+  using ConvertAMDGPUToROCDLPassBase::ConvertAMDGPUToROCDLPassBase;
 
   void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     FailureOr<Chipset> maybeChipset = Chipset::parse(chipset);
     if (failed(maybeChipset)) {
       emitError(UnknownLoc::get(ctx), "Invalid chipset name: " + chipset);
       return signalPassFailure();
     }
void mlir::populateAMDGPUToROCDLConversionPatterns(LLVMTypeConverter &converter,
                                                    Chipset chipset) {
   patterns.add<LDSBarrierOpLowering>(converter);
   patterns.add<
       RawBufferOpLowering<RawBufferLoadOp, ROCDL::RawBufferLoadOp>,
       RawBufferOpLowering<RawBufferStoreOp, ROCDL::RawBufferStoreOp>,
       RawBufferOpLowering<RawBufferAtomicFaddOp, ROCDL::RawBufferAtomicFAddOp>>(
       converter, chipset);
 }
-
-std::unique_ptr<Pass> mlir::createConvertAMDGPUToROCDLPass() {
-  return std::make_unique<ConvertAMDGPUToROCDLPass>();
-}

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 //===- AffineToStandard.cpp - Lower affine constructs to primitives -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file lowers affine constructs (If and For statements, AffineApply
 // operations) within a function into their standard If and For equivalent ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
-#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTAFFINETOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::vector;
 
 /// Given a range of values, emit the code that reduces them with "min" or "max"
 /// depending on the provided comparison predicate.  The predicate defines which
 /// comparison to perform, "lt" for "min", "gt" for "max" and is used for the
 /// `cmpi` operation followed by the `select` operation:
 ///
void mlir::populateAffineToVectorConversionPatterns(
   // clang-format off
   patterns.add<
       AffineVectorLoadLowering,
       AffineVectorStoreLowering>(patterns.getContext());
   // clang-format on
 }
 
 namespace {
-class LowerAffinePass : public ConvertAffineToStandardBase<LowerAffinePass> {
+class ConvertAffineToStandardPass : public impl::ConvertAffineToStandardPassBase<ConvertAffineToStandardPass> {
+  using ConvertAffineToStandardPassBase::ConvertAffineToStandardPassBase;
+
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateAffineToStdConversionPatterns(patterns);
     populateAffineToVectorConversionPatterns(patterns);
     ConversionTarget target(getContext());
     target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect,
                            scf::SCFDialect, VectorDialect>();
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-/// Lowers If and For operations within a function into their lower level CFG
-/// equivalent blocks.
-std::unique_ptr<Pass> mlir::createLowerAffinePass() {
-  return std::make_unique<LowerAffinePass>();
-}

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 //===- ArithmeticToLLVM.cpp - Arithmetic to LLVM dialect conversion -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/TypeUtilities.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTARITHMETICTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 //===----------------------------------------------------------------------===//
 // Straightforward Op Lowerings
 //===----------------------------------------------------------------------===//

 }
 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertArithmeticToLLVMPass
-    : public ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
-  ConvertArithmeticToLLVMPass() = default;
+    : public impl::ConvertArithmeticToLLVMPassBase<ConvertArithmeticToLLVMPass> {
+  using ConvertArithmeticToLLVMPassBase::ConvertArithmeticToLLVMPassBase;
 
   void runOnOperation() override {
     LLVMConversionTarget target(getContext());
     RewritePatternSet patterns(&getContext());
 
     LowerToLLVMOptions options(&getContext());
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
patterns.add<
     SubIOpLowering,
     TruncFOpLowering,
     TruncIOpLowering,
     UIToFPOpLowering,
     XOrIOpLowering
   >(converter);
   // clang-format on
 }
-
-std::unique_ptr<Pass> mlir::arith::createConvertArithmeticToLLVMPass() {
-  return std::make_unique<ConvertArithmeticToLLVMPass>();
-}

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

 //===- ArithmeticToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
-#include "../PassDetail.h"
+
 #include "../SPIRVCommon/Pattern.h"
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTARITHMETICTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "arith-to-spirv-pattern"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Operation Conversion
 //===----------------------------------------------------------------------===//
 

 }
 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertArithmeticToSPIRVPass
-    : public ConvertArithmeticToSPIRVBase<ConvertArithmeticToSPIRVPass> {
+    : public impl::ConvertArithmeticToSPIRVPassBase<ConvertArithmeticToSPIRVPass> {
+  using ConvertArithmeticToSPIRVPassBase::ConvertArithmeticToSPIRVPassBase;
+
   void runOnOperation() override {
     Operation *op = getOperation();
     auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
     auto target = SPIRVConversionTarget::get(targetAttr);
 
     SPIRVTypeConverter::Options options;
     options.emulateNon32BitScalarTypes = this->emulateNon32BitScalarTypes;
     SPIRVTypeConverter typeConverter(targetAttr, options);
void runOnOperation() override {
 
     if (failed(applyPartialConversion(op, *target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<>>
-mlir::arith::createConvertArithmeticToSPIRVPass() {
+mlir::createConvertArithmeticToSPIRVPass() {
   return std::make_unique<ConvertArithmeticToSPIRVPass>();
 }

mlir/lib/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.cpp

 //===- ArmNeon2dToIntr.cpp - convert Arm Neon 2d ops to intrinsics --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ArmNeon2dToIntr/ArmNeon2dToIntr.h"
-#include "../PassDetail.h"
+
 #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTARMNEON2DTOINTRPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::arm_neon;
 
 namespace {
 
 class Sdot2dLoweringPattern : public OpRewritePattern<Sdot2dOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
Value c1d =
         rewriter.create<vector::ShapeCastOp>(loc, flattenedVectorType, c2d);
     Value newOp = rewriter.create<SdotOp>(loc, op.getRes().getType(), op.getA(),
                                           b1d, c1d);
     rewriter.replaceOp(op, {newOp});
     return success();
   }
 };
 
-class ConvertArmNeon2dToIntr
-    : public ConvertArmNeon2dToIntrBase<ConvertArmNeon2dToIntr> {
+class ConvertArmNeon2dToIntrPass
+    : public impl::ConvertArmNeon2dToIntrPassBase<ConvertArmNeon2dToIntrPass> {
+  using ConvertArmNeon2dToIntrPassBase::ConvertArmNeon2dToIntrPassBase;
+
   void runOnOperation() override {
     auto *context = &getContext();
 
     RewritePatternSet patterns(context);
     populateConvertArmNeon2dToIntrPatterns(patterns);
 
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::populateConvertArmNeon2dToIntrPatterns(RewritePatternSet &patterns) {
   patterns.add<Sdot2dLoweringPattern>(patterns.getContext());
 }
-
-std::unique_ptr<Pass> mlir::createConvertArmNeon2dToIntrPass() {
-  return std::make_unique<ConvertArmNeon2dToIntr>();
-}

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

 //===- AsyncToLLVM.cpp - Convert Async to LLVM dialect --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTASYNCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "convert-async-to-llvm"
 
 using namespace mlir;
 using namespace mlir::async;
 
 //===----------------------------------------------------------------------===//
 // Async Runtime C API declaration.
 //===----------------------------------------------------------------------===//
public:
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertAsyncToLLVMPass
-    : public ConvertAsyncToLLVMBase<ConvertAsyncToLLVMPass> {
+    : public impl::ConvertAsyncToLLVMPassBase<ConvertAsyncToLLVMPass> {
+  using ConvertAsyncToLLVMPassBase::ConvertAsyncToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertAsyncToLLVMPass::runOnOperation() {
   ModuleOp module = getOperation();
   MLIRContext *ctx = module->getContext();
 
public:
   matchAndRewrite(async::YieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<async::YieldOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertAsyncToLLVMPass() {
-  return std::make_unique<ConvertAsyncToLLVMPass>();
-}
-
 void mlir::populateAsyncStructuralTypeConversionsAndLegality(
     TypeConverter &typeConverter, RewritePatternSet &patterns,
     ConversionTarget &target) {
   typeConverter.addConversion([&](TokenType type) { return type; });
   typeConverter.addConversion([&](ValueType type) {
     Type converted = typeConverter.convertType(type.getValueType());
     return converted ? ValueType::get(converted) : converted;
   });
 
   patterns.add<ConvertExecuteOpTypes, ConvertAwaitOpTypes, ConvertYieldOpTypes>(
       typeConverter, patterns.getContext());
 
   target.addDynamicallyLegalOp<AwaitOp, ExecuteOp, async::YieldOp>(
       [&](Operation *op) { return typeConverter.isLegal(op); });
 }
+
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertAsyncToLLVMPass() {
+  return std::make_unique<ConvertAsyncToLLVMPass>();
+}

mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp

 //===- BufferizationToMemRef.cpp - Bufferization to MemRef conversion -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns to convert Bufferization dialect to MemRef
 // dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/BufferizationToMemRef/BufferizationToMemRef.h"
-#include "../PassDetail.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTBUFFERIZATIONTOMEMREFPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// The CloneOpConversion transforms all bufferization clone operations into
 /// memref alloc and memref copy operations. In the dynamic-shape case, it also
 /// emits additional dim and constant operations to determine the shape. This
 /// conversion does not resolve memory leaks if it is used alone.
 struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {

 } // namespace
 
 void mlir::populateBufferizationToMemRefConversionPatterns(
     RewritePatternSet &patterns) {
   patterns.add<CloneOpConversion>(patterns.getContext());
 }
 
 namespace {
-struct BufferizationToMemRefPass
-    : public ConvertBufferizationToMemRefBase<BufferizationToMemRefPass> {
-  BufferizationToMemRefPass() = default;
+struct ConvertBufferizationToMemRefPass
+    : public impl::ConvertBufferizationToMemRefPassBase<
+          ConvertBufferizationToMemRefPass> {
+  using ConvertBufferizationToMemRefPassBase::
+      ConvertBufferizationToMemRefPassBase;
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateBufferizationToMemRefConversionPatterns(patterns);
 
     ConversionTarget target(getContext());
     target.addLegalDialect<memref::MemRefDialect>();
     target.addLegalOp<arith::ConstantOp>();
     target.addIllegalDialect<bufferization::BufferizationDialect>();
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createBufferizationToMemRefPass() {
-  return std::make_unique<BufferizationToMemRefPass>();
-}

mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp

 //===- ComplexToLLVM.cpp - conversion from Complex to LLVM dialect --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ComplexToLLVM/ComplexToLLVM.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTCOMPLEXTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
 //===----------------------------------------------------------------------===//
 // ComplexStructBuilder implementation.
 //===----------------------------------------------------------------------===//
 
patterns.add<
       ReOpConversion,
       SubOpConversion
     >(converter);
   // clang-format on
 }
 
 namespace {
 struct ConvertComplexToLLVMPass
-    : public ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
+    : public impl::ConvertComplexToLLVMPassBase<ConvertComplexToLLVMPass> {
+  using ConvertComplexToLLVMPassBase::ConvertComplexToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertComplexToLLVMPass::runOnOperation() {
   // Convert to the LLVM IR dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   LLVMTypeConverter converter(&getContext());
   populateComplexToLLVMConversionPatterns(converter, patterns);
 
   LLVMConversionTarget target(getContext());
   target.addIllegalDialect<complex::ComplexDialect>();
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<Pass> mlir::createConvertComplexToLLVMPass() {
-  return std::make_unique<ConvertComplexToLLVMPass>();
-}

mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp

 //===-- ComplexToLibm.cpp - conversion from Complex to libm calls ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ComplexToLibm/ComplexToLibm.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTCOMPLEXTOLIBMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 // Functor to resolve the function name corresponding to the given complex
 // result type.
 struct ComplexTypeResolver {
   llvm::Optional<bool> operator()(Type type) const {
void mlir::populateComplexToLibmConversionPatterns(RewritePatternSet &patterns,
   patterns.add<ScalarOpToLibmCall<complex::AbsOp, FloatTypeResolver>>(
       patterns.getContext(), "cabsf", "cabs", benefit);
   patterns.add<ScalarOpToLibmCall<complex::AngleOp, FloatTypeResolver>>(
       patterns.getContext(), "cargf", "carg", benefit);
 }
 
 namespace {
 struct ConvertComplexToLibmPass
-    : public ConvertComplexToLibmBase<ConvertComplexToLibmPass> {
+    : public impl::ConvertComplexToLibmPassBase<ConvertComplexToLibmPass> {
+  using ConvertComplexToLibmPassBase::ConvertComplexToLibmPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertComplexToLibmPass::runOnOperation() {
   auto module = getOperation();
 
   RewritePatternSet patterns(&getContext());

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

 //===- ComplexToStandard.cpp - conversion from Complex to Standard dialect ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ComplexToStandard/ComplexToStandard.h"
 
-#include <memory>
-#include <type_traits>
-
-#include "../PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
+#include <memory>
+#include <type_traits>
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTCOMPLEXTOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 struct AbsOpConversion : public OpConversionPattern<complex::AbsOp> {
   using OpConversionPattern<complex::AbsOp>::OpConversionPattern;
 
   LogicalResult
patterns.add<
       TanhOpConversion,
       PowOpConversion,
       RsqrtOpConversion
   >(patterns.getContext());
   // clang-format on
 }
 
 namespace {
-struct ConvertComplexToStandardPass
-    : public ConvertComplexToStandardBase<ConvertComplexToStandardPass> {
+struct ConvertComplexToStandardPass : public impl::ConvertComplexToStandardPassBase<ConvertComplexToStandardPass> {
+  using ConvertComplexToStandardPassBase::ConvertComplexToStandardPassBase;
+
   void runOnOperation() override;
 };
 
 void ConvertComplexToStandardPass::runOnOperation() {
   // Convert to the Standard dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   populateComplexToStandardConversionPatterns(patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<arith::ArithmeticDialect, math::MathDialect>();
   target.addLegalOp<complex::CreateOp, complex::ImOp, complex::ReOp>();
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 } // namespace
-
-std::unique_ptr<Pass> mlir::createConvertComplexToStandardPass() {
-  return std::make_unique<ConvertComplexToStandardPass>();
-}

mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp

 //===- ControlFlowToLLVM.cpp - ControlFlow to LLVM dialect conversion -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert MLIR standard and builtin dialects
 // into the LLVM IR dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTCONTROLFLOWTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 #define PASS_NAME "convert-cf-to-llvm"
 
 namespace {
 /// Lower `cf.assert`. The default lowering calls the `abort` function if the
 /// assertion is violated and has no effect otherwise. The failure message is
 /// ignored by the default lowering but should be propagated by any custom

 }
 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass converting MLIR operations into the LLVM IR dialect.
-struct ConvertControlFlowToLLVM
-    : public ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
-  ConvertControlFlowToLLVM() = default;
+struct ConvertControlFlowToLLVMPass
+    : public impl::ConvertControlFlowToLLVMPassBase<
+          ConvertControlFlowToLLVMPass> {
+  using ConvertControlFlowToLLVMPassBase::ConvertControlFlowToLLVMPassBase;
 
   /// Run the dialect converter on the module.
   void runOnOperation() override {
     LLVMConversionTarget target(getContext());
     RewritePatternSet patterns(&getContext());
 
     LowerToLLVMOptions options(&getContext());
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
 
     LLVMTypeConverter converter(&getContext(), options);
     mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::cf::createConvertControlFlowToLLVMPass() {
-  return std::make_unique<ConvertControlFlowToLLVM>();
-}

mlir/lib/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.cpp

 //===- ControlFlowToSPIRVPass.cpp - ControlFlow to SPIR-V Pass ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert ControlFlow dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/ControlFlowToSPIRV/ControlFlowToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTCONTROLFLOWTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR ControlFlow operations into the SPIR-V dialect.
 class ConvertControlFlowToSPIRVPass
-    : public ConvertControlFlowToSPIRVBase<ConvertControlFlowToSPIRVPass> {
+    : public impl::ConvertControlFlowToSPIRVPassBase<
+          ConvertControlFlowToSPIRVPass> {
+  using ConvertControlFlowToSPIRVPassBase::ConvertControlFlowToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertControlFlowToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

 //===- FuncToLLVM.cpp - Func to LLVM dialect conversion -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert MLIR Func and builtin dialects
 // into the LLVM IR dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
+
 #include "mlir/Analysis/DataLayoutAnalysis.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
-#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FormatVariadic.h"
 #include <algorithm>
 #include <functional>
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTFUNCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 #define PASS_NAME "convert-func-to-llvm"
 
 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
 static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
patterns.add<
       ConstantOpLowering,
       ReturnOpLowering>(converter);
   // clang-format on
 }
 
 namespace {
 /// A pass converting Func operations into the LLVM IR dialect.
 struct ConvertFuncToLLVMPass
-    : public ConvertFuncToLLVMBase<ConvertFuncToLLVMPass> {
+    : public impl::ConvertFuncToLLVMPassBase<ConvertFuncToLLVMPass> {
   ConvertFuncToLLVMPass() = default;
   ConvertFuncToLLVMPass(bool useBarePtrCallConv, unsigned indexBitwidth,
                         bool useAlignedAlloc,
                         const llvm::DataLayout &dataLayout) {
     this->useBarePtrCallConv = useBarePtrCallConv;
     this->indexBitwidth = indexBitwidth;
     this->dataLayout = dataLayout.getStringRepresentation();
   }

mlir/lib/Conversion/FuncToSPIRV/FuncToSPIRVPass.cpp

 //===- FuncToSPIRVPass.cpp - Func to SPIR-V Passes ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert Func dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTFUNCTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Func operations into the SPIR-V dialect.
 class ConvertFuncToSPIRVPass
-    : public ConvertFuncToSPIRVBase<ConvertFuncToSPIRVPass> {
+    : public impl::ConvertFuncToSPIRVPassBase<ConvertFuncToSPIRVPass> {
+  using ConvertFuncToSPIRVPassBase::ConvertFuncToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertFuncToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

 // GPU runtime calls. As most of GPU runtimes does not have a stable published
 // ABI, this pass uses a slim runtime layer that builds on top of the public
 // API from GPU runtime headers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/GPUCommon/GPUCommonPass.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/AsyncToLLVM/AsyncToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/GPU/Transforms/Passes.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static constexpr const char *kGpuBinaryStorageSuffix = "_gpubin_cst";
 
 namespace {
 
-class GpuToLLVMConversionPass
-    : public GpuToLLVMConversionPassBase<GpuToLLVMConversionPass> {
+class ConvertGpuToLLVMPass
+    : public impl::ConvertGpuToLLVMPassBase<ConvertGpuToLLVMPass> {
 public:
-  GpuToLLVMConversionPass() = default;
+  ConvertGpuToLLVMPass() = default;
 
-  GpuToLLVMConversionPass(bool kernelBarePtrCallConv)
-      : GpuToLLVMConversionPass() {
+  ConvertGpuToLLVMPass(bool kernelBarePtrCallConv)
+      : ConvertGpuToLLVMPass() {
     if (this->kernelBarePtrCallConv.getNumOccurrences() == 0)
       this->kernelBarePtrCallConv = kernelBarePtrCallConv;
   }
 
-  GpuToLLVMConversionPass(const GpuToLLVMConversionPass &other)
-      : GpuToLLVMConversionPassBase(other) {}
+  ConvertGpuToLLVMPass(const ConvertGpuToLLVMPass &other)
+      : ConvertGpuToLLVMPassBase(other) {}
 
   // Run the dialect converter on the module.
   void runOnOperation() override;
 
 private:
   Option<std::string> gpuBinaryAnnotation{
       *this, "gpu-binary-annotation",
       llvm::cl::desc("Annotation attribute string for GPU binary"),
ConvertSetDefaultDeviceOpToGpuRuntimeCallPattern(
             typeConverter) {}
 
   LogicalResult
   matchAndRewrite(gpu::SetDefaultDeviceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
-void GpuToLLVMConversionPass::runOnOperation() {
+void ConvertGpuToLLVMPass::runOnOperation() {
   LLVMTypeConverter converter(&getContext());
   RewritePatternSet patterns(&getContext());
   LLVMConversionTarget target(getContext());
 
   target.addIllegalDialect<gpu::GPUDialect>();
 
   mlir::arith::populateArithmeticToLLVMConversionPatterns(converter, patterns);
   mlir::cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
LogicalResult ConvertSetDefaultDeviceOpToGpuRuntimeCallPattern::matchAndRewrite(
     gpu::SetDefaultDeviceOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Location loc = op.getLoc();
   setDefaultDeviceCallBuilder.create(loc, rewriter, {adaptor.devIndex()});
   rewriter.replaceOp(op, {});
   return success();
 }
 
-std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
-mlir::createGpuToLLVMConversionPass(bool kernelBarePtrCallConv) {
-  return std::make_unique<GpuToLLVMConversionPass>(kernelBarePtrCallConv);
-}
-
 void mlir::populateGpuToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                RewritePatternSet &patterns,
                                                StringRef gpuBinaryAnnotation,
                                                bool kernelBarePtrCallConv) {
   converter.addConversion(
       [context = &converter.getContext()](gpu::AsyncTokenType type) -> Type {
         return LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
       });
   patterns.add<ConvertAllocOpToGpuRuntimeCallPattern,
                ConvertDeallocOpToGpuRuntimeCallPattern,
                ConvertHostRegisterOpToGpuRuntimeCallPattern,
                ConvertMemcpyOpToGpuRuntimeCallPattern,
                ConvertMemsetOpToGpuRuntimeCallPattern,
                ConvertSetDefaultDeviceOpToGpuRuntimeCallPattern,
                ConvertWaitAsyncOpToGpuRuntimeCallPattern,
                ConvertWaitOpToGpuRuntimeCallPattern,
                ConvertAsyncYieldToGpuRuntimeCallPattern>(converter);
   patterns.add<ConvertLaunchFuncOpToGpuRuntimeCallPattern>(
       converter, gpuBinaryAnnotation, kernelBarePtrCallConv);
   patterns.add<EraseGpuModuleOpPattern>(&converter.getContext());
 }
+
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
+mlir::createConvertGpuToLLVMPass(bool kernelBarePtrCallConv) {
+  return std::make_unique<ConvertGpuToLLVMPass>(kernelBarePtrCallConv);
+}

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include "../GPUCommon/GPUOpsLowering.h"
 #include "../GPUCommon/IndexIntrinsicsOpLowering.h"
 #include "../GPUCommon/OpToFuncCallLowering.h"
-#include "../PassDetail.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUTONVVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 /// Convert gpu dialect shfl mode enum to the equivalent nvvm one.
 static NVVM::ShflKind convertShflKind(gpu::ShuffleMode mode) {
   switch (mode) {

 /// Import the GPU Ops to NVVM Patterns.
 #include "GPUToNVVM.cpp.inc"
 
 /// A pass that replaces all occurrences of GPU device operations with their
 /// corresponding NVVM equivalent.
 ///
 /// This pass only handles device code and is not meant to be run on GPU host
 /// code.
-struct LowerGpuOpsToNVVMOpsPass
-    : public ConvertGpuOpsToNVVMOpsBase<LowerGpuOpsToNVVMOpsPass> {
-  LowerGpuOpsToNVVMOpsPass() = default;
-  LowerGpuOpsToNVVMOpsPass(unsigned indexBitwidth) {
+struct ConvertGpuToNVVMPass
+    : public impl::ConvertGpuToNVVMPassBase<ConvertGpuToNVVMPass> {
+  ConvertGpuToNVVMPass() = default;
+  ConvertGpuToNVVMPass(unsigned indexBitwidth) {
     this->indexBitwidth = indexBitwidth;
   }
 
   void runOnOperation() override {
     gpu::GPUModuleOp m = getOperation();
 
     // Request C wrapper emission.
     for (auto func : m.getOps<func::FuncOp>()) {
patterns.add<OpToFuncCallLowering<math::SinOp>>(converter, "__nv_sinf",
                                                   "__nv_sin");
   patterns.add<OpToFuncCallLowering<math::SqrtOp>>(converter, "__nv_sqrtf",
                                                    "__nv_sqrt");
   patterns.add<OpToFuncCallLowering<math::TanhOp>>(converter, "__nv_tanhf",
                                                    "__nv_tanh");
 }
 
 std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
-mlir::createLowerGpuOpsToNVVMOpsPass(unsigned indexBitwidth) {
-  return std::make_unique<LowerGpuOpsToNVVMOpsPass>(indexBitwidth);
+mlir::createConvertGpuToNVVMPass(unsigned indexBitwidth) {
+  return std::make_unique<ConvertGpuToNVVMPass>(indexBitwidth);
 }

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include "../GPUCommon/GPUOpsLowering.h"
 #include "../GPUCommon/IndexIntrinsicsOpLowering.h"
 #include "../GPUCommon/OpToFuncCallLowering.h"
-#include "../PassDetail.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUTOROCDLPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 /// Returns true if the given `gpu.func` can be safely called using the bare
 /// pointer calling convention.
 static bool canBeCalledWithBarePointers(gpu::GPUFuncOp func) {
   bool canBeBare = true;
   for (Type type : func.getArgumentTypes())
     if (auto memrefTy = type.dyn_cast<BaseMemRefType>())
       canBeBare &= LLVMTypeConverter::canConvertToBarePtr(memrefTy);
   return canBeBare;
 }
 
 namespace {
 
 /// Import the GPU Ops to ROCDL Patterns.
 #include "GPUToROCDL.cpp.inc"
 
 // A pass that replaces all occurrences of GPU device operations with their
 // corresponding ROCDL equivalent.
 //
 // This pass only handles device code and is not meant to be run on GPU host
 // code.
-struct LowerGpuOpsToROCDLOpsPass
-    : public ConvertGpuOpsToROCDLOpsBase<LowerGpuOpsToROCDLOpsPass> {
-  LowerGpuOpsToROCDLOpsPass() = default;
-  LowerGpuOpsToROCDLOpsPass(const std::string &chipset, unsigned indexBitwidth,
+struct ConvertGpuToROCDLPass : public impl::ConvertGpuToROCDLPassBase<ConvertGpuToROCDLPass> {
+  ConvertGpuToROCDLPass() = default;
+  ConvertGpuToROCDLPass(const std::string &chipset, unsigned indexBitwidth,
                             bool useBarePtrCallConv,
                             gpu::amd::Runtime runtime) {
     if (this->chipset.getNumOccurrences() == 0)
       this->chipset = chipset;
     if (this->indexBitwidth.getNumOccurrences() == 0)
       this->indexBitwidth = indexBitwidth;
     if (this->useBarePtrCallConv.getNumOccurrences() == 0)
       this->useBarePtrCallConv = useBarePtrCallConv;
patterns.add<OpToFuncCallLowering<math::SinOp>>(converter, "__ocml_sin_f32",
                                                   "__ocml_sin_f64");
   patterns.add<OpToFuncCallLowering<math::SqrtOp>>(converter, "__ocml_sqrt_f32",
                                                    "__ocml_sqrt_f64");
   patterns.add<OpToFuncCallLowering<math::TanhOp>>(converter, "__ocml_tanh_f32",
                                                    "__ocml_tanh_f64");
 }
 
 std::unique_ptr<OperationPass<gpu::GPUModuleOp>>
-mlir::createLowerGpuOpsToROCDLOpsPass(const std::string &chipset,
+mlir::createConvertGpuToROCDLPass(const std::string &chipset,
                                       unsigned indexBitwidth,
                                       bool useBarePtrCallConv,
                                       gpu::amd::Runtime runtime) {
-  return std::make_unique<LowerGpuOpsToROCDLOpsPass>(
+  return std::make_unique<ConvertGpuToROCDLPass>(
       chipset, indexBitwidth, useBarePtrCallConv, runtime);
 }

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRVPass.cpp

 //===- GPUToSPIRVPass.cpp - GPU to SPIR-V Passes --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert a kernel function in the GPU Dialect
 // into a spv.module operation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRV.h"
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPUTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Pass to lower GPU Dialect to SPIR-V. The pass only converts the gpu.func ops
 /// inside gpu.module ops. i.e., the function that are referenced in
 /// gpu.launch_func ops. For each such function
 ///
 /// 1) Create a spirv::ModuleOp, and clone the function into spirv::ModuleOp
 /// (the original function is still needed by the gpu::LaunchKernelOp, so cannot
 /// replace it).
 ///
 /// 2) Lower the body of the spirv::ModuleOp.
-class GPUToSPIRVPass : public ConvertGPUToSPIRVBase<GPUToSPIRVPass> {
+class ConvertGPUToSPIRVPass
+    : public impl::ConvertGPUToSPIRVPassBase<ConvertGPUToSPIRVPass> {
 public:
-  explicit GPUToSPIRVPass(bool mapMemorySpace)
+  explicit ConvertGPUToSPIRVPass(bool mapMemorySpace)
       : mapMemorySpace(mapMemorySpace) {}
   void runOnOperation() override;
 
 private:
   bool mapMemorySpace;
 };
 } // namespace
 
-void GPUToSPIRVPass::runOnOperation() {
+void ConvertGPUToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   SmallVector<Operation *, 1> gpuModules;
   OpBuilder builder(context);
   module.walk([&](gpu::GPUModuleOp moduleOp) {
     // Clone each GPU kernel module for conversion, given that the GPU
     // launch op still needs the original GPU kernel module.
void ConvertGPUToSPIRVPass::runOnOperation() {
   populateFuncToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyFullConversion(gpuModules, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertGPUToSPIRVPass(bool mapMemorySpace) {
-  return std::make_unique<GPUToSPIRVPass>(mapMemorySpace);
+  return std::make_unique<ConvertGPUToSPIRVPass>(mapMemorySpace);
 }

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

 //===- ConvertGPULaunchFuncToVulkanLaunchFunc.cpp - MLIR conversion pass --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert gpu launch function into a vulkan
 // launch function. Creates a SPIR-V binary shader from the `spirv::ModuleOp`
 // using `spirv::serialize` function, attaches binary data and entry point name
 // as an attributes to vulkan launch call op.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
+
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Target/SPIRV/Serialization.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTGPULAUNCHFUNCTOVULKANLAUNCHFUNCPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static constexpr const char *kSPIRVBlobAttrName = "spirv_blob";
 static constexpr const char *kSPIRVEntryPointAttrName = "spirv_entry_point";
 static constexpr const char *kVulkanLaunch = "vulkanLaunch";
 
 namespace {
 
 /// A pass to convert gpu launch op to vulkan launch call op, by creating a
 /// SPIR-V binary shader from `spirv::ModuleOp` using `spirv::serialize`
 /// function and attaching binary data and entry point name as an attributes to
 /// created vulkan launch call op.
-class ConvertGpuLaunchFuncToVulkanLaunchFunc
-    : public ConvertGpuLaunchFuncToVulkanLaunchFuncBase<
-          ConvertGpuLaunchFuncToVulkanLaunchFunc> {
+class ConvertGpuLaunchFuncToVulkanLaunchFuncPass
+    : public impl::ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase<
+          ConvertGpuLaunchFuncToVulkanLaunchFuncPass> {
 public:
+  using ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase::
+      ConvertGpuLaunchFuncToVulkanLaunchFuncPassBase;
+
   void runOnOperation() override;
 
 private:
   /// Creates a SPIR-V binary shader from the given `module` using
   /// `spirv::serialize` function.
   LogicalResult createBinaryShader(ModuleOp module,
                                    std::vector<char> &binaryShader);
 

 private:
   /// The number of vulkan launch configuration operands, placed at the leading
   /// positions of the operand list.
   static constexpr unsigned kVulkanLaunchNumConfigOperands = 3;
 };
 
 } // namespace
 
-void ConvertGpuLaunchFuncToVulkanLaunchFunc::runOnOperation() {
+void ConvertGpuLaunchFuncToVulkanLaunchFuncPass::runOnOperation() {
   bool done = false;
   getOperation().walk([this, &done](gpu::LaunchFuncOp op) {
     if (done) {
       op.emitError("should only contain one 'gpu::LaunchFuncOp' op");
       return signalPassFailure();
     }
     done = true;
     convertGpuLaunchFunc(op);
   });
 
   // Erase `gpu::GPUModuleOp` and `spirv::Module` operations.
   for (auto gpuModule :
        llvm::make_early_inc_range(getOperation().getOps<gpu::GPUModuleOp>()))
     gpuModule.erase();
 
   for (auto spirvModule :
        llvm::make_early_inc_range(getOperation().getOps<spirv::ModuleOp>()))
     spirvModule.erase();
 }
 
-LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::declareVulkanLaunchFunc(
+LogicalResult
+ConvertGpuLaunchFuncToVulkanLaunchFuncPass::declareVulkanLaunchFunc(
     Location loc, gpu::LaunchFuncOp launchOp) {
   auto builder = OpBuilder::atBlockEnd(getOperation().getBody());
 
   // Workgroup size is written into the kernel. So to properly modelling
   // vulkan launch, we have to skip local workgroup size configuration here.
   SmallVector<Type, 8> gpuLaunchTypes(launchOp.getOperandTypes());
   // The first kVulkanLaunchNumConfigOperands of the gpu.launch_func op are the
   // same as the config operands for the vulkan launch call op.
ConvertGpuLaunchFuncToVulkanLaunchFuncPass::declareVulkanLaunchFunc(
 
   // Declare vulkan launch function.
   auto funcType = builder.getFunctionType(vulkanLaunchTypes, {});
   builder.create<func::FuncOp>(loc, kVulkanLaunch, funcType).setPrivate();
 
   return success();
 }
 
-LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::createBinaryShader(
+LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFuncPass::createBinaryShader(
     ModuleOp module, std::vector<char> &binaryShader) {
   bool done = false;
   SmallVector<uint32_t, 0> binary;
   for (auto spirvModule : module.getOps<spirv::ModuleOp>()) {
     if (done)
       return spirvModule.emitError("should only contain one 'spv.module' op");
     done = true;
 
     if (failed(spirv::serialize(spirvModule, binary)))
       return failure();
   }
   binaryShader.resize(binary.size() * sizeof(uint32_t));
   std::memcpy(binaryShader.data(), reinterpret_cast<char *>(binary.data()),
               binaryShader.size());
   return success();
 }
 
-void ConvertGpuLaunchFuncToVulkanLaunchFunc::convertGpuLaunchFunc(
+void ConvertGpuLaunchFuncToVulkanLaunchFuncPass::convertGpuLaunchFunc(
     gpu::LaunchFuncOp launchOp) {
   ModuleOp module = getOperation();
   OpBuilder builder(launchOp);
   Location loc = launchOp.getLoc();
 
   // Serialize `spirv::Module` into binary form.
   std::vector<char> binary;
   if (failed(createBinaryShader(module, binary)))
void ConvertGpuLaunchFuncToVulkanLaunchFuncPass::convertGpuLaunchFunc(
   vulkanLaunchCallOp->setAttr(kSPIRVEntryPointAttrName,
                               launchOp.getKernelName());
 
   launchOp.erase();
 }
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass() {
-  return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFunc>();
+  return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFuncPass>();
 }

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

 //===- ConvertLaunchFuncToVulkanCalls.cpp - MLIR Vulkan conversion passes -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert vulkan launch call into a sequence of
 // Vulkan runtime calls. The Vulkan runtime API surface is huge so currently we
 // don't expose separate external functions in IR for each of them, instead we
 // expose a few external functions to wrapper libraries which manages Vulkan
 // runtime.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
+
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
-
+#include "mlir/Pass/Pass.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FormatVariadic.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTVULKANLAUNCHFUNCTOVULKANCALLSPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static constexpr const char *kCInterfaceVulkanLaunch =
     "_mlir_ciface_vulkanLaunch";
 static constexpr const char *kDeinitVulkan = "deinitVulkan";
 static constexpr const char *kRunOnVulkan = "runOnVulkan";
 static constexpr const char *kInitVulkan = "initVulkan";
 static constexpr const char *kSetBinaryShader = "setBinaryShader";

 /// * bindMemRef           -- binds memref
 /// * setBinaryShader      -- sets the binary shader data
 /// * setEntryPoint        -- sets the entry point name
 /// * setNumWorkGroups     -- sets the number of a local workgroups
 /// * runOnVulkan          -- runs vulkan runtime
 /// * deinitVulkan         -- deinitializes vulkan runtime
 ///
 class VulkanLaunchFuncToVulkanCallsPass
-    : public ConvertVulkanLaunchFuncToVulkanCallsBase<
+    : public impl::ConvertVulkanLaunchFuncToVulkanCallsPassBase<
           VulkanLaunchFuncToVulkanCallsPass> {
 private:
   void initializeCachedTypes() {
     llvmFloatType = Float32Type::get(&getContext());
     llvmVoidType = LLVM::LLVMVoidType::get(&getContext());
     llvmPointerType =
         LLVM::LLVMPointerType::get(IntegerType::get(&getContext(), 8));
     llvmInt32Type = IntegerType::get(&getContext(), 32);
if (auto intType = type.dyn_cast<IntegerType>()) {
       if (intType.getWidth() == 8)
         return "Int8";
     }
 
     llvm_unreachable("unsupported type");
   }
 
 public:
+  using ConvertVulkanLaunchFuncToVulkanCallsPassBase::ConvertVulkanLaunchFuncToVulkanCallsPassBase;
+
   void runOnOperation() override;
 
 private:
   Type llvmFloatType;
   Type llvmVoidType;
   Type llvmPointerType;
   Type llvmInt32Type;
   Type llvmInt64Type;

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 //===- LinalgToLLVM.cpp - conversion from Linalg to LLVM dialect ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/AffineToStandard/AffineToStandard.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"

 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTLINALGTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::LLVM;
 using namespace mlir::linalg;
 
 template <typename T>
 static Type getPtrToElementType(T containerType, LLVMTypeConverter &lowering) {
   return LLVMPointerType::get(
       lowering.convertType(containerType.getElementType()));

 /// Populate the given list with patterns that convert from Linalg to LLVM.
 void mlir::populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                   RewritePatternSet &patterns) {
   patterns.add<YieldOpConversion>(converter);
 }
 
 namespace {
 struct ConvertLinalgToLLVMPass
-    : public ConvertLinalgToLLVMBase<ConvertLinalgToLLVMPass> {
+    : public impl::ConvertLinalgToLLVMPassBase<ConvertLinalgToLLVMPass> {
+  using ConvertLinalgToLLVMPassBase::ConvertLinalgToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to the LLVM IR dialect using the converter defined above.

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

 //===- LinalgToSPIRVPass.cpp - Linalg to SPIR-V Passes --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRV.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTLINALGTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Linalg ops into SPIR-V ops.
-class LinalgToSPIRVPass : public ConvertLinalgToSPIRVBase<LinalgToSPIRVPass> {
+class ConvertLinalgToSPIRVPass
+    : public impl::ConvertLinalgToSPIRVPassBase<ConvertLinalgToSPIRVPass> {
+  using ConvertLinalgToSPIRVPassBase::ConvertLinalgToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void LinalgToSPIRVPass::runOnOperation() {
+void ConvertLinalgToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
       SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   RewritePatternSet patterns(context);
   populateLinalgToSPIRVPatterns(typeConverter, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   // Allow builtin ops.
   target->addLegalOp<ModuleOp>();
   target->addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
     return typeConverter.isSignatureLegal(op.getFunctionType()) &&
            typeConverter.isLegal(&op.getBody());
   });
 
   if (failed(applyFullConversion(module, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createLinalgToSPIRVPass() {
-  return std::make_unique<LinalgToSPIRVPass>();
+std::unique_ptr<OperationPass<ModuleOp>>
+mlir::createConvertLinalgToSPIRVPass() {
+  return std::make_unique<ConvertLinalgToSPIRVPass>();
 }

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

 //===- LinalgToStandard.cpp - conversion from Linalg to Standard dialect --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTLINALGTOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 /// Helper function to extract the operand types that are passed to the
 /// generated CallOp. MemRefTypes have their layout canonicalized since the
 /// information is not used in signature generation.
 /// Note that static size information is not modified.
void mlir::linalg::populateLinalgToStandardConversionPatterns(
     RewritePatternSet &patterns) {
   // TODO: ConvOp conversion needs to export a descriptor with relevant
   // attribute values such as kernel striding and dilation.
   patterns.add<LinalgOpToLibraryCallRewrite>(patterns.getContext());
 }
 
 namespace {
 struct ConvertLinalgToStandardPass
-    : public ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
+    : public impl::ConvertLinalgToStandardPassBase<
+          ConvertLinalgToStandardPass> {
+  using ConvertLinalgToStandardPassBase::ConvertLinalgToStandardPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToStandardPass::runOnOperation() {
   auto module = getOperation();
   ConversionTarget target(getContext());
   target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,

mlir/lib/Conversion/MathToFuncs/MathToFuncs.cpp

 //===- MathToFuncs.cpp - Math to outlined implementation conversion -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MathToFuncs/MathToFuncs.h"
-#include "../PassDetail.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/TypeUtilities.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMATHTOFUNCSPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 // Pattern to convert vector operations to scalar operations.
 template <typename Op>
 struct VecOpToScalarOp : public OpRewritePattern<Op> {
 public:
   using OpRewritePattern<Op>::OpRewritePattern;
if (!elementFunc)
     return rewriter.notifyMatchFailure(op, "missing software implementation");
 
   rewriter.replaceOpWithNewOp<func::CallOp>(op, elementFunc, op.getOperands());
   return success();
 }
 
 namespace {
 struct ConvertMathToFuncsPass
-    : public ConvertMathToFuncsBase<ConvertMathToFuncsPass> {
-  ConvertMathToFuncsPass() = default;
+    : public impl::ConvertMathToFuncsPassBase<ConvertMathToFuncsPass> {
+  using ConvertMathToFuncsPassBase::ConvertMathToFuncsPassBase;
 
   void runOnOperation() override;
 
 private:
   // Generate outlined implementations for power operations
   // and store them in powerFuncs map.
   void preprocessPowOperations();
 
void ConvertMathToFuncsPass::runOnOperation() {
 
   ConversionTarget target(getContext());
   target.addLegalDialect<arith::ArithmeticDialect, cf::ControlFlowDialect,
                          func::FuncDialect, vector::VectorDialect>();
   target.addIllegalOp<math::IPowIOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<Pass> mlir::createConvertMathToFuncsPass() {
-  return std::make_unique<ConvertMathToFuncsPass>();
-}

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

 //===- MathToLLVM.cpp - Math to LLVM dialect conversion -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/IR/TypeUtilities.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMATHTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 using AbsFOpLowering = VectorConvertToLLVMPattern<math::AbsFOp, LLVM::FAbsOp>;
 using CeilOpLowering = VectorConvertToLLVMPattern<math::CeilOp, LLVM::FCeilOp>;
 using CopySignOpLowering =
     VectorConvertToLLVMPattern<math::CopySignOp, LLVM::CopySignOp>;
return LLVM::detail::handleMultidimensionalVectors(
               rewriter.create<LLVM::SqrtOp>(loc, llvm1DVectorTy, operands[0]);
           return rewriter.create<LLVM::FDivOp>(loc, llvm1DVectorTy, one, sqrt);
         },
         rewriter);
   }
 };
 
 struct ConvertMathToLLVMPass
-    : public ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
-  ConvertMathToLLVMPass() = default;
+    : public impl::ConvertMathToLLVMPassBase<ConvertMathToLLVMPass> {
+  using ConvertMathToLLVMPassBase::ConvertMathToLLVMPassBase;
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     LLVMTypeConverter converter(&getContext());
     populateMathToLLVMConversionPatterns(converter, patterns);
     LLVMConversionTarget target(getContext());
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
patterns.add<
     RoundEvenOpLowering,
     RoundOpLowering,
     RsqrtOpLowering,
     SinOpLowering,
     SqrtOpLowering
   >(converter);
   // clang-format on
 }
-
-std::unique_ptr<Pass> mlir::createConvertMathToLLVMPass() {
-  return std::make_unique<ConvertMathToLLVMPass>();
-}

mlir/lib/Conversion/MathToLibm/MathToLibm.cpp

 //===-- MathToLibm.cpp - conversion from Math to libm calls ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MathToLibm/MathToLibm.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMATHTOLIBMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 // Pattern to convert vector operations to scalar operations. This is needed as
 // libm calls require scalars.
 template <typename Op>
 struct VecOpToScalarOp : public OpRewritePattern<Op> {
void mlir::populateMathToLibmConversionPatterns(
   patterns.add<ScalarOpToLibmCall<math::FloorOp>>(patterns.getContext(),
                                                   "floorf", "floor", benefit);
   patterns.add<ScalarOpToLibmCall<math::CeilOp>>(patterns.getContext(), "ceilf",
                                                  "ceil", benefit);
 }
 
 namespace {
 struct ConvertMathToLibmPass
-    : public ConvertMathToLibmBase<ConvertMathToLibmPass> {
+    : public impl::ConvertMathToLibmPassBase<ConvertMathToLibmPass> {
+  using ConvertMathToLibmPassBase::ConvertMathToLibmPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertMathToLibmPass::runOnOperation() {
   auto module = getOperation();
 
   RewritePatternSet patterns(&getContext());

mlir/lib/Conversion/MathToSPIRV/MathToSPIRVPass.cpp

 //===- MathToSPIRVPass.cpp - Math to SPIR-V Passes ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert standard dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/MathToSPIRV/MathToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMATHTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Math operations into the SPIR-V dialect.
 class ConvertMathToSPIRVPass
-    : public ConvertMathToSPIRVBase<ConvertMathToSPIRVPass> {
+    : public impl::ConvertMathToSPIRVPassBase<ConvertMathToSPIRVPass> {
+  using ConvertMathToSPIRVPassBase::ConvertMathToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertMathToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

 //===- MemRefToLLVM.cpp - MemRef to LLVM dialect conversion ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
-#include "../PassDetail.h"
+
 #include "mlir/Analysis/DataLayoutAnalysis.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/MemRefToLLVM/AllocLikeConversion.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/FunctionCallUtils.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
+#include "mlir/Pass/Pass.h"
 #include "llvm/ADT/SmallBitVector.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMEMREFTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
 bool isStaticStrideOrOffset(int64_t strideOrOffset) {
   return !ShapedType::isDynamicStrideOrOffset(strideOrOffset);
 }
 
void mlir::populateMemRefToLLVMConversionPatterns(LLVMTypeConverter &converter,
   auto allocLowering = converter.getOptions().allocLowering;
   if (allocLowering == LowerToLLVMOptions::AllocLowering::AlignedAlloc)
     patterns.add<AlignedAllocOpLowering, DeallocOpLowering>(converter);
   else if (allocLowering == LowerToLLVMOptions::AllocLowering::Malloc)
     patterns.add<AllocOpLowering, DeallocOpLowering>(converter);
 }
 
 namespace {
-struct MemRefToLLVMPass : public ConvertMemRefToLLVMBase<MemRefToLLVMPass> {
-  MemRefToLLVMPass() = default;
+struct ConvertMemRefToLLVMPass : public impl::ConvertMemRefToLLVMPassBase<ConvertMemRefToLLVMPass> {
+  using ConvertMemRefToLLVMPassBase::ConvertMemRefToLLVMPassBase;
 
   void runOnOperation() override {
     Operation *op = getOperation();
     const auto &dataLayoutAnalysis = getAnalysis<DataLayoutAnalysis>();
     LowerToLLVMOptions options(&getContext(),
                                dataLayoutAnalysis.getAtOrAbove(op));
     options.allocLowering =
         (useAlignedAlloc ? LowerToLLVMOptions::AllocLowering::AlignedAlloc
void runOnOperation() override {
     populateMemRefToLLVMConversionPatterns(typeConverter, patterns);
     LLVMConversionTarget target(getContext());
     target.addLegalOp<func::FuncOp>();
     if (failed(applyPartialConversion(op, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createMemRefToLLVMPass() {
-  return std::make_unique<MemRefToLLVMPass>();
-}

mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp

 //===- MapMemRefStorageCLassPass.cpp --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to map numeric MemRef memory spaces to
 // symbolic ones defined in the SPIR-V specification.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
-#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
+
+#include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVEnums.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_MAPMEMREFSTORAGECLASSPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "mlir-map-memref-storage-class"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Mappings
 //===----------------------------------------------------------------------===//
 

 }
 
 //===----------------------------------------------------------------------===//
 // Conversion Pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 class MapMemRefStorageClassPass final
-    : public MapMemRefStorageClassBase<MapMemRefStorageClassPass> {
+    : public impl::MapMemRefStorageClassPassBase<MapMemRefStorageClassPass> {
 public:
   explicit MapMemRefStorageClassPass() {
     memorySpaceMap = spirv::mapMemorySpaceToVulkanStorageClass;
   }
   explicit MapMemRefStorageClassPass(
       const spirv::MemorySpaceToStorageClassMap &memorySpaceMap)
       : memorySpaceMap(memorySpaceMap) {}
 

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.cpp

 //===- MemRefToSPIRVPass.cpp - MemRef to SPIR-V Passes ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert standard dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTMEMREFTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR MemRef operations into the SPIR-V dialect.
 class ConvertMemRefToSPIRVPass
-    : public ConvertMemRefToSPIRVBase<ConvertMemRefToSPIRVPass> {
+    : public impl::ConvertMemRefToSPIRVPassBase<ConvertMemRefToSPIRVPass> {
+  using ConvertMemRefToSPIRVPassBase::ConvertMemRefToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertMemRefToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 

mlir/lib/Conversion/NVGPUToNVVM/NVGPUToNVVM.cpp

 //===- NVGPUToNVVM.cpp - NVGPU to NVVM dialect conversion -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/NVGPUToNVVM/NVGPUToNVVM.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTNVGPUTONVVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 /// Returns the type for the intrinsic given the vectorResultType of the
 /// `gpu.mma.sync` operation.
 static Type inferIntrinsicResultType(Type vectorResultType) {
   MLIRContext *ctx = vectorResultType.getContext();
   auto a = vectorResultType.cast<LLVM::LLVMArrayType>();
matchAndRewrite(nvgpu::MmaSyncOp op, OpAdaptor adaptor,
     rewriter.replaceOp(op, convertIntrinsicResult(op.getLoc(), intrinsicResTy,
                                                   desiredRetTy, intrinsicResult,
                                                   rewriter));
     return success();
   }
 };
 
 struct ConvertNVGPUToNVVMPass
-    : public ConvertNVGPUToNVVMBase<ConvertNVGPUToNVVMPass> {
-  ConvertNVGPUToNVVMPass() = default;
+    : public impl::ConvertNVGPUToNVVMPassBase<ConvertNVGPUToNVVMPass> {
+  using ConvertNVGPUToNVVMPassBase::ConvertNVGPUToNVVMPassBase;
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     LLVMTypeConverter converter(&getContext());
     /// device-side async tokens cannot be materialized in nvvm. We just convert
     /// them to a dummy i32 type in order to easily drop them during conversion.
     converter.addConversion([&](nvgpu::DeviceAsyncTokenType type) -> Type {
       return converter.convertType(IntegerType::get(type.getContext(), 32));

 } // namespace
 
 void mlir::populateNVGPUToNVVMConversionPatterns(LLVMTypeConverter &converter,
                                                  RewritePatternSet &patterns) {
   patterns.add<MmaSyncOptoNVVM, MmaLdMatrixOpToNVVM, NVGPUAsyncCopyLowering,
                NVGPUAsyncCreateGroupLowering, NVGPUAsyncWaitLowering>(
       converter);
 }
-
-std::unique_ptr<Pass> mlir::createConvertNVGPUToNVVMPass() {
-  return std::make_unique<ConvertNVGPUToNVVMPass>();
-}

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

 //===- OpenACCToLLVM.cpp - Prepare OpenACC data for LLVM translation ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
-#include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
+
+#include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTOPENACCTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // DataDescriptor implementation
 //===----------------------------------------------------------------------===//
 
 constexpr StringRef getStructName() { return "openacc_data"; }
void mlir::populateOpenACCToLLVMConversionPatterns(
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::EnterDataOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::ExitDataOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
   patterns.add<LegalizeDataOpForLLVMTranslation<acc::UpdateOp>>(converter);
 }
 
 namespace {
 struct ConvertOpenACCToLLVMPass
-    : public ConvertOpenACCToLLVMBase<ConvertOpenACCToLLVMPass> {
+    : public impl::ConvertOpenACCToLLVMPassBase<ConvertOpenACCToLLVMPass> {
+  using ConvertOpenACCToLLVMPassBase::ConvertOpenACCToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertOpenACCToLLVMPass::runOnOperation() {
   auto op = getOperation();
   auto *context = op.getContext();
 

mlir/lib/Conversion/OpenACCToSCF/OpenACCToSCF.cpp

 //===- OpenACCToSCF.cpp - OpenACC condition to SCF if conversion ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTOPENACCTOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Conversion patterns
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// Pattern to transform the `ifCond` on operation without region into a scf.if

 void mlir::populateOpenACCToSCFConversionPatterns(RewritePatternSet &patterns) {
   patterns.add<ExpandIfCondition<acc::EnterDataOp>>(patterns.getContext());
   patterns.add<ExpandIfCondition<acc::ExitDataOp>>(patterns.getContext());
   patterns.add<ExpandIfCondition<acc::UpdateOp>>(patterns.getContext());
 }
 
 namespace {
 struct ConvertOpenACCToSCFPass
-    : public ConvertOpenACCToSCFBase<ConvertOpenACCToSCFPass> {
+    : public impl::ConvertOpenACCToSCFPassBase<ConvertOpenACCToSCFPass> {
+  using ConvertOpenACCToSCFPassBase::ConvertOpenACCToSCFPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertOpenACCToSCFPass::runOnOperation() {
   auto op = getOperation();
   auto *context = op.getContext();
 

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

 //===- OpenMPToLLVM.cpp - conversion from OpenMP to LLVM dialect ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVMPass.h"
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTOPENMPTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// A pattern that converts the region arguments in a single-region OpenMP
 /// operation to the LLVM dialect. The body of the region is not modified and is
 /// expected to either be processed by the conversion infrastructure or already
 /// contain ops compatible with LLVM dialect types.
patterns.add<
       RegionLessOpWithVarOperandsConversion<omp::AtomicReadOp>,
       RegionLessOpWithVarOperandsConversion<omp::AtomicWriteOp>,
       RegionLessOpWithVarOperandsConversion<omp::FlushOp>,
       RegionLessOpWithVarOperandsConversion<omp::ThreadprivateOp>>(converter);
 }
 
 namespace {
 struct ConvertOpenMPToLLVMPass
-    : public ConvertOpenMPToLLVMBase<ConvertOpenMPToLLVMPass> {
+    : public impl::ConvertOpenMPToLLVMPassBase<ConvertOpenMPToLLVMPass> {
+  using ConvertOpenMPToLLVMPassBase::ConvertOpenMPToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertOpenMPToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to OpenMP operations with LLVM IR dialect

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

 //===- PDLToPDLInterp.cpp - Lower a PDL module to the interpreter ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
-#include "../PassDetail.h"
+
 #include "PredicateTree.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/ScopedHashTable.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTPDLTOPDLINTERPPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::pdl_to_pdl_interp;
 
 //===----------------------------------------------------------------------===//
 // PatternLowering
 //===----------------------------------------------------------------------===//
 
 namespace {
void PatternLowering::generateOperationResultTypeRewriter(
   llvm_unreachable("unable to infer result type for operation");
 }
 
 //===----------------------------------------------------------------------===//
 // Conversion Pass
 //===----------------------------------------------------------------------===//
 
 namespace {
-struct PDLToPDLInterpPass
-    : public ConvertPDLToPDLInterpBase<PDLToPDLInterpPass> {
+struct ConvertPDLToPDLInterpPass
+    : public impl::ConvertPDLToPDLInterpPassBase<ConvertPDLToPDLInterpPass> {
+  using ConvertPDLToPDLInterpPassBase::ConvertPDLToPDLInterpPassBase;
+
   void runOnOperation() final;
 };
 } // namespace
 
 /// Convert the given module containing PDL pattern operations into a PDL
 /// Interpreter operations.
-void PDLToPDLInterpPass::runOnOperation() {
+void ConvertPDLToPDLInterpPass::runOnOperation() {
   ModuleOp module = getOperation();
 
   // Create the main matcher function This function contains all of the match
   // related functionality from patterns in the module.
   OpBuilder builder = OpBuilder::atBlockBegin(module.getBody());
   auto matcherFunc = builder.create<pdl_interp::FuncOp>(
       module.getLoc(), pdl_interp::PDLInterpDialect::getMatcherFunctionName(),
       builder.getFunctionType(builder.getType<pdl::OperationType>(),
void ConvertPDLToPDLInterpPass::runOnOperation() {
 
   // After generation, delete all of the pattern operations.
   for (pdl::PatternOp pattern :
        llvm::make_early_inc_range(module.getOps<pdl::PatternOp>()))
     pattern.erase();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createPDLToPDLInterpPass() {
-  return std::make_unique<PDLToPDLInterpPass>();
+  return std::make_unique<ConvertPDLToPDLInterpPass>();
 }

mlir/lib/Conversion/PassDetail.h

-//===- PassDetail.h - Conversion Pass class details -------------*- 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 CONVERSION_PASSDETAIL_H_
-#define CONVERSION_PASSDETAIL_H_
-
-#include "mlir/Pass/Pass.h"
-
-#include "mlir/Conversion/GPUToROCDL/Runtimes.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/FunctionInterfaces.h"
-
-namespace mlir {
-class AffineDialect;
-
-// Forward declaration from Dialect.h
-template <typename ConcreteDialect>
-void registerDialect(DialectRegistry &registry);
-
-namespace acc {
-class OpenACCDialect;
-} // namespace acc
-
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace cf {
-class ControlFlowDialect;
-} // namespace cf
-
-namespace complex {
-class ComplexDialect;
-} // namespace complex
-
-namespace gpu {
-class GPUDialect;
-class GPUModuleOp;
-} // namespace gpu
-
-namespace func {
-class FuncDialect;
-} // namespace func
-
-namespace linalg {
-class LinalgDialect;
-} // namespace linalg
-
-namespace LLVM {
-class LLVMDialect;
-} // namespace LLVM
-
-namespace nvgpu {
-class NVGPUDialect;
-}
-
-namespace NVVM {
-class NVVMDialect;
-} // namespace NVVM
-
-namespace math {
-class MathDialect;
-} // namespace math
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace omp {
-class OpenMPDialect;
-} // namespace omp
-
-namespace pdl_interp {
-class PDLInterpDialect;
-} // namespace pdl_interp
-
-namespace ROCDL {
-class ROCDLDialect;
-} // namespace ROCDL
-
-namespace scf {
-class SCFDialect;
-} // namespace scf
-
-namespace spirv {
-class SPIRVDialect;
-} // namespace spirv
-
-namespace tensor {
-class TensorDialect;
-} // namespace tensor
-
-namespace tosa {
-class TosaDialect;
-} // namespace tosa
-
-namespace vector {
-class VectorDialect;
-} // namespace vector
-
-namespace arm_neon {
-class ArmNeonDialect;
-} // namespace arm_neon
-
-#define GEN_PASS_CLASSES
-#include "mlir/Conversion/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // CONVERSION_PASSDETAIL_H_

mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp

 //===- ReconcileUnrealizedCasts.cpp - Eliminate noop unrealized casts -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.h"
-#include "../PassDetail.h"
+
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_RECONCILEUNREALIZEDCASTSPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
 /// Folds the DAGs of `unrealized_conversion_cast`s that have as exit types
 /// the same as the input ones.
 /// For example, the DAGs `A -> B -> C -> B -> A` and `A -> B -> C -> A`
 /// represent a noop within the IR, and thus the initial input values can be
LogicalResult matchAndRewrite(UnrealizedConversionCastOp op,
     for (UnrealizedConversionCastOp castOp : intermediateNodes)
       rewriter.eraseOp(castOp);
 
     return success();
   }
 };
 
 /// Pass to simplify and eliminate unrealized conversion casts.
-struct ReconcileUnrealizedCasts
-    : public ReconcileUnrealizedCastsBase<ReconcileUnrealizedCasts> {
-  ReconcileUnrealizedCasts() = default;
+struct ReconcileUnrealizedCastsPass
+    : public impl::ReconcileUnrealizedCastsPassBase<
+          ReconcileUnrealizedCastsPass> {
+  using ReconcileUnrealizedCastsPassBase::ReconcileUnrealizedCastsPassBase;
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateReconcileUnrealizedCastsPatterns(patterns);
     ConversionTarget target(getContext());
     target.addIllegalOp<UnrealizedConversionCastOp>();
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 void mlir::populateReconcileUnrealizedCastsPatterns(
     RewritePatternSet &patterns) {
   patterns.add<UnrealizedConversionCastPassthrough>(patterns.getContext());
 }
-
-std::unique_ptr<Pass> mlir::createReconcileUnrealizedCastsPass() {
-  return std::make_unique<ReconcileUnrealizedCasts>();
-}

mlir/lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp

 //===- SCFToControlFlow.cpp - SCF to CF conversion ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert scf.for, scf.if and loop.terminator
 // ops into standard CFG ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
-#include "../PassDetail.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSCFTOCONTROLFLOWPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 
-struct SCFToControlFlowPass
-    : public SCFToControlFlowBase<SCFToControlFlowPass> {
+struct ConvertSCFToControlFlowPass : public impl::ConvertSCFToControlFlowPassBase<ConvertSCFToControlFlowPass> {
+  using ConvertSCFToControlFlowPassBase::ConvertSCFToControlFlowPassBase;
+
   void runOnOperation() override;
 };
 
 // Create a CFG subgraph for the loop around its body blocks (if the body
 // contained other loops, they have been already lowered to a flow of blocks).
 // Maintain the invariants that a CFG subgraph created for any loop has a single
 // entry and a single exit, and that the entry/exit blocks are respectively
 // first/last blocks in the parent region.  The original loop operation is

 
 void mlir::populateSCFToControlFlowConversionPatterns(
     RewritePatternSet &patterns) {
   patterns.add<ForLowering, IfLowering, ParallelLowering, WhileLowering,
                ExecuteRegionLowering>(patterns.getContext());
   patterns.add<DoWhileLowering>(patterns.getContext(), /*benefit=*/2);
 }
 
-void SCFToControlFlowPass::runOnOperation() {
+void ConvertSCFToControlFlowPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   populateSCFToControlFlowConversionPatterns(patterns);
 
   // Configure conversion to lower out SCF operations.
   ConversionTarget target(getContext());
   target.addIllegalOp<scf::ForOp, scf::IfOp, scf::ParallelOp, scf::WhileOp,
                       scf::ExecuteRegionOp>();
   target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<Pass> mlir::createConvertSCFToCFPass() {
-  return std::make_unique<SCFToControlFlowPass>();
-}

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

 //===- SCFToGPUPass.cpp - Convert a loop nest to a GPU kernel -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/SCFToGPU/SCFToGPU.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
-
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/CommandLine.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTAFFINEFORTOGPUPASS
+#define GEN_PASS_DEF_CONVERTPARALLELLOOPTOGPUPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 // A pass that traverses top-level loops in the function and converts them to
 // GPU launch operations.  Nested launches are not allowed, so this does not
 // walk the function recursively to avoid considering nested loops.
-struct ForLoopMapper : public ConvertAffineForToGPUBase<ForLoopMapper> {
+struct ForLoopMapper
+    : public impl::ConvertAffineForToGPUPassBase<ForLoopMapper> {
   ForLoopMapper() = default;
   ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
     this->numBlockDims = numBlockDims;
     this->numThreadDims = numThreadDims;
   }
 
   void runOnOperation() override {
     for (Operation &op :
          llvm::make_early_inc_range(getOperation().getBody().getOps())) {
       if (auto forOp = dyn_cast<AffineForOp>(&op)) {
         if (failed(convertAffineLoopNestToGPULaunch(forOp, numBlockDims,
                                                     numThreadDims)))
           signalPassFailure();
       }
     }
   }
 };
 
 struct ParallelLoopToGpuPass
-    : public ConvertParallelLoopToGpuBase<ParallelLoopToGpuPass> {
+    : public impl::ConvertParallelLoopToGpuPassBase<ParallelLoopToGpuPass> {
+  using ConvertParallelLoopToGpuPassBase::ConvertParallelLoopToGpuPassBase;
+
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populateParallelLoopToGPUPatterns(patterns);
     ConversionTarget target(getContext());
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
     configureParallelLoopToGPULegality(target);
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
     finalizeParallelLoopToGPUConversion(getOperation());
   }
 };
 
 } // namespace
 
 std::unique_ptr<InterfacePass<FunctionOpInterface>>
 mlir::createAffineForToGPUPass(unsigned numBlockDims, unsigned numThreadDims) {
   return std::make_unique<ForLoopMapper>(numBlockDims, numThreadDims);
 }
 std::unique_ptr<InterfacePass<FunctionOpInterface>>
 mlir::createAffineForToGPUPass() {
   return std::make_unique<ForLoopMapper>();
 }
-
-std::unique_ptr<Pass> mlir::createParallelLoopToGpuPass() {
-  return std::make_unique<ParallelLoopToGpuPass>();
-}

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

 //===- SCFToOpenMP.cpp - Structured Control Flow to OpenMP conversion -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert scf.parallel operations into OpenMP
 // parallel loops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
-#include "../PassDetail.h"
+
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSCFTOOPENMPPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 /// Matches a block containing a "simple" reduction. The expected shape of the
 /// block is as follows.
 ///
 ///   ^bb(%arg0, %arg1):
 ///     %0 = OpTy(%arg0, %arg1)
 ///     scf.reduce.return %0
static LogicalResult applyPatterns(ModuleOp module) {
 
   RewritePatternSet patterns(module.getContext());
   patterns.add<ParallelOpLowering>(module.getContext());
   FrozenRewritePatternSet frozen(std::move(patterns));
   return applyPartialConversion(module, target, frozen);
 }
 
 /// A pass converting SCF operations to OpenMP operations.
-struct SCFToOpenMPPass : public ConvertSCFToOpenMPBase<SCFToOpenMPPass> {
+struct ConvertSCFToOpenMPPass : public impl::ConvertSCFToOpenMPPassBase<ConvertSCFToOpenMPPass> {
+  using ConvertSCFToOpenMPPassBase::ConvertSCFToOpenMPPassBase;
+
   /// Pass entry point.
   void runOnOperation() override {
     if (failed(applyPatterns(getOperation())))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertSCFToOpenMPPass() {
-  return std::make_unique<SCFToOpenMPPass>();
+  return std::make_unique<ConvertSCFToOpenMPPass>();
 }

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRVPass.cpp

 //===- SCFToSPIRVPass.cpp - SCF to SPIR-V Passes --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert SCF dialect into SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h"
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRV.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSCFTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct SCFToSPIRVPass : public SCFToSPIRVBase<SCFToSPIRVPass> {
+struct ConvertSCFToSPIRVPass
+    : public impl::ConvertSCFToSPIRVPassBase<ConvertSCFToSPIRVPass> {
+  using ConvertSCFToSPIRVPassBase::ConvertSCFToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void SCFToSPIRVPass::runOnOperation() {
+void ConvertSCFToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
   std::unique_ptr<ConversionTarget> target =
       SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   ScfToSPIRVContext scfContext;
   RewritePatternSet patterns(context);
   populateSCFToSPIRVPatterns(typeConverter, scfContext, patterns);
 
   // TODO: Change SPIR-V conversion to be progressive and remove the following
   // patterns.
   mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
   populateFuncToSPIRVPatterns(typeConverter, patterns);
   populateMemRefToSPIRVPatterns(typeConverter, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertSCFToSPIRVPass() {
-  return std::make_unique<SCFToSPIRVPass>();
+  return std::make_unique<ConvertSCFToSPIRVPass>();
 }

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

 //===- ConvertLaunchFuncToLLVMCalls.cpp - MLIR GPU launch to LLVM pass ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements passes to convert `gpu.launch_func` op into a sequence
 // of LLVM calls that emulate the host and device sides.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
+#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
+
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/LoweringOptions.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
-#include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/SymbolTable.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
-
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LOWERHOSTCODETOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static constexpr const char kSPIRVModule[] = "__spv__";
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
matchAndRewrite(gpu::LaunchFuncOp launchOp, OpAdaptor adaptor,
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(op, kernelFunc,
                                               ArrayRef<Value>());
     for (CopyInfo info : copyInfo)
       copy(loc, info.src, info.dst, info.size, rewriter);
     return success();
   }
 };
 
-class LowerHostCodeToLLVM
-    : public LowerHostCodeToLLVMBase<LowerHostCodeToLLVM> {
+class LowerHostCodeToLLVMPass
+    : public impl::LowerHostCodeToLLVMPassBase<LowerHostCodeToLLVMPass> {
 public:
+  using LowerHostCodeToLLVMPassBase::LowerHostCodeToLLVMPassBase;
+
   void runOnOperation() override {
     ModuleOp module = getOperation();
 
     // Erase the GPU module.
     for (auto gpuModule :
          llvm::make_early_inc_range(module.getOps<gpu::GPUModuleOp>()))
       gpuModule.erase();
 
void runOnOperation() override {
     for (auto spvModule : module.getOps<spirv::ModuleOp>())
       (void)encodeKernelName(spvModule);
   }
 };
 } // namespace
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createLowerHostCodeToLLVMPass() {
-  return std::make_unique<LowerHostCodeToLLVM>();
+  return std::make_unique<LowerHostCodeToLLVMPass>();
 }

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.cpp

 //===- SPIRVToLLVMPass.cpp - SPIR-V to LLVM Passes ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert MLIR SPIR-V ops into LLVM ops
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Conversion/SPIRVToLLVM/SPIRVToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSPIRVTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR SPIR-V operations into LLVM dialect.
 class ConvertSPIRVToLLVMPass
-    : public ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> {
+    : public impl::ConvertSPIRVToLLVMPassBase<ConvertSPIRVToLLVMPass> {
+  using ConvertSPIRVToLLVMPassBase::ConvertSPIRVToLLVMPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertSPIRVToLLVMPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
   LLVMTypeConverter converter(&getContext());

mlir/lib/Conversion/ShapeToStandard/ConvertShapeConstraints.cpp

 //===- ConvertShapeConstraints.cpp - Conversion of shape constraints ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSHAPECONSTRAINTSPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
+
 namespace {
 #include "ShapeToStandard.cpp.inc"
 } // namespace
 
 namespace {
 class ConvertCstrRequireOp : public OpRewritePattern<shape::CstrRequireOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
void mlir::populateConvertShapeConstraintsConversionPatterns(
   patterns.add<ConvertCstrRequireOp>(patterns.getContext());
 }
 
 namespace {
 // This pass eliminates shape constraints from the program, converting them to
 // eager (side-effecting) error handling code. After eager error handling code
 // is emitted, witnesses are satisfied, so they are replace with
 // `shape.const_witness true`.
-class ConvertShapeConstraints
-    : public ConvertShapeConstraintsBase<ConvertShapeConstraints> {
+class ConvertShapeConstraintsPass
+    : public impl::ConvertShapeConstraintsPassBase<
+          ConvertShapeConstraintsPass> {
+  using ConvertShapeConstraintsPassBase::ConvertShapeConstraintsPassBase;
+
   void runOnOperation() override {
     auto *func = getOperation();
     auto *context = &getContext();
 
     RewritePatternSet patterns(context);
     populateConvertShapeConstraintsConversionPatterns(patterns);
 
     if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createConvertShapeConstraintsPass() {
-  return std::make_unique<ConvertShapeConstraints>();
-}

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

 //===- ShapeToStandard.cpp - conversion from Shape to Standard dialect ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/ShapeToStandard/ShapeToStandard.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTSHAPETOSTANDARDPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::shape;
 using namespace mlir::scf;
 
 /// Conversion patterns.
 namespace {
 class AnyOpConversion : public OpConversionPattern<AnyOp> {
 public:

 
 namespace {
 /// Import the Shape Ops to Std Patterns.
 #include "ShapeToStandard.cpp.inc"
 } // namespace
 
 namespace {
 /// Conversion pass.
-class ConvertShapeToStandardPass
-    : public ConvertShapeToStandardBase<ConvertShapeToStandardPass> {
+class ConvertShapeToStandardPass : public impl::ConvertShapeToStandardPassBase<ConvertShapeToStandardPass> {
+  using ConvertShapeToStandardPassBase::ConvertShapeToStandardPassBase;
 
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertShapeToStandardPass::runOnOperation() {
   // Setup target legality.
   MLIRContext &ctx = getContext();

mlir/lib/Conversion/TensorToLinalg/TensorToLinalgPass.cpp

 //===- TensorToLinalgPass.cpp - Tensor to Linalg Passes -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert Tensor dialect to Linalg dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/TensorToLinalg/TensorToLinalgPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/TensorToLinalg/TensorToLinalg.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTENSORTOLINALGPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Tensor operations into the Linalg dialect.
 class ConvertTensorToLinalgPass
-    : public ConvertTensorToLinalgBase<ConvertTensorToLinalgPass> {
+    : public impl::ConvertTensorToLinalgPassBase<ConvertTensorToLinalgPass> {
+  using ConvertTensorToLinalgPassBase::ConvertTensorToLinalgPassBase;
+
   void runOnOperation() override {
     auto &context = getContext();
     ConversionTarget target(context);
     target.addLegalDialect<mlir::arith::ArithmeticDialect,
                            mlir::linalg::LinalgDialect,
                            mlir::tensor::TensorDialect>();
     target.addIllegalOp<mlir::tensor::PadOp>();
 

mlir/lib/Conversion/TensorToSPIRV/TensorToSPIRVPass.cpp

 //===- TensorToSPIRVPass.cpp - Tensor to SPIR-V Passes ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert Tensor dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRVPass.h"
-#include "../PassDetail.h"
+
 #include "mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h"
 #include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Conversion/TensorToSPIRV/TensorToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTENSORTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A pass converting MLIR Tensor operations into the SPIR-V dialect.
 class ConvertTensorToSPIRVPass
-    : public ConvertTensorToSPIRVBase<ConvertTensorToSPIRVPass> {
+    : public impl::ConvertTensorToSPIRVPassBase<ConvertTensorToSPIRVPass> {
+  using ConvertTensorToSPIRVPassBase::ConvertTensorToSPIRVPassBase;
+
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     Operation *op = getOperation();
 
     auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
     std::unique_ptr<ConversionTarget> target =
         SPIRVConversionTarget::get(targetAttr);
 

mlir/lib/Conversion/TosaToArith/TosaToArithPass.cpp

 //===- TosaToArithPass.cpp - Lowering Tosa to Linalg Dialect -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass legalizes Tosa operations to the Arith dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/TosaToArith/TosaToArith.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTOSATOARITHPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace tosa;
 
 namespace {
-struct TosaToArith : public TosaToArithBase<TosaToArith> {
+struct ConvertTosaToArithPass
+    : public impl::ConvertTosaToArithPassBase<ConvertTosaToArithPass> {
 public:
+  using ConvertTosaToArithPassBase::ConvertTosaToArithPassBase;
+
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addIllegalOp<tosa::ConstOp>();
     target.addLegalDialect<arith::ArithmeticDialect>();
 
     mlir::tosa::populateTosaToArithConversionPatterns(&patterns);
 
     if (this->includeApplyRescale) {
       mlir::tosa::populateTosaRescaleToArithConversionPatterns(&patterns,
                                                                this->use32Bit);
       target.addIllegalOp<tosa::ApplyScaleOp>();
     }
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaToArith() {
-  return std::make_unique<TosaToArith>();
-}

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamedPass.cpp

 //===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass legalizes Tosa operations to the Linalg dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTOSATOLINALGNAMEDPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct TosaToLinalgNamed : public TosaToLinalgNamedBase<TosaToLinalgNamed> {
+struct ConvertTosaToLinalgNamedPass
+    : public impl::ConvertTosaToLinalgNamedPassBase<
+          ConvertTosaToLinalgNamedPass> {
 public:
+  using ConvertTosaToLinalgNamedPassBase::ConvertTosaToLinalgNamedPassBase;
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<arith::ArithmeticDialect, linalg::LinalgDialect,
                 math::MathDialect, tensor::TensorDialect, scf::SCFDialect>();
   }
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
void runOnOperation() override {
 
     FunctionOpInterface func = getOperation();
     mlir::tosa::populateTosaToLinalgNamedConversionPatterns(&patterns);
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaToLinalgNamed() {
-  return std::make_unique<TosaToLinalgNamed>();
-}

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgPass.cpp

 //===- TosaToLinalgPass.cpp - Lowering Tosa to Linalg Dialect -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass legalizes Tosa operations to the Linalg dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/TosaToLinalg/TosaToLinalg.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTOSATOLINALGPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct TosaToLinalg : public TosaToLinalgBase<TosaToLinalg> {
+struct ConvertTosaToLinalgPass
+    : public impl::ConvertTosaToLinalgPassBase<ConvertTosaToLinalgPass> {
 public:
+  using ConvertTosaToLinalgPassBase::ConvertTosaToLinalgPassBase;
+
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<arith::ArithmeticDialect, linalg::LinalgDialect,
                 math::MathDialect, tensor::TensorDialect, scf::SCFDialect>();
   }
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
void runOnOperation() override {
     FunctionOpInterface func = getOperation();
     mlir::tosa::populateTosaToLinalgConversionPatterns(&patterns);
     if (failed(applyFullConversion(func, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaToLinalg() {
-  return std::make_unique<TosaToLinalg>();
-}
-
 void mlir::tosa::addTosaToLinalgPasses(OpPassManager &pm,
                                        bool disableTosaDecompositions) {
   // Optional decompositions are designed to benefit linalg.
   if (!disableTosaDecompositions)
-    pm.addNestedPass<func::FuncOp>(tosa::createTosaOptionalDecompositions());
+    pm.addNestedPass<func::FuncOp>(
+        tosa::createTosaOptionalDecompositionsPass());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
 
   pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
-  pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalgNamed());
+  pm.addNestedPass<func::FuncOp>(createConvertTosaToLinalgNamedPass());
   pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
   // TODO: Remove pass that operates on const tensor and enable optionality
   pm.addNestedPass<func::FuncOp>(tosa::createTosaLayerwiseConstantFoldPass());
   pm.addNestedPass<func::FuncOp>(tosa::createTosaMakeBroadcastablePass());
-  pm.addNestedPass<func::FuncOp>(tosa::createTosaToLinalg());
+  pm.addNestedPass<func::FuncOp>(createConvertTosaToLinalgPass());
 }

mlir/lib/Conversion/TosaToSCF/TosaToSCFPass.cpp

 //===- TosaToSCFPass.cpp - Lowering Tosa to SCF Dialect -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass legalizes Tosa operations to the SCF dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/TosaToSCF/TosaToSCF.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTOSATOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace tosa;
 
 namespace {
-struct TosaToSCF : public TosaToSCFBase<TosaToSCF> {
+struct TosaToSCF : public impl::ConvertTosaToSCFPassBase<TosaToSCF> {
 public:
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addLegalDialect<tensor::TensorDialect, scf::SCFDialect>();
     target.addIllegalOp<tosa::IfOp, tosa::WhileOp>();
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
 
     auto *op = getOperation();
     mlir::tosa::populateTosaToSCFConversionPatterns(&patterns);
     if (failed(applyPartialConversion(op, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<Pass> mlir::tosa::createTosaToSCF() {
-  return std::make_unique<TosaToSCF>();
-}
-
 void mlir::tosa::addTosaToSCFPasses(OpPassManager &pm) {
-  pm.addNestedPass<func::FuncOp>(createTosaToSCF());
+  pm.addNestedPass<func::FuncOp>(createConvertTosaToSCFPass());
 }

mlir/lib/Conversion/TosaToTensor/TosaToTensorPass.cpp

 //===- TosaToTensorPass.cpp - Lowering Tosa to Tensor Dialect -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass legalizes Tosa operations to the Tensor dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/TosaToTensor/TosaToTensor.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTTOSATOTENSORPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace tosa;
 
 namespace {
-struct TosaToTensor : public TosaToTensorBase<TosaToTensor> {
+struct ConvertTosaToTensorPass
+    : public impl::ConvertTosaToTensorPassBase<ConvertTosaToTensorPass> {
 public:
+  using ConvertTosaToTensorPassBase::ConvertTosaToTensorPassBase;
+
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
     target.addIllegalOp<tosa::SliceOp>();
     target.addLegalDialect<arith::ArithmeticDialect>();
     target.addLegalDialect<tensor::TensorDialect>();
 
     mlir::tosa::populateTosaToTensorConversionPatterns(&patterns);
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaToTensor() {
-  return std::make_unique<TosaToTensor>();
-}

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "NvGpuSupport.h"
 #include "mlir/Conversion/VectorToGPU/VectorToGPU.h"
 
-#include "../PassDetail.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTVECTORTOGPUPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 /// For a vector TransferOpType `xferOp`, an empty `indices` vector, and an
 /// AffineMap representing offsets to apply to indices, the function fills
 /// `indices` with the original indices plus the offsets. The offsets are
 /// applied by taking into account the permutation map of the transfer op. If
 /// the `offsetMap` has dimension placeholders, those should be provided in
 /// `dimValues`.
for (Operation *op : ops) {
     }
   }
   return success();
 }
 
 namespace {
 
 struct ConvertVectorToGPUPass
-    : public ConvertVectorToGPUBase<ConvertVectorToGPUPass> {
+    : public impl::ConvertVectorToGPUPassBase<ConvertVectorToGPUPass> {
 
   explicit ConvertVectorToGPUPass(bool useNvGpu_) {
     useNvGpu.setValue(useNvGpu_);
   }
 
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     populatePrepareVectorToMMAPatterns(patterns, useNvGpu.getValue());

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVMPass.cpp

 //===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 
-#include "../PassDetail.h"
-
 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Dialect/AMX/AMXDialect.h"
 #include "mlir/Dialect/AMX/Transforms.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
 #include "mlir/Dialect/ArmSVE/ArmSVEDialect.h"
 #include "mlir/Dialect/ArmSVE/Transforms.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
 #include "mlir/Dialect/X86Vector/Transforms.h"
 #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTVECTORTOLLVMPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::vector;
 
 namespace {
-struct LowerVectorToLLVMPass
-    : public ConvertVectorToLLVMBase<LowerVectorToLLVMPass> {
-  LowerVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
+struct ConvertVectorToLLVMPass
+    : public impl::ConvertVectorToLLVMPassBase<ConvertVectorToLLVMPass> {
+  ConvertVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
     this->reassociateFPReductions = options.reassociateFPReductions;
     this->force32BitVectorIndices = options.force32BitVectorIndices;
     this->armNeon = options.armNeon;
     this->armSVE = options.armSVE;
     this->amx = options.amx;
     this->x86Vector = options.x86Vector;
   }
   // Override explicitly to allow conditional dialect dependence.
if (amx)
       registry.insert<amx::AMXDialect>();
     if (x86Vector)
       registry.insert<x86vector::X86VectorDialect>();
   }
   void runOnOperation() override;
 };
 } // namespace
 
-void LowerVectorToLLVMPass::runOnOperation() {
+void ConvertVectorToLLVMPass::runOnOperation() {
   // Perform progressive lowering of operations on slices and
   // all contraction operations. Also applies folding and DCE.
   {
     RewritePatternSet patterns(&getContext());
     populateVectorToVectorCanonicalizationPatterns(patterns);
     populateVectorBroadcastLoweringPatterns(patterns);
     populateVectorContractLoweringPatterns(patterns);
     populateVectorMaskOpLoweringPatterns(patterns);
void ConvertVectorToLLVMPass::runOnOperation() {
 
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertVectorToLLVMPass(const LowerVectorToLLVMOptions &options) {
-  return std::make_unique<LowerVectorToLLVMPass>(options);
+  return std::make_unique<ConvertVectorToLLVMPass>(options);
 }

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

 //===- VectorToSCF.cpp - Convert vector to SCF dialect ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements lowering of vector transfer operations to SCF.
 //
 //===----------------------------------------------------------------------===//
 
 #include <type_traits>
 
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTVECTORTOSCFPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using vector::TransferReadOp;
 using vector::TransferWriteOp;
 
 namespace {
 
 /// Attribute name used for labeling transfer ops during progressive lowering.
 static const char kPassLabel[] = "__vector_to_scf_lowering__";
patterns.add<lowering_1_d::TransferOp1dConversion<TransferReadOp>,
                  lowering_1_d::TransferOp1dConversion<TransferWriteOp>>(
         patterns.getContext(), options);
   }
 }
 
 namespace {
 
 struct ConvertVectorToSCFPass
-    : public ConvertVectorToSCFBase<ConvertVectorToSCFPass> {
+    : public impl::ConvertVectorToSCFPassBase<ConvertVectorToSCFPass> {
   ConvertVectorToSCFPass() = default;
   ConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
     this->fullUnroll = options.unroll;
     this->targetRank = options.targetRank;
     this->lowerPermutationMaps = options.lowerPermutationMaps;
     this->lowerTensors = options.lowerTensors;
   }
 

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

 //===- VectorToSPIRV.cpp - Vector to SPIR-V Patterns ----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns to convert Vector dialect to SPIRV dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/VectorToSPIRV/VectorToSPIRV.h"
 
-#include "../PassDetail.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/DialectConversion.h"

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRVPass.cpp

 //===- VectorToSPIRVPass.cpp - Vector to SPIR-V Passes --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert Vector dialect to SPIRV dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Conversion/VectorToSPIRV/VectorToSPIRVPass.h"
 
-#include "../PassDetail.h"
 #include "mlir/Conversion/VectorToSPIRV/VectorToSPIRV.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTVECTORTOSPIRVPASS
+#include "mlir/Conversion/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 struct ConvertVectorToSPIRVPass
-    : public ConvertVectorToSPIRVBase<ConvertVectorToSPIRVPass> {
+    : public impl::ConvertVectorToSPIRVPassBase<ConvertVectorToSPIRVPass> {
+  using ConvertVectorToSPIRVPassBase::ConvertVectorToSPIRVPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertVectorToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   Operation *op = getOperation();
 

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

 // reuse, results in near elimination of conflict misses, TLB misses, reduced
 // use of hardware prefetch streams, and reduced false sharing. It is also
 // necessary for hardware that explicitly managed levels in the memory
 // hierarchy, and where DMAs may have to be used. This optimization is often
 // performed on already tiled code.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <algorithm>
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEDATACOPYGENERATIONPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "affine-data-copy-generate"
 
 using namespace mlir;
 
 namespace {
 
 /// Replaces all loads and stores on memref's living in 'slowMemorySpace' by
 /// introducing copy operations to transfer data into `fastMemorySpace` and
 /// rewriting the original load's/store's to instead load/store from the
 /// allocated fast memory buffers. Additional options specify the identifier
 /// corresponding to the fast memory space and the amount of fast memory space
 /// available. The pass traverses through the nesting structure, recursing to
 /// inner levels if necessary to determine at what depth copies need to be
 /// placed so that the allocated buffers fit within the memory capacity
 /// provided.
 // TODO: We currently can't generate copies correctly when stores
 // are strided. Check for strided stores.
-struct AffineDataCopyGeneration
-    : public AffineDataCopyGenerationBase<AffineDataCopyGeneration> {
-  AffineDataCopyGeneration() = default;
-  explicit AffineDataCopyGeneration(unsigned slowMemorySpace,
+struct AffineDataCopyGenerationPass
+    : public impl::AffineDataCopyGenerationPassBase<AffineDataCopyGenerationPass> {
+  AffineDataCopyGenerationPass() = default;
+  explicit AffineDataCopyGenerationPass(unsigned slowMemorySpace,
                                         unsigned fastMemorySpace,
                                         unsigned tagMemorySpace,
                                         int minDmaTransferSize,
                                         uint64_t fastMemCapacityBytes) {
     this->slowMemorySpace = slowMemorySpace;
     this->fastMemorySpace = fastMemorySpace;
     this->tagMemorySpace = tagMemorySpace;
     this->minDmaTransferSize = minDmaTransferSize;
     this->fastMemoryCapacity = fastMemCapacityBytes / 1024;
   }
 
   void runOnOperation() override;

 /// by the latter. Only load op's handled for now.
 /// TODO: extend this to store op's.
 std::unique_ptr<OperationPass<func::FuncOp>>
 mlir::createAffineDataCopyGenerationPass(unsigned slowMemorySpace,
                                          unsigned fastMemorySpace,
                                          unsigned tagMemorySpace,
                                          int minDmaTransferSize,
                                          uint64_t fastMemCapacityBytes) {
-  return std::make_unique<AffineDataCopyGeneration>(
+  return std::make_unique<AffineDataCopyGenerationPass>(
       slowMemorySpace, fastMemorySpace, tagMemorySpace, minDmaTransferSize,
       fastMemCapacityBytes);
 }
 std::unique_ptr<OperationPass<func::FuncOp>>
 mlir::createAffineDataCopyGenerationPass() {
-  return std::make_unique<AffineDataCopyGeneration>();
+  return std::make_unique<AffineDataCopyGenerationPass>();
 }
 
 /// Generate copies for this block. The block is partitioned into separate
 /// ranges: each range is either a sequence of one or more operations starting
 /// and ending with an affine load or store op, or just an affine.forop (which
 /// could have other affine for op's nested within).
-void AffineDataCopyGeneration::runOnBlock(Block *block,
-                                          DenseSet<Operation *> &copyNests) {
+void AffineDataCopyGenerationPass::runOnBlock(Block *block, DenseSet<Operation *> &copyNests) {
   if (block->empty())
     return;
 
   uint64_t fastMemCapacityBytes =
       fastMemoryCapacity != std::numeric_limits<uint64_t>::max()
           ? fastMemoryCapacity * 1024
           : fastMemoryCapacity;
   AffineCopyOptions copyOptions = {generateDma, slowMemorySpace,
assert(!curBegin->hasTrait<OpTrait::IsTerminator>() &&
            "can't be a terminator");
     // Exclude the affine.yield - hence, the std::prev.
     (void)affineDataCopyGenerate(/*begin=*/curBegin,
                                  /*end=*/std::prev(block->end()), copyOptions,
                                  /*filterMemRef=*/llvm::None, copyNests);
   }
 }
 
-void AffineDataCopyGeneration::runOnOperation() {
+void AffineDataCopyGenerationPass::runOnOperation() {
   func::FuncOp f = getOperation();
   OpBuilder topBuilder(f.getBody());
   zeroIndex = topBuilder.create<arith::ConstantIndexOp>(f.getLoc(), 0);
 
   // Nests that are copy-in's or copy-out's; the root AffineForOps of those
   // nests are stored herein.
   DenseSet<Operation *> copyNests;
 

mlir/lib/Dialect/Affine/Transforms/AffineExpandIndexOps.cpp

 //===- AffineExpandIndexOps.cpp - Affine expand index ops pass ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to expand affine index ops into one or more more
 // fundamental operations.
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Passes.h"
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEEXPANDINDEXOPSPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Lowers `affine.delinearize_index` into a sequence of division and remainder
 /// operations.
 struct LowerDelinearizeIndexOps
     : public OpRewritePattern<AffineDelinearizeIndexOp> {
   using OpRewritePattern<AffineDelinearizeIndexOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(AffineDelinearizeIndexOp op,
                                 PatternRewriter &rewriter) const override {
     FailureOr<SmallVector<Value>> multiIndex =
         delinearizeIndex(rewriter, op->getLoc(), op.getLinearIndex(),
                          llvm::to_vector(op.getBasis()));
     if (failed(multiIndex))
       return failure();
     rewriter.replaceOp(op, *multiIndex);
     return success();
   }
 };
 
 class ExpandAffineIndexOpsPass
-    : public AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
+    : public impl::AffineExpandIndexOpsPassBase<ExpandAffineIndexOpsPass> {
 public:
   ExpandAffineIndexOpsPass() = default;
 
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);
     populateAffineExpandIndexOpsPatterns(patterns);
     if (failed(

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

 //===- AffineLoopInvariantCodeMotion.cpp - Code to perform loop fusion-----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop invariant code motion.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPINVARIANTCODEMOTIONPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "licm"
 
 using namespace mlir;
 
 namespace {
 
 /// Loop invariant code motion (LICM) pass.
 /// TODO: The pass is missing zero-trip tests.
 /// TODO: Check for the presence of side effects before hoisting.
 /// TODO: This code should be removed once the new LICM pass can handle its
 ///       uses.
 struct LoopInvariantCodeMotion
-    : public AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+    : public impl::AffineLoopInvariantCodeMotionPassBase<
+          LoopInvariantCodeMotion> {
   void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 };
 } // namespace
 
 static bool
 checkInvarianceOfNestedIfOps(Operation *op, Value indVar, ValueRange iterArgs,
                              SmallPtrSetImpl<Operation *> &opsWithUsers,

mlir/lib/Dialect/Affine/Transforms/AffineLoopNormalize.cpp

 //===- AffineLoopNormalize.cpp - AffineLoopNormalize Pass -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a normalizer for affine loop-like ops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPNORMALIZEPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 /// Normalize affine.parallel ops so that lower bounds are 0 and steps are 1.
 /// As currently implemented, this pass cannot fail, but it might skip over ops
 /// that are already in a normalized form.
 struct AffineLoopNormalizePass
-    : public AffineLoopNormalizeBase<AffineLoopNormalizePass> {
+    : public impl::AffineLoopNormalizePassBase<AffineLoopNormalizePass> {
 
   void runOnOperation() override {
     getOperation().walk([](Operation *op) {
       if (auto affineParallel = dyn_cast<AffineParallelOp>(op))
         normalizeAffineParallel(affineParallel);
       else if (auto affineFor = dyn_cast<AffineForOp>(op))
         (void)normalizeAffineFor(affineFor);
     });

mlir/lib/Dialect/Affine/Transforms/AffineParallelize.cpp

 //===- AffineParallelize.cpp - Affineparallelize Pass---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a parallelizer for affine loop nests that is able to
 // perform inner or outer loop parallelization.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Affine/Passes.h.inc"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "llvm/Support/Debug.h"
 #include <deque>
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEPARALLELIZEPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "affine-parallel"
 
 using namespace mlir;
 
 namespace {
 /// Convert all parallel affine.for op into 1-D affine.parallel op.
-struct AffineParallelize : public AffineParallelizeBase<AffineParallelize> {
+struct AffineParallelize
+    : public impl::AffineParallelizePassBase<AffineParallelize> {
   void runOnOperation() override;
 };
 
 /// Descriptor of a potentially parallelizable loop.
 struct ParallelizationCandidate {
   ParallelizationCandidate(AffineForOp l, SmallVector<LoopReduction> &&r)
       : loop(l), reductions(std::move(r)) {}
 

mlir/lib/Dialect/Affine/Transforms/AffineScalarReplacement.cpp

 // redundant loads.
 // TODO: In the future, similar techniques could be used to eliminate
 // dead memref store's and perform more complex forwarding when support for
 // SSA scalars live out of 'affine.for'/'affine.if' statements is available.
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/Passes.h"
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Support/LogicalResult.h"
 #include <algorithm>
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINESCALARREPLACEMENTPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "affine-scalrep"
 
 using namespace mlir;
 
 namespace {
 struct AffineScalarReplacement
-    : public AffineScalarReplacementBase<AffineScalarReplacement> {
+    : public impl::AffineScalarReplacementPassBase<AffineScalarReplacement> {
   void runOnOperation() override;
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
 mlir::createAffineScalarReplacementPass() {
   return std::make_unique<AffineScalarReplacement>();
 }
 
 void AffineScalarReplacement::runOnOperation() {
   affineScalarReplace(getOperation(), getAnalysis<DominanceInfo>(),
                       getAnalysis<PostDominanceInfo>());
 }

mlir/lib/Dialect/Affine/Transforms/LoopCoalescing.cpp

 //===- LoopCoalescing.cpp - Pass transforming loop nests into single loops-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LOOPCOALESCINGPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define PASS_NAME "loop-coalescing"
 #define DEBUG_TYPE PASS_NAME
 
 using namespace mlir;
 
 namespace {
-struct LoopCoalescingPass : public LoopCoalescingBase<LoopCoalescingPass> {
+struct LoopCoalescingPass
+    : public impl::LoopCoalescingPassBase<LoopCoalescingPass> {
 
   /// Walk either an scf.for or an affine.for to find a band to coalesce.
   template <typename LoopOpTy>
   static void walkLoop(LoopOpTy op) {
     // Ignore nested loops.
     if (op->template getParentOfType<LoopOpTy>())
       return;
 

mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp

 //===- LoopFusion.cpp - Code to perform loop fusion -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop fusion.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopFusionUtils.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iomanip>
 #include <sstream>
+
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPFUSIONPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "affine-loop-fusion"
 
 using namespace mlir;
 
 namespace {
 /// Loop fusion pass. This pass currently supports a greedy fusion policy,
 /// which fuses loop nests with single-writer/single-reader memref dependences
 /// with the goal of improving locality.
 
 // TODO: Support fusion of source loop nests which write to multiple
 // memrefs, where each memref can have multiple users (if profitable).
 // TODO: Extend this pass to check for fusion preventing dependences,
 // and add support for more general loop fusion algorithms.
 
-struct LoopFusion : public AffineLoopFusionBase<LoopFusion> {
+struct LoopFusion : public impl::AffineLoopFusionPassBase<LoopFusion> {
   LoopFusion() = default;
   LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
              bool maximalFusion, enum FusionMode affineFusionMode) {
     this->fastMemorySpace = fastMemorySpace;
     this->localBufSizeThreshold = localBufSizeThresholdBytes / 1024;
     this->maximalFusion = maximalFusion;
     this->affineFusionMode = affineFusionMode;
   }

mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp

 //===- LoopTiling.cpp --- Loop tiling pass ------------------------------*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to tile loop nests.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/IR/AffineValueMap.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-using namespace mlir;
+
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPTILINGPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-tile"
 
+using namespace mlir;
+
 namespace {
 
 /// A pass to perform loop tiling on all suitable loop nests of a Function.
-struct LoopTiling : public AffineLoopTilingBase<LoopTiling> {
+struct LoopTiling : public impl::AffineLoopTilingPassBase<LoopTiling> {
   LoopTiling() = default;
   explicit LoopTiling(uint64_t cacheSizeBytes, bool avoidMaxMinBounds = true)
       : avoidMaxMinBounds(avoidMaxMinBounds) {
     this->cacheSizeInKiB = cacheSizeBytes / 1024;
   }
 
   void runOnOperation() override;
   void getTileSizes(ArrayRef<AffineForOp> band,

mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp

 //===- LoopUnroll.cpp - Code to perform loop unrolling --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop unrolling.
 //
 //===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
-using namespace mlir;
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPUNROLLPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-unroll"
 
+using namespace mlir;
+
 namespace {
 
 // TODO: this is really a test pass and should be moved out of dialect
 // transforms.
 
 /// Loop unrolling pass. Unrolls all innermost loops unless full unrolling and a
 /// full unroll threshold was specified, in which case, fully unrolls all loops
 /// with trip count less than the specified threshold. The latter is for testing
 /// purposes, especially for testing outer loop unrolling.
-struct LoopUnroll : public AffineLoopUnrollBase<LoopUnroll> {
+struct LoopUnroll : public impl::AffineLoopUnrollPassBase<LoopUnroll> {
   // Callback to obtain unroll factors; if this has a callable target, takes
   // precedence over command-line argument or passed argument.
   const std::function<unsigned(AffineForOp)> getUnrollFactor;
 
   LoopUnroll() : getUnrollFactor(nullptr) {}
   LoopUnroll(const LoopUnroll &other)
 
       = default;

mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp

 //               S6(i);
 //               S5(i+1);
 //               S6(i+1);
 //
 // Note: 'if/else' blocks are not jammed. So, if there are loops inside if
 // op's, bodies of those loops will not be jammed.
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
-#include "mlir/Dialect/Affine/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"
 
-using namespace mlir;
+namespace mlir {
+#define GEN_PASS_DEF_AFFINELOOPUNROLLANDJAMPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-unroll-jam"
 
+using namespace mlir;
+
 namespace {
 /// Loop unroll jam pass. Currently, this just unroll jams the first
 /// outer loop in a Function.
-struct LoopUnrollAndJam : public AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
+struct LoopUnrollAndJam
+    : public impl::AffineLoopUnrollAndJamPassBase<LoopUnrollAndJam> {
   explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = None) {
     if (unrollJamFactor)
       this->unrollJamFactor = *unrollJamFactor;
   }
 
   void runOnOperation() override;
 };
 } // namespace

mlir/lib/Dialect/Affine/Transforms/PassDetail.h

-//===- PassDetail.h - Affine Pass class details -----------------*- 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 DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Affine/Passes.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-// Forward declaration from Dialect.h
-template <typename ConcreteDialect>
-void registerDialect(DialectRegistry &registry);
-
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace linalg {
-class LinalgDialect;
-} // namespace linalg
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace vector {
-class VectorDialect;
-} // namespace vector
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Affine/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Affine/Transforms/PipelineDataTransfer.cpp

 //===- PipelineDataTransfer.cpp --- Pass for pipelining data movement ---*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to pipeline data transfers.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEPIPELINEDATATRANSFERPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "affine-pipeline-data-transfer"
 
 using namespace mlir;
 
 namespace {
 struct PipelineDataTransfer
-    : public AffinePipelineDataTransferBase<PipelineDataTransfer> {
+    : public impl::AffinePipelineDataTransferPassBase<PipelineDataTransfer> {
   void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 
   std::vector<AffineForOp> forOps;
 };
 
 } // namespace
 

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

 //===- SimplifyAffineStructures.cpp ---------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to simplify affine structures in operations.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SIMPLIFYAFFINESTRUCTURESPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "simplify-affine-structure"
 
 using namespace mlir;
 
 namespace {
 
 /// Simplifies affine maps and sets appearing in the operations of the Function.
 /// This part is mainly to test the simplifyAffineExpr method. In addition,
 /// all memrefs with non-trivial layout maps are converted to ones with trivial
 /// identity layout ones.
 struct SimplifyAffineStructures
-    : public SimplifyAffineStructuresBase<SimplifyAffineStructures> {
+    : public impl::SimplifyAffineStructuresPassBase<SimplifyAffineStructures> {
   void runOnOperation() override;
 
   /// Utility to simplify an affine attribute and update its entry in the parent
   /// operation if necessary.
   template <typename AttributeT>
   void simplifyAndUpdateAttribute(Operation *op, StringAttr name,
                                   AttributeT attr) {
     auto &simplified = simplifiedAttributes[attr];

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

 //===- SuperVectorize.cpp - Vectorize Pass Impl ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements vectorization of loops, operations and data types to
 // a target-independent, n-D super-vector abstraction.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Affine/Passes.h"
+
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"
 #include "mlir/Dialect/Affine/Analysis/NestedMatcher.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Utils/VectorUtils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_AFFINEVECTORIZEPASS
+#include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace vector;
 
 ///
 /// Implements a high-level vectorization strategy on a Function.
 /// The abstraction used is that of super-vectors, which provide a single,
 /// compact, representation in the vector types, information that is expected
 /// to reduce the impact of the phase ordering problem
static NestedPattern &vectorTransferPattern() {
   });
   return pattern;
 }
 
 namespace {
 
 /// Base state for the vectorize pass.
 /// Command line arguments are preempted by non-empty pass arguments.
-struct Vectorize : public AffineVectorizeBase<Vectorize> {
+struct Vectorize : public impl::AffineVectorizePassBase<Vectorize> {
   Vectorize() = default;
   Vectorize(ArrayRef<int64_t> virtualVectorSize);
   void runOnOperation() override;
 };
 
 } // namespace
 
 Vectorize::Vectorize(ArrayRef<int64_t> virtualVectorSize) {

mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization for Arithmetic ops ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Arithmetic/Transforms/BufferizableOpInterfaceImpl.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 
+namespace mlir {
+namespace arith {
+#define GEN_PASS_DEF_ARITHMETICBUFFERIZEPASS
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+} // namespace arith
+} // namespace mlir
+
 using namespace mlir;
 using namespace bufferization;
 
 namespace {
 /// Pass to bufferize Arithmetic ops.
 struct ArithmeticBufferizePass
-    : public ArithmeticBufferizeBase<ArithmeticBufferizePass> {
+    : public arith::impl::ArithmeticBufferizePassBase<ArithmeticBufferizePass> {
   ArithmeticBufferizePass(uint64_t alignment = 0, bool constantOpOnly = false)
       : constantOpOnly(constantOpOnly) {
     this->alignment = alignment;
   }
 
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     if (constantOpOnly) {

mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp

 //===- ExpandOps.cpp - Pass to legalize Arithmetic ops for LLVM lowering --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+
+#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+namespace arith {
+#define GEN_PASS_DEF_ARITHMETICEXPANDOPSPASS
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+} // namespace arith
+} // namespace mlir
+
 using namespace mlir;
 
 /// Create an integer or index constant.
 static Value createConst(Location loc, Type type, int value,
                          PatternRewriter &rewriter) {
   return rewriter.create<arith::ConstantOp>(
       loc, rewriter.getIntegerAttr(type, value));
 }
LogicalResult matchAndRewrite(OpTy op,
     Location loc = op.getLoc();
     Value cmp = rewriter.create<arith::CmpIOp>(loc, pred, lhs, rhs);
     rewriter.replaceOpWithNewOp<arith::SelectOp>(op, cmp, lhs, rhs);
     return success();
   }
 };
 
 struct ArithmeticExpandOpsPass
-    : public ArithmeticExpandOpsBase<ArithmeticExpandOpsPass> {
+    : public arith::impl::ArithmeticExpandOpsPassBase<ArithmeticExpandOpsPass> {
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     ConversionTarget target(getContext());
 
     arith::populateArithmeticExpandOpsPatterns(patterns);
 
     target.addLegalDialect<arith::ArithmeticDialect>();
     // clang-format off

mlir/lib/Dialect/Arithmetic/Transforms/PassDetail.h

-//===- PassDetail.h - Arithmetic Pass details -------------------*- 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 DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace func {
-class FuncDialect;
-} // namespace func
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp

 //===- UnsignedWhenEquivalent.cpp - Pass to replace signed operations with
 // unsigned
 // ones when all their arguments and results are statically non-negative --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
+
 #include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
 #include "mlir/Analysis/DataFlow/IntegerRangeAnalysis.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
-#include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+namespace arith {
+#define GEN_PASS_DEF_ARITHMETICUNSIGNEDWHENEQUIVALENTPASS
+#include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
+} // namespace arith
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::arith;
 using namespace mlir::dataflow;
 
 /// Succeeds when a value is statically non-negative in that it has a lower
 /// bound on its value (if it is treated as signed) and that bound is
 /// non-negative.
 static LogicalResult staticallyNonNegative(DataFlowSolver &solver, Value v) {
LogicalResult matchAndRewrite(CmpIOp op, CmpIOpAdaptor adaptor,
                                 ConversionPatternRewriter &rw) const override {
     rw.replaceOpWithNewOp<CmpIOp>(op, toUnsignedPred(op.getPredicate()),
                                   op.getLhs(), op.getRhs());
     return success();
   }
 };
 
 struct ArithmeticUnsignedWhenEquivalentPass
-    : public ArithmeticUnsignedWhenEquivalentBase<
+    : public arith::impl::ArithmeticUnsignedWhenEquivalentPassBase<
           ArithmeticUnsignedWhenEquivalentPass> {
   /// Implementation structure: first find all equivalent ops and collect them,
   /// then perform all the rewrites in a second pass over the target op. This
   /// ensures that analysis results are not invalidated during rewriting.
   void runOnOperation() override {
     Operation *op = getOperation();
     MLIRContext *ctx = op->getContext();
     DataFlowSolver solver;

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

 //===- AsyncParallelFor.cpp - Implementation of Async Parallel For --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements scf.parallel to scf.for + async.execute conversion pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include <utility>
+#include "mlir/Dialect/Async/Passes.h"
 
 #include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Async/IR/Async.h"
-#include "mlir/Dialect/Async/Passes.h"
 #include "mlir/Dialect/Async/Transforms.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/RegionUtils.h"
+#include <utility>
+
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCPARALLELFORPASS
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::async;
 
 #define DEBUG_TYPE "async-parallel-for"
 
 namespace {
 

 //   %block_size = ... compute parallel compute block size
 //   %block_count = ... compute the number of compute blocks
 //
 //   scf.for %block_index = %c0 to %block_count {
 //      call @parallel_compute_fn(%block_index, %block_size, ...)
 //   }
 //
 struct AsyncParallelForPass
-    : public AsyncParallelForBase<AsyncParallelForPass> {
+    : public impl::AsyncParallelForPassBase<AsyncParallelForPass> {
   AsyncParallelForPass() = default;
 
   AsyncParallelForPass(bool asyncDispatch, int32_t numWorkerThreads,
                        int32_t minTaskSize) {
     this->asyncDispatch = asyncDispatch;
     this->numWorkerThreads = numWorkerThreads;
     this->minTaskSize = minTaskSize;
   }

mlir/lib/Dialect/Async/Transforms/AsyncRuntimeRefCounting.cpp

 //===- AsyncRuntimeRefCounting.cpp - Async Runtime Ref Counting -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements automatic reference counting for Async runtime
 // operations and types.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Async/Passes.h"
+
 #include "mlir/Analysis/Liveness.h"
 #include "mlir/Dialect/Async/IR/Async.h"
-#include "mlir/Dialect/Async/Passes.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/SmallSet.h"
 
-using namespace mlir;
-using namespace mlir::async;
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTINGPASS
+#define GEN_PASS_DEF_ASYNCRUNTIMEPOLICYBASEDREFCOUNTINGPASS
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
 
 #define DEBUG_TYPE "async-runtime-ref-counting"
 
+using namespace mlir;
+using namespace mlir::async;
+
 //===----------------------------------------------------------------------===//
 // Utility functions shared by reference counting passes.
 //===----------------------------------------------------------------------===//
 
 // Drop the reference count immediately if the value has no uses.
 static LogicalResult dropRefIfNoUses(Value value, unsigned count = 1) {
   if (!value.getUses().empty())
     return failure();

 
 //===----------------------------------------------------------------------===//
 // Automatic reference counting based on the liveness analysis.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class AsyncRuntimeRefCountingPass
-    : public AsyncRuntimeRefCountingBase<AsyncRuntimeRefCountingPass> {
+    : public impl::AsyncRuntimeRefCountingPassBase<AsyncRuntimeRefCountingPass> {
 public:
   AsyncRuntimeRefCountingPass() = default;
   void runOnOperation() override;
 
 private:
   /// Adds an automatic reference counting to the `value`.
   ///
   /// All values (token, group or value) are semantically created with a

 
 //===----------------------------------------------------------------------===//
 // Reference counting based on the user defined policy.
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class AsyncRuntimePolicyBasedRefCountingPass
-    : public AsyncRuntimePolicyBasedRefCountingBase<
+    : public impl::AsyncRuntimePolicyBasedRefCountingPassBase<
           AsyncRuntimePolicyBasedRefCountingPass> {
 public:
   AsyncRuntimePolicyBasedRefCountingPass() { initializeDefaultPolicy(); }
 
   void runOnOperation() override;
 
 private:
   // Adds a reference counting operations for all uses of the `value` according

mlir/lib/Dialect/Async/Transforms/AsyncRuntimeRefCountingOpt.cpp

 //===- AsyncRuntimeRefCountingOpt.cpp - Async Ref Counting --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Optimize Async dialect reference counting operations.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Async/Passes.h"
+
+#include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/Debug.h"
 
-using namespace mlir;
-using namespace mlir::async;
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCRUNTIMEREFCOUNTINGOPTPASS
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
 
 #define DEBUG_TYPE "async-ref-counting"
 
+using namespace mlir;
+using namespace mlir::async;
+
 namespace {
 
 class AsyncRuntimeRefCountingOptPass
-    : public AsyncRuntimeRefCountingOptBase<AsyncRuntimeRefCountingOptPass> {
+    : public impl::AsyncRuntimeRefCountingOptPassBase<
+          AsyncRuntimeRefCountingOptPass> {
 public:
   AsyncRuntimeRefCountingOptPass() = default;
   void runOnOperation() override;
 
 private:
   LogicalResult optimizeReferenceCounting(
       Value value, llvm::SmallDenseMap<Operation *, Operation *> &cancellable);
 };

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

 //===- AsyncToAsyncRuntime.cpp - Lower from Async to Async Runtime --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements lowering from high level async operations to async.coro
 // and async.runtime operations.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Async/Passes.h"
+
 #include "PassDetail.h"
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Async/IR/Async.h"
-#include "mlir/Dialect/Async/Passes.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_ASYNCTOASYNCRUNTIMEPASS
+#include "mlir/Dialect/Async/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::async;
 
 #define DEBUG_TYPE "async-to-async-runtime"
 // Prefix for functions outlined from `async.execute` op regions.
 static constexpr const char kAsyncFnPrefix[] = "async_execute_fn";
 
 namespace {
 
 class AsyncToAsyncRuntimePass
-    : public AsyncToAsyncRuntimeBase<AsyncToAsyncRuntimePass> {
+    : public impl::AsyncToAsyncRuntimePassBase<AsyncToAsyncRuntimePass> {
 public:
   AsyncToAsyncRuntimePass() = default;
   void runOnOperation() override;
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Async/Transforms/PassDetail.h

 namespace async {
 class AsyncDialect;
 } // namespace async
 
 namespace scf {
 class SCFDialect;
 } // namespace scf
 
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Async/Passes.h.inc"
-
 // -------------------------------------------------------------------------- //
 // Utility functions shared by Async Transformations.
 // -------------------------------------------------------------------------- //
 
 // Forward declarations.
 class OpBuilder;
 
 namespace async {

mlir/lib/Dialect/Bufferization/Transforms/AllocTensorElimination.cpp

 //===- AllocTensorElimination.cpp - alloc_tensor op elimination -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/AllocTensorElimination.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_ALLOCTENSORELIMINATIONPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::bufferization;
 
 /// Return true if all `neededValues` are in scope at the given
 /// `insertionPoint`.
 static bool
 neededValuesDominateInsertionPoint(const DominanceInfo &domInfo,
                                    Operation *insertionPoint,
return eliminateAllocTensors(
             insertOp.getMixedOffsets(), insertOp.getMixedSizes(),
             insertOp.getMixedStrides());
         return extractOp.getResult();
       });
 }
 
 namespace {
 struct AllocTensorElimination
-    : public AllocTensorEliminationBase<AllocTensorElimination> {
+    : public bufferization::impl::AllocTensorEliminationPassBase<AllocTensorElimination> {
   AllocTensorElimination() = default;
 
   void runOnOperation() override;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<bufferization::BufferizationDialect, tensor::TensorDialect>();
   }

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

 // TODO:
 // The current implementation does not support explicit-control-flow loops and
 // the resulting code will be invalid with respect to program semantics.
 // However, structured control-flow loops are fully supported. Furthermore, it
 // doesn't accept functions which return buffers already.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 
 #include "mlir/Dialect/Bufferization/IR/AllocationOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "llvm/ADT/SetOperations.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_BUFFERDEALLOCATIONPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::bufferization;
 
 /// Walks over all immediate return-like terminators in the given region.
 static LogicalResult
 walkReturnOperations(Region *region,
                      llvm::function_ref<LogicalResult(Operation *)> func) {
   for (Block &block : *region) {
static Optional<Value> buildClone(OpBuilder &builder, Value alloc) {
     return builder.create<bufferization::CloneOp>(alloc.getLoc(), alloc)
         .getResult();
   }
 };
 
 /// The actual buffer deallocation pass that inserts and moves dealloc nodes
 /// into the right positions. Furthermore, it inserts additional clones if
 /// necessary. It uses the algorithm described at the top of the file.
-struct BufferDeallocationPass : BufferDeallocationBase<BufferDeallocationPass> {
+struct BufferDeallocationPass : bufferization::impl::BufferDeallocationPassBase<BufferDeallocationPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect>();
     registry.insert<memref::MemRefDialect>();
     registerAllocationOpInterfaceExternalModels(registry);
   }
 
   void runOnOperation() override {
     func::FuncOp func = getOperation();

mlir/lib/Dialect/Bufferization/Transforms/BufferOptimizations.cpp

 //===- BufferOptimizations.cpp - pre-pass optimizations for bufferization -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements logic for three optimization passes. The first two
 // passes try to move alloc nodes out of blocks to reduce the number of
 // allocations and copies during buffer deallocation. The third pass tries to
 // convert heap-based allocations to stack-based allocations, if possible.
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+
+#include "mlir/Dialect/Bufferization/Transforms/BufferUtils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_BUFFERHOISTINGPASS
+#define GEN_PASS_DEF_BUFFERLOOPHOISTINGPASS
+#define GEN_PASS_DEF_PROMOTEBUFFERSTOSTACKPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::bufferization;
 
 /// Returns true if the given operation implements a known high-level region-
 /// based control-flow interface.
 static bool isKnownControlFlowInterface(Operation *op) {
   return isa<LoopLikeOpInterface, RegionBranchOpInterface>(op);
 }

 };
 
 //===----------------------------------------------------------------------===//
 // BufferOptimizationPasses
 //===----------------------------------------------------------------------===//
 
 /// The buffer hoisting pass that hoists allocation nodes into dominating
 /// blocks.
-struct BufferHoistingPass : BufferHoistingBase<BufferHoistingPass> {
+struct BufferHoistingPass : bufferization::impl::BufferHoistingPassBase<BufferHoistingPass> {
 
   void runOnOperation() override {
     // Hoist all allocations into dominator blocks.
     BufferAllocationHoisting<BufferAllocationHoistingState> optimizer(
         getOperation());
     optimizer.hoist();
   }
 };
 
 /// The buffer loop hoisting pass that hoists allocation nodes out of loops.
-struct BufferLoopHoistingPass : BufferLoopHoistingBase<BufferLoopHoistingPass> {
+struct BufferLoopHoistingPass : bufferization::impl::BufferLoopHoistingPassBase<BufferLoopHoistingPass> {
 
   void runOnOperation() override {
     // Hoist all allocations out of loops.
     BufferAllocationHoisting<BufferAllocationLoopHoistingState> optimizer(
         getOperation());
     optimizer.hoist();
   }
 };
 
 /// The promote buffer to stack pass that tries to convert alloc nodes into
 /// alloca nodes.
 class PromoteBuffersToStackPass
-    : public PromoteBuffersToStackBase<PromoteBuffersToStackPass> {
+    : public bufferization::impl::PromoteBuffersToStackPassBase<PromoteBuffersToStackPass> {
 public:
   PromoteBuffersToStackPass(unsigned maxAllocSizeInBytes,
                             unsigned maxRankOfAllocatedMemRef) {
     this->maxAllocSizeInBytes = maxAllocSizeInBytes;
     this->maxRankOfAllocatedMemRef = maxRankOfAllocatedMemRef;
   }
 
   explicit PromoteBuffersToStackPass(std::function<bool(Value)> isSmallAlloc)

mlir/lib/Dialect/Bufferization/Transforms/BufferResultsToOutParams.cpp

 //===- BufferResultsToOutParams.cpp - Calling convention conversion -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_BUFFERRESULTSTOOUTPARAMSPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 
 /// Return `true` if the given MemRef type has a fully dynamic layout.
 static bool hasFullyDynamicLayoutMap(MemRefType type) {
   int64_t offset;
   SmallVector<int64_t, 4> strides;
   if (failed(getStridesAndOffset(type, strides, offset)))
     return false;
mlir::bufferization::promoteBufferResultsToOutParams(ModuleOp module) {
   }
   if (failed(updateCalls(module)))
     return failure();
   return success();
 }
 
 namespace {
 struct BufferResultsToOutParamsPass
-    : BufferResultsToOutParamsBase<BufferResultsToOutParamsPass> {
+    : bufferization::impl::BufferResultsToOutParamsPassBase<
+          BufferResultsToOutParamsPass> {
   void runOnOperation() override {
     if (failed(bufferization::promoteBufferResultsToOutParams(getOperation())))
       return signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::bufferization::createBufferResultsToOutParamsPass() {
   return std::make_unique<BufferResultsToOutParamsPass>();
 }

mlir/lib/Dialect/Bufferization/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization utilities ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h"
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 #include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_FINALIZINGBUFFERIZEPASS
+#define GEN_PASS_DEF_BUFFERIZATIONBUFFERIZEPASS
+#define GEN_PASS_DEF_ONESHOTBUFFERIZEPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::bufferization;
 
 //===----------------------------------------------------------------------===//
 // BufferizeTypeConverter
 //===----------------------------------------------------------------------===//
 
 static Value materializeToTensor(OpBuilder &builder, TensorType type,

 void mlir::bufferization::populateEliminateBufferizeMaterializationsPatterns(
     BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns) {
   patterns.add<BufferizeToTensorOp, BufferizeToMemrefOp>(typeConverter,
                                                          patterns.getContext());
 }
 
 namespace {
 struct FinalizingBufferizePass
-    : public FinalizingBufferizeBase<FinalizingBufferizePass> {
-  using FinalizingBufferizeBase<
-      FinalizingBufferizePass>::FinalizingBufferizeBase;
+    : public bufferization::impl::FinalizingBufferizePassBase<FinalizingBufferizePass> {
+  using FinalizingBufferizePassBase::FinalizingBufferizePassBase;
 
   void runOnOperation() override {
     auto func = getOperation();
     auto *context = &getContext();
 
     BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
parseLayoutMapOption(const std::string &s) {
   if (s == "identity-layout-map")
     return BufferizationOptions::LayoutMapOption::IdentityLayoutMap;
   if (s == "infer-layout-map")
     return BufferizationOptions::LayoutMapOption::InferLayoutMap;
   llvm_unreachable("invalid layout map option");
 }
 
 struct OneShotBufferizePass
-    : public OneShotBufferizeBase<OneShotBufferizePass> {
+    : public bufferization::impl::OneShotBufferizePassBase<OneShotBufferizePass> {
   OneShotBufferizePass() {}
 
   explicit OneShotBufferizePass(const OneShotBufferizationOptions &options)
       : options(options) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<bufferization::BufferizationDialect, memref::MemRefDialect>();

 
 private:
   llvm::Optional<OneShotBufferizationOptions> options;
 };
 } // namespace
 
 namespace {
 struct BufferizationBufferizePass
-    : public BufferizationBufferizeBase<BufferizationBufferizePass> {
+    : public bufferization::impl::BufferizationBufferizePassBase<BufferizationBufferizePass> {
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     options.opFilter.allowDialect<BufferizationDialect>();
 
     if (failed(bufferizeOp(getOperation(), options)))
       signalPassFailure();
   }
 

mlir/lib/Dialect/Bufferization/Transforms/DropEquivalentBufferResults.cpp

 //   return
 // }
 // ```
 //
 // All call sites are updated accordingly. If a function returns a cast of a
 // function argument, it is also considered equivalent. A cast is inserted at
 // the call site in that case.
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_DROPEQUIVALENTBUFFERRESULTSPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
+
 using namespace mlir;
 
 /// Return the unique ReturnOp that terminates `funcOp`.
 /// Return nullptr if there is no such unique ReturnOp.
 static func::ReturnOp getAssumedUniqueReturnOp(func::FuncOp funcOp) {
   func::ReturnOp returnOp;
   for (Block &b : funcOp.getBody()) {
     if (auto candidateOp = dyn_cast<func::ReturnOp>(b.getTerminator())) {
for (auto funcOp : module.getOps<func::FuncOp>()) {
     });
   }
 
   return success();
 }
 
 namespace {
 struct DropEquivalentBufferResultsPass
-    : DropEquivalentBufferResultsBase<DropEquivalentBufferResultsPass> {
+    : bufferization::impl::DropEquivalentBufferResultsPassBase<
+          DropEquivalentBufferResultsPass> {
   void runOnOperation() override {
     if (failed(bufferization::dropEquivalentBufferResults(getOperation())))
       return signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::bufferization::createDropEquivalentBufferResultsPass() {
   return std::make_unique<DropEquivalentBufferResultsPass>();
 }

mlir/lib/Dialect/Bufferization/Transforms/PassDetail.h

-//===- PassDetail.h - Bufferization Pass details ----------------*- 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 DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace func {
-class FuncDialect;
-} // namespace func
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Bufferization/Transforms/TensorCopyInsertion.cpp

 //===- TensorCopyInsertion.cpp - Resolve Bufferization Conflicts w/ Copies ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
-
-#include "PassDetail.h"
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
 
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotAnalysis.h"
 #include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h"
-#include "mlir/Dialect/Bufferization/Transforms/Passes.h"
+#include "mlir/Dialect/Bufferization/Transforms/TensorCopyInsertion.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+
+namespace mlir {
+namespace bufferization {
+#define GEN_PASS_DEF_TENSORCOPYINSERTIONPASS
+#include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
+} // namespace bufferization
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::bufferization;
 
 /// Resolve all operands that are also used inside of repetitive regions of the
 /// same op. Such cases are not fully supported by One-Shot Bufferize.
 ///
 /// E.g.:
WalkResult result = op->walk([&](Operation *op) {
     return WalkResult::advance();
   });
 
   return failure(result.wasInterrupted());
 }
 
 namespace {
 struct TensorCopyInsertionPass
-    : TensorCopyInsertionBase<TensorCopyInsertionPass> {
+    : bufferization::impl::TensorCopyInsertionPassBase<
+          TensorCopyInsertionPass> {
   TensorCopyInsertionPass() : options(llvm::None) {}
   TensorCopyInsertionPass(const OneShotBufferizationOptions &options)
       : options(options) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect>();
   }
 

mlir/lib/Dialect/Func/Transforms/FuncBufferize.cpp

 //===- Bufferize.cpp - Bufferization for func ops -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements bufferization of func.func's and func.call's.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Func/Transforms/Passes.h"
+
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
-#include "mlir/Dialect/Func/Transforms/Passes.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_FUNCBUFFERIZEPASS
+#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::func;
 
 namespace {
-struct FuncBufferizePass : public FuncBufferizeBase<FuncBufferizePass> {
-  using FuncBufferizeBase<FuncBufferizePass>::FuncBufferizeBase;
+struct FuncBufferizePass
+    : public impl::FuncBufferizePassBase<FuncBufferizePass> {
+  using FuncBufferizePassBase::FuncBufferizePassBase;
+
   void runOnOperation() override {
     auto module = getOperation();
     auto *context = &getContext();
 
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 

mlir/lib/Dialect/Func/Transforms/PassDetail.h

-//===- PassDetail.h - Func Pass class details -------------------*- 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 DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-class AtomicRMWOp;
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Func/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_FUNC_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

 //===- AsyncRegionRewriter.cpp - Implementation of GPU async rewriters ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the GPU dialect pattern rewriters that make GPU op
 // within a region execute asynchronously.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
+
 #include "mlir/Dialect/Async/IR/Async.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
 #include "mlir/Dialect/GPU/Transforms/Utils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_GPUASYNCREGIONPASS
+#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
+
 namespace {
-class GpuAsyncRegionPass : public GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
+class GpuAsyncRegionPass : public impl::GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
   struct ThreadTokenCallback;
   struct DeferWaitCallback;
   struct SingleTokenUseCallback;
   void runOnOperation() override;
 };
 } // namespace
 
 static bool isTerminator(Operation *op) {

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

 //===- KernelOutlining.cpp - Implementation of GPU kernel outlining -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the GPU dialect kernel outlining pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
+
 #include "mlir/AsmParser/AsmParser.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
 #include "mlir/Dialect/GPU/Transforms/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_GPULAUNCHSINKINDEXCOMPUTATIONSPASS
+#define GEN_PASS_DEF_GPUKERNELOUTLININGPASS
+#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 template <typename OpTy>
 static void createForAllDimensions(OpBuilder &builder, Location loc,
                                    SmallVectorImpl<Value> &values) {
   for (auto dim : {gpu::Dimension::x, gpu::Dimension::y, gpu::Dimension::z})
     values.push_back(builder.create<OpTy>(loc, builder.getIndexType(), dim));
 }
static void convertToLaunchFuncOp(gpu::LaunchOp launchOp,
   launchOp.replaceAllUsesWith(launchFunc);
   launchOp.erase();
 }
 
 namespace {
 /// Pass that moves ops which are likely an index computation into gpu.launch
 /// body.
 class GpuLaunchSinkIndexComputationsPass
-    : public GpuLaunchSinkIndexComputationsBase<
+    : public impl::GpuLaunchSinkIndexComputationsPassBase<
           GpuLaunchSinkIndexComputationsPass> {
 public:
   void runOnOperation() override {
     Operation *op = getOperation();
     if (op->walk([](gpu::LaunchOp launch) {
             // Pull in instructions that can be sunk
             if (failed(sinkOperationsIntoLaunchOp(launch,
                                                   isLikelyAnIndexComputation)))

 /// This pass moves the kernel code of each LaunchOp into a function created
 /// inside a nested module. It also creates an external function of the same
 /// name in the parent module.
 ///
 /// The gpu.modules are intended to be compiled to a cubin blob independently in
 /// a separate pass. The external functions can then be annotated with the
 /// symbol of the cubin accessor function.
 class GpuKernelOutliningPass
-    : public GpuKernelOutliningBase<GpuKernelOutliningPass> {
+    : public impl::GpuKernelOutliningPassBase<GpuKernelOutliningPass> {
 public:
   GpuKernelOutliningPass(StringRef dlStr) {
     if (!dlStr.empty() && !dataLayoutStr.hasValue())
       dataLayoutStr = dlStr.str();
   }
 
   GpuKernelOutliningPass(const GpuKernelOutliningPass &other)
-      : GpuKernelOutliningBase(other), dataLayoutSpec(other.dataLayoutSpec) {
+      : GpuKernelOutliningPassBase(other), dataLayoutSpec(other.dataLayoutSpec) {
     dataLayoutStr = other.dataLayoutStr.getValue();
   }
 
   LogicalResult initialize(MLIRContext *context) override {
     // Initialize the data layout specification from the data layout string.
     if (!dataLayoutStr.empty()) {
       Attribute resultAttr = mlir::parseAttribute(dataLayoutStr, context);
       if (!resultAttr)

mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp

 //===- ParallelLoopMapper.cpp - Utilities for mapping parallel loops to GPU =//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements utilities to generate mappings for parallel loops to
 // GPU devices.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
+#include "mlir/Dialect/GPU/Transforms/Passes.h"
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Dialect/GPU/Transforms/Passes.h"
+#include "mlir/Dialect/GPU/Transforms/ParallelLoopMapper.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/AffineMap.h"
 
 namespace mlir {
+#define GEN_PASS_DEF_GPUMAPPARALLELLOOPSPASS
+#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
+} // namespace mlir
+
+namespace mlir {
 
 using scf::ParallelOp;
 
 StringRef gpu::getMappingAttrName() { return "mapping"; }
 
 LogicalResult
 gpu::setMappingAttr(ParallelOp ploopOp,
                     ArrayRef<ParallelLoopDimMappingAttr> mapping) {
static void mapParallelOp(ParallelOp parallelOp,
   for (Operation &op : *parallelOp.getBody()) {
     if (ParallelOp nested = dyn_cast<ParallelOp>(op))
       mapParallelOp(nested, mappingLevel);
   }
 }
 
 namespace {
 struct GpuMapParallelLoopsPass
-    : public GpuMapParallelLoopsPassBase<GpuMapParallelLoopsPass> {
+    : public impl::GpuMapParallelLoopsPassBase<GpuMapParallelLoopsPass> {
   void runOnOperation() override {
     for (Region &region : getOperation()->getRegions()) {
       region.walk([](ParallelOp parallelOp) { mapParallelOp(parallelOp); });
     }
   }
 };
 
 } // namespace
 } // namespace gpu
 } // namespace mlir
 
 std::unique_ptr<mlir::OperationPass<mlir::func::FuncOp>>
 mlir::createGpuMapParallelLoopsPass() {
   return std::make_unique<gpu::GpuMapParallelLoopsPass>();
 }

mlir/lib/Dialect/GPU/Transforms/PassDetail.h

-//===- PassDetail.h - GPU Pass class details --------------------*- 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 DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Async/IR/Async.h"
-#include "mlir/Dialect/DLTI/DLTI.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Dialect/GPU/IR/GPUDialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/GPU/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/LLVMIR/Transforms/LegalizeForExport.cpp

 //===- LegalizeForExport.cpp - Prepare for translation to LLVM IR ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
-#include "PassDetail.h"
+
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace LLVM {
+#define GEN_PASS_DEF_LLVMLEGALIZEFOREXPORTPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace LLVM
+} // namespace mlir
 
 using namespace mlir;
 
 /// If the given block has the same successor with different arguments,
 /// introduce dummy successor blocks so that all successors of the given block
 /// are different.
 static void ensureDistinctSuccessors(Block &bb) {
   // Early exit if the block cannot have successors.
for (Region &region : llvm::make_early_inc_range(nested->getRegions())) {
       for (Block &block : llvm::make_early_inc_range(region)) {
         ::ensureDistinctSuccessors(block);
       }
     }
   });
 }
 
 namespace {
-struct LegalizeForExportPass
-    : public LLVMLegalizeForExportBase<LegalizeForExportPass> {
+struct LLVMLegalizeForExportPass
+    : public LLVM::impl::LLVMLegalizeForExportPassBase<
+          LLVMLegalizeForExportPass> {
+  using LLVMLegalizeForExportPassBase::LLVMLegalizeForExportPassBase;
+
   void runOnOperation() override {
     LLVM::ensureDistinctSuccessors(getOperation());
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> LLVM::createLegalizeForExportPass() {
-  return std::make_unique<LegalizeForExportPass>();
+  return std::make_unique<LLVMLegalizeForExportPass>();
 }

mlir/lib/Dialect/LLVMIR/Transforms/OptimizeForNVVM.cpp

 //===- OptimizeForNVVM.cpp - Optimize LLVM IR for NVVM ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/Transforms/OptimizeForNVVM.h"
-#include "PassDetail.h"
+
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace NVVM {
+#define GEN_PASS_DEF_NVVMOPTIMIZEFORTARGETPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace NVVM
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 // Replaces fdiv on fp16 with fp32 multiplication with reciprocal plus one
 // (conditional) Newton iteration.
 //
 // This as accurate as promoting the division to fp32 in the NVPTX backend, but
 // faster because it performs less Newton iterations, avoids the slow path
 // for e.g. denormals, and allows reuse of the reciprocal for multiple divisions
 // by the same divisor.
 struct ExpandDivF16 : public OpRewritePattern<LLVM::FDivOp> {
   using OpRewritePattern<LLVM::FDivOp>::OpRewritePattern;
 
 private:
   LogicalResult matchAndRewrite(LLVM::FDivOp op,
                                 PatternRewriter &rewriter) const override;
 };
 
-struct NVVMOptimizeForTarget
-    : public NVVMOptimizeForTargetBase<NVVMOptimizeForTarget> {
+struct NVVMOptimizeForTargetPass
+    : public NVVM::impl::NVVMOptimizeForTargetPassBase<
+          NVVMOptimizeForTargetPass> {
+  using NVVMOptimizeForTargetPassBase::NVVMOptimizeForTargetPassBase;
+
   void runOnOperation() override;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<NVVM::NVVMDialect>();
   }
 };
 } // namespace
 
Value result =
       rewriter.create<LLVM::SelectOp>(loc, f32Type, pred, approx, refined);
 
   // Replace with trucation back to fp16.
   rewriter.replaceOpWithNewOp<LLVM::FPTruncOp>(op, op.getType(), result);
 
   return success();
 }
 
-void NVVMOptimizeForTarget::runOnOperation() {
+void NVVMOptimizeForTargetPass::runOnOperation() {
   MLIRContext *ctx = getOperation()->getContext();
   RewritePatternSet patterns(ctx);
   patterns.add<ExpandDivF16>(ctx);
   if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<Pass> NVVM::createOptimizeForTargetPass() {
-  return std::make_unique<NVVMOptimizeForTarget>();
+  return std::make_unique<NVVMOptimizeForTargetPass>();
 }

mlir/lib/Dialect/LLVMIR/Transforms/PassDetail.h

-//===- PassDetail.h - LLVM Pass class details -------------------*- 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 DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-namespace func {
-class FuncOp;
-} // namespace func
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/LLVMIR/Transforms/RequestCWrappers.cpp

 //===- RequestCWrappers.cpp - Annotate funcs with wrap attributes ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/Transforms/RequestCWrappers.h"
-#include "PassDetail.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace LLVM {
+#define GEN_PASS_DEF_LLVMREQUESTCWRAPPERSPASS
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+} // namespace LLVM
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
-class RequestCWrappersPass
-    : public LLVMRequestCWrappersBase<RequestCWrappersPass> {
-public:
+struct LLVMRequestCWrappersPass
+    : public LLVM::impl::LLVMRequestCWrappersPassBase<
+          LLVMRequestCWrappersPass> {
+  using LLVMRequestCWrappersPassBase::LLVMRequestCWrappersPassBase;
+
   void runOnOperation() override {
     getOperation()->setAttr(LLVM::LLVMDialect::getEmitCWrapperAttrName(),
                             UnitAttr::get(&getContext()));
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::LLVM::createRequestCWrappersPass() {
-  return std::make_unique<RequestCWrappersPass>();
+  return std::make_unique<LLVMRequestCWrappersPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/BubbleUpExtractSlice.cpp

 //===- BubbleUpExtractSlice.cpp - bubble up tensor.extract_slice ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns that transforms linalg.<op> +
 // tensor.extract_slice into tensor.extract_slice + linalg.<op> to reduce
 // the computation for the linalg op.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/Utils/Utils.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 

mlir/lib/Dialect/Linalg/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization of linalg ops ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
 
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/BufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGBUFFERIZEPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace bufferization;
 
 namespace {
 /// Converts Linalg operations that work on tensor-type operands or results to
 /// work on buffers.
-struct LinalgBufferizePass : public LinalgBufferizeBase<LinalgBufferizePass> {
+struct LinalgBufferizePass
+    : public impl::LinalgBufferizePassBase<LinalgBufferizePass> {
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     options.opFilter.allowDialect<linalg::LinalgDialect>();
 
     if (failed(bufferizeOp(getOperation(), options)))
       signalPassFailure();
   }
 

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

 //===- Detensorize.cpp - Linalg transformations as patterns ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Func/Transforms/FuncConversions.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include <iterator>
 #include <memory>
 #include <utility>
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGDETENSORIZEPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::linalg;
 
 static Value sourceMaterializationCallback(OpBuilder &builder, Type type,
                                            ValueRange inputs, Location loc) {
   assert(inputs.size() == 1);
   auto inputType = inputs[0].getType();
   if (inputType.isa<TensorType>())
DetensorizeTypeConverter() {
     });
 
     addSourceMaterialization(sourceMaterializationCallback);
     addArgumentMaterialization(sourceMaterializationCallback);
   }
 };
 
 /// @see LinalgDetensorize in Linalg/Passes.td for more details.
-struct LinalgDetensorize : public LinalgDetensorizeBase<LinalgDetensorize> {
+struct LinalgDetensorize : public impl::LinalgDetensorizePassBase<LinalgDetensorize> {
   LinalgDetensorize() = default;
 
   class CostModel {
   public:
     virtual ~CostModel() = default;
 
     /// A cost model algorithm computes the following outputs:
     ///

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

 //===- DropUnitDims.cpp - Pass to drop use of unit-extent for broadcasting ===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns/pass to remove usage of unit-extent dimensions
 // to specify broadcasting in favor of more canonical representation of the
 // computation
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "linalg-drop-unit-dims"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 /// Implements a pass that canonicalizes the uses of unit-extent dimensions for
 /// broadcasting. For example,
 ///
void mlir::linalg::populateFoldUnitExtentDimsPatterns(
   linalg::InitTensorOp::getCanonicalizationPatterns(patterns, context);
   tensor::CollapseShapeOp::getCanonicalizationPatterns(patterns, context);
   tensor::ExpandShapeOp::getCanonicalizationPatterns(patterns, context);
 }
 
 namespace {
 /// Pass that removes unit-extent dims within generic ops.
 struct LinalgFoldUnitExtentDimsPass
-    : public LinalgFoldUnitExtentDimsBase<LinalgFoldUnitExtentDimsPass> {
+    : public impl::LinalgFoldUnitExtentDimsPassBase<LinalgFoldUnitExtentDimsPass> {
   void runOnOperation() override {
     Operation *op = getOperation();
     MLIRContext *context = op->getContext();
     RewritePatternSet patterns(context);
     if (foldOneTripLoopsOnly)
       patterns.add<FoldUnitDimLoops>(context);
     else
       populateFoldUnitExtentDimsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(op, std::move(patterns));
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createLinalgFoldUnitExtentDimsPass() {
   return std::make_unique<LinalgFoldUnitExtentDimsPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

 //===- ElementwiseOpFusion.cpp - Implementation of linalg Fusion ---------===///
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Fusion on tensors operations pass.
 //
 //===----------------------------------------------------------------------===//
-#include <utility>
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include <utility>
+
+namespace mlir {
+#define GEN_PASS_DEF_LINALGFOLDUNITEXTENTDIMSPASS
+#define GEN_PASS_DEF_LINALGELEMENTWISEOPFUSIONPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 //===---------------------------------------------------------------------===//
 // Methods and patterns that fuse elementwise `linalg.generic` operations.
 //===---------------------------------------------------------------------===//
 

 
 /// Pass that fuses generic ops on tensors. Used only for testing.
 // TODO(ravishankarm): This pass is to be deprecated. The efficacy of the
 // patterns added here heavily depends on the cost function used. Having an
 // opinionated pass of this form is not recommended. Deprecate this pass in
 // favor of test passes that check the functionality of each of the patterns
 // added here individually.
 struct LinalgElementwiseOpFusionPass
-    : public LinalgElementwiseOpFusionBase<LinalgElementwiseOpFusionPass> {
+    : public impl::LinalgElementwiseOpFusionPassBase<LinalgElementwiseOpFusionPass> {
   void runOnOperation() override {
     Operation *op = getOperation();
     MLIRContext *context = op->getContext();
     RewritePatternSet patterns(context);
 
     // Add folding with reshape by expansion patterns.
     ControlFusionFn defaultControlFn = [](OpOperand *fusedOperand) {
       Operation *producer = fusedOperand->get().getDefiningOp();

mlir/lib/Dialect/Linalg/Transforms/ElementwiseToLinalg.cpp

 //===- ElementwiseToLinalg.cpp - conversion of elementwise to linalg ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/Passes.h"
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/Utils/Utils.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONVERTELEMENTWISETOLINALGPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static bool isElementwiseMappableOpOnRankedTensors(Operation *op) {
   if (!OpTrait::hasElementwiseMappableTraits(op))
     return false;
 
   // TODO: The conversion pattern can be made to work for `any_of` here, but
   // it's more complex as it requires tracking which operands are scalars.

 void mlir::linalg::populateElementwiseToLinalgConversionPatterns(
     RewritePatternSet &patterns) {
   patterns.add<ConvertAnyElementwiseMappableOpOnRankedTensors>(
       patterns.getContext());
 }
 
 namespace {
 class ConvertElementwiseToLinalgPass
-    : public ConvertElementwiseToLinalgBase<ConvertElementwiseToLinalgPass> {
+    : public impl::ConvertElementwiseToLinalgPassBase<
+          ConvertElementwiseToLinalgPass> {
 
   void runOnOperation() final {
     auto *func = getOperation();
     auto *context = &getContext();
     ConversionTarget target(*context);
     RewritePatternSet patterns(context);
 
     mlir::linalg::populateElementwiseToLinalgConversionPatterns(patterns);

mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp

 //===- Fusion.cpp - Implementation of linalg Fusion -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Fusion pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Linalg/Analysis/DependenceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"

mlir/lib/Dialect/Linalg/Transforms/FusionOnTensors.cpp

 //===- FusionOnTensors.cpp - Implementation of linalg Fusion --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements linalg fusion on tensors
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"

mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp

 //===- Generalization.cpp - linalg named ops to generic ops  --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Linalg generalization pass. It converts named
 // Linalg ops to linalg.generic ops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGGENERALIZATIONPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "linalg-generalization"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 static LogicalResult generalizeNamedOpPrecondition(LinalgOp linalgOp) {
   // Check if the operation is a LinalgOp but not a GenericOp.
   if (isa<GenericOp>(linalgOp))
rewriter.inlineRegionBefore(linalgOp->getRegion(0), genericOp.getRegion(),
                               genericOp.getRegion().begin());
   rewriter.replaceOp(linalgOp, genericOp->getResults());
   return genericOp;
 }
 
 namespace {
 
 struct LinalgGeneralizationPass
-    : public LinalgGeneralizationBase<LinalgGeneralizationPass> {
+    : public impl::LinalgGeneralizationPassBase<LinalgGeneralizationPass> {
   void runOnOperation() override;
 };
 
 } // namespace
 
 void LinalgGeneralizationPass::runOnOperation() {
   func::FuncOp func = getOperation();
   RewritePatternSet patterns(&getContext());

mlir/lib/Dialect/Linalg/Transforms/InitTensorToAllocTensor.cpp

 //===- InitTensorToAllocTensor.cpp - Lower init_tensor to alloc_tensor ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
 
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGINITTENSORTOALLOCTENSORPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::bufferization;
 using namespace mlir::linalg;
 
 namespace {
 struct InitTensorLoweringPattern : public OpRewritePattern<InitTensorOp> {
   using OpRewritePattern<InitTensorOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(InitTensorOp op,
                                 PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<bufferization::AllocTensorOp>(op, op.getType(),
                                                               op.getSizes());
     return success();
   }
 };
 
 struct LinalgInitTensorToAllocTensor
-    : public LinalgInitTensorToAllocTensorBase<LinalgInitTensorToAllocTensor> {
+    : public impl::LinalgInitTensorToAllocTensorPassBase<
+          LinalgInitTensorToAllocTensor> {
   LinalgInitTensorToAllocTensor() = default;
 
   void runOnOperation() override;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<linalg::LinalgDialect, bufferization::BufferizationDialect>();
   }

mlir/lib/Dialect/Linalg/Transforms/InlineScalarOperands.cpp

 //===- InlineScalarOperands.cpp - Pass to inline scalar operands =============//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns/pass to inline scalar operands into a generic
 // operation. A scalar operand is an operand whose indexing map has a constant
 // rhs.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGINLINESCALAROPERANDSPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct InlineScalarOperands : public OpRewritePattern<GenericOp> {
   using OpRewritePattern<GenericOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(GenericOp genericOp,
                                 PatternRewriter &rewriter) const override {
void mlir::linalg::populateInlineConstantOperandsPatterns(
     RewritePatternSet &patterns) {
   auto *context = patterns.getContext();
   patterns.add<InlineScalarOperands>(context);
 }
 
 namespace {
 /// Pass that removes unit-extent dims within generic ops.
 struct LinalgInlineScalarOperandsPass
-    : public LinalgInlineScalarOperandsBase<LinalgInlineScalarOperandsPass> {
+    : public impl::LinalgInlineScalarOperandsPassBase<
+          LinalgInlineScalarOperandsPass> {
   void runOnOperation() override {
     func::FuncOp funcOp = getOperation();
     MLIRContext *context = funcOp.getContext();
     RewritePatternSet patterns(context);
 
     populateInlineConstantOperandsPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
 mlir::createLinalgInlineScalarOperandsPass() {
   return std::make_unique<LinalgInlineScalarOperandsPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/LinalgStrategyPasses.cpp

 //===- LinalgStrategyPasses.cpp - Implementation of Linalg passes ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a configurable pass that can apply patterns liberally
 // and be plugged in a pass pipeline.
 //
 //===----------------------------------------------------------------------===//
 
-#include <utility>
+#include "mlir/Dialect/Linalg/Passes.h"
 
-#include "PassDetail.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Affine/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Hoisting.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
 #include "mlir/Transforms/Passes.h"
+#include <utility>
+
+namespace mlir {
+#define GEN_PASS_DEF_LINALGSTRATEGYTILEANDFUSEPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYTILEPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYPADPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYDECOMPOSEPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYPEELPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYVECTORIZEPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYENABLEPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYLOWERVECTORSPASS
+#define GEN_PASS_DEF_LINALGSTRATEGYREMOVEMARKERSPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::vector;
 using namespace linalg;
 
 namespace {
 
 /// Configurable pass to apply pattern-based tiling and fusion.
 struct LinalgStrategyTileAndFusePass
-    : public LinalgStrategyTileAndFusePassBase<LinalgStrategyTileAndFusePass> {
+    : public impl::LinalgStrategyTileAndFusePassBase<LinalgStrategyTileAndFusePass> {
 
   LinalgStrategyTileAndFusePass() = default;
 
   LinalgStrategyTileAndFusePass(StringRef opName,
                                 LinalgTilingAndFusionOptions opt,
                                 LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
struct LinalgStrategyTileAndFusePass
   }
 
   LinalgTilingAndFusionOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply pattern-based linalg tiling.
 struct LinalgStrategyTilePass
-    : public LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
+    : public impl::LinalgStrategyTilePassBase<LinalgStrategyTilePass> {
 
   LinalgStrategyTilePass() = default;
 
   LinalgStrategyTilePass(StringRef opName, LinalgTilingOptions opt,
                          LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
struct LinalgStrategyTilePass
   }
 
   LinalgTilingOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply hoisting and padding.
 struct LinalgStrategyPadPass
-    : public LinalgStrategyPadPassBase<LinalgStrategyPadPass> {
+    : public impl::LinalgStrategyPadPassBase<LinalgStrategyPadPass> {
 
   LinalgStrategyPadPass() = default;
 
   LinalgStrategyPadPass(StringRef opName, LinalgPaddingOptions opt,
                         LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
struct LinalgStrategyPadPass
   LinalgPaddingOptions options;
   LinalgTransformationFilter filter;
 };
 
 
 /// Configurable pass to apply lowering of coarser-grained named linalg ops into
 /// finer-grained named versions.
 struct LinalgStrategyDecomposePass
-    : public LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
+    : public impl::LinalgStrategyDecomposePassBase<LinalgStrategyDecomposePass> {
 
   LinalgStrategyDecomposePass() = default;
 
   LinalgStrategyDecomposePass(LinalgTransformationFilter filter)
       : filter(std::move(filter)) {}
 
   void runOnOperation() override {
     auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
     RewritePatternSet decompositionPattern(funcOp.getContext());
     populateDecomposeConvolutionPatterns(decompositionPattern, filter);
     if (failed(applyPatternsAndFoldGreedily(funcOp,
                                             std::move(decompositionPattern))))
       signalPassFailure();
   }
 
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply pattern-based linalg peeling.
 struct LinalgStrategyPeelPass
-    : public LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
+    : public impl::LinalgStrategyPeelPassBase<LinalgStrategyPeelPass> {
 
   LinalgStrategyPeelPass() = default;
 
   LinalgStrategyPeelPass(StringRef opName, LinalgPeelOptions opt,
                          LinalgTransformationFilter filt)
       : options(std::move(opt)), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
   }
struct LinalgStrategyPeelPass
   }
 
   LinalgPeelOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to apply pattern-based linalg vectorization.
 struct LinalgStrategyVectorizePass
-    : public LinalgStrategyVectorizePassBase<LinalgStrategyVectorizePass> {
+    : public impl::LinalgStrategyVectorizePassBase<LinalgStrategyVectorizePass> {
 
   LinalgStrategyVectorizePass() = default;
 
   LinalgStrategyVectorizePass(StringRef opName, LinalgVectorizationOptions opt,
                               LinalgTransformationFilter filt,
                               bool padVectorize = false)
       : options(opt), filter(std::move(filt)) {
     this->anchorOpName.setValue(opName.str());
struct LinalgStrategyVectorizePass
 
   LinalgVectorizationOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to enable the application of other pattern-based linalg
 /// passes.
 struct LinalgStrategyEnablePass
-    : public LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
+    : public impl::LinalgStrategyEnablePassBase<LinalgStrategyEnablePass> {
 
   LinalgStrategyEnablePass(LinalgEnablingOptions opt,
                            LinalgTransformationFilter filt)
       : options(opt), filter(std::move(filt)) {}
 
   void runOnOperation() override {
     auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
struct LinalgStrategyEnablePass
   }
 
   LinalgEnablingOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to lower vector operations.
 struct LinalgStrategyLowerVectorsPass
-    : public LinalgStrategyLowerVectorsPassBase<
+    : public impl::LinalgStrategyLowerVectorsPassBase<
           LinalgStrategyLowerVectorsPass> {
 
   LinalgStrategyLowerVectorsPass(LinalgVectorLoweringOptions opt,
                                  LinalgTransformationFilter filt)
       : options(opt), filter(std::move(filt)) {}
 
   void runOnOperation() override {
     auto funcOp = getOperation();
struct LinalgStrategyLowerVectorsPass
   }
 
   LinalgVectorLoweringOptions options;
   LinalgTransformationFilter filter;
 };
 
 /// Configurable pass to lower vector operations.
 struct LinalgStrategyRemoveMarkersPass
-    : public LinalgStrategyRemoveMarkersPassBase<
+    : public impl::LinalgStrategyRemoveMarkersPassBase<
           LinalgStrategyRemoveMarkersPass> {
 
   void runOnOperation() override {
     auto funcOp = getOperation();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
     funcOp.walk([](LinalgOp op) {
       op->removeAttr(LinalgTransforms::kLinalgTransformMarker);

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

 //===- Loops.cpp - conversion from Linalg named and generic ops to loops --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Arithmetic/Utils/Utils.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGLOWERTOAFFINELOOPSPASS
+#define GEN_PASS_DEF_LINALGLOWERTOLOOPSPASS
+#define GEN_PASS_DEF_LINALGLOWERTOPARALLELLOOPSPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::linalg;
 
 static SmallVector<Value> makeCanonicalAffineApplies(OpBuilder &b, Location loc,
                                                      AffineMap map,
                                                      ArrayRef<Value> vals) {
   if (map.isEmpty())
     return {};
static void lowerLinalgToLoopsImpl(func::FuncOp funcOp) {
   tensor::DimOp::getCanonicalizationPatterns(patterns, context);
   AffineApplyOp::getCanonicalizationPatterns(patterns, context);
   patterns.add<FoldAffineOp>(context);
   // Just apply the patterns greedily.
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
 struct LowerToAffineLoops
-    : public LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
+    : public impl::LinalgLowerToAffineLoopsPassBase<LowerToAffineLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnOperation() override {
     lowerLinalgToLoopsImpl<AffineForOp>(getOperation());
   }
 };
 
-struct LowerToLoops : public LinalgLowerToLoopsBase<LowerToLoops> {
+struct LowerToLoops : public impl::LinalgLowerToLoopsPassBase<LowerToLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, scf::SCFDialect>();
   }
   void runOnOperation() override {
     lowerLinalgToLoopsImpl<scf::ForOp>(getOperation());
   }
 };
 
 struct LowerToParallelLoops
-    : public LinalgLowerToParallelLoopsBase<LowerToParallelLoops> {
+    : public impl::LinalgLowerToParallelLoopsPassBase<LowerToParallelLoops> {
   void runOnOperation() override {
     lowerLinalgToLoopsImpl<scf::ParallelOp>(getOperation());
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>

mlir/lib/Dialect/Linalg/Transforms/NamedOpConversions.cpp

 //===- NamedOpConversions.cpp - Implements conversions between named ops --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements conversions between named ops that can be seens as
 // canonicalizations of named ops.
 //
 //===----------------------------------------------------------------------===//
-#include "PassDetail.h"
-#include "mlir/Dialect/Linalg/IR/Linalg.h"
+
 #include "mlir/Dialect/Linalg/Passes.h"
+
+#include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-
 #include "llvm/ADT/SmallVector.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LINALGNAMEDOPCONVERSIONPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::linalg;
 
 static llvm::SmallVector<int64_t> getIndicesVector(int start, int end) {
   return llvm::to_vector<2>(llvm::seq<int64_t>(start, end));
 }
 
 static LogicalResult
LogicalResult matchAndRewrite(DepthwiseConv2DNhwcHwcmQOp op,
     auto dilation = op.getDilations();
 
     return matchAndReplaceDepthwiseConv(operation, input, kernel, iZp, kZp,
                                         init, stride, dilation, rewriter);
   }
 };
 
 struct LinalgNamedOpConversionPass
-    : public LinalgNamedOpConversionBase<LinalgNamedOpConversionPass> {
+    : public impl::LinalgNamedOpConversionPassBase<
+          LinalgNamedOpConversionPass> {
   LinalgNamedOpConversionPass() = default;
   LinalgNamedOpConversionPass(const LinalgNamedOpConversionPass &) = default;
 
   void runOnOperation() override {
     Operation *op = getOperation();
     RewritePatternSet patterns(op->getContext());
     populateLinalgNamedOpConversionPatterns(patterns);
     if (failed(applyPatternsAndFoldGreedily(op, std::move(patterns))))

mlir/lib/Dialect/Linalg/Transforms/PassDetail.h

-//===- PassDetail.h - Linalg Pass class details -----------------*- 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 DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Affine/IR/AffineOps.h"
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/Dialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace linalg {
-class LinalgDialect;
-} // namespace linalg
-
-namespace scf {
-class SCFDialect;
-} // namespace scf
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace tensor {
-class TensorDialect;
-} // namespace tensor
-
-namespace vector {
-class VectorDialect;
-} // namespace vector
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Linalg/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp

 //===- Promotion.cpp - Implementation of linalg Promotion -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Promotion pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/AffineExpr.h"

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

 //===- Tiling.cpp - Implementation of linalg Tiling -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the linalg dialect Tiling pass.
 //
 //===----------------------------------------------------------------------===//
 
-#include <utility>
+#include "mlir/Dialect/Linalg/Passes.h"
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/Utils/Utils.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
-#include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-
 #include "llvm/Support/CommandLine.h"
+#include <utility>
+
+namespace mlir {
+#define GEN_PASS_DEF_LINALGTILINGPASS
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+} // namespace mlir
+
+#define DEBUG_TYPE "linalg-tiling"
 
 using namespace mlir;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
-#define DEBUG_TYPE "linalg-tiling"
-
 static bool isZero(OpFoldResult v) {
   if (!v)
     return false;
   if (auto attr = v.dyn_cast<Attribute>()) {
     IntegerAttr intAttr = attr.dyn_cast<IntegerAttr>();
     return intAttr && intAttr.getValue().isZero();
   }
   if (auto cst = v.get<Value>().getDefiningOp<arith::ConstantIndexOp>())
static void applyExtractSliceOfPadTensorSwapPattern(func::FuncOp funcOp) {
   RewritePatternSet patterns(ctx);
   patterns.add<ExtractSliceOfPadTensorSwapPattern>(patterns.getContext());
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
   (void)applyPatternsAndFoldGreedily(
       funcOp, getLinalgTilingCanonicalizationPatterns(ctx));
 }
 
 namespace {
-struct LinalgTilingPass : public LinalgTilingBase<LinalgTilingPass> {
+struct LinalgTilingPass : public impl::LinalgTilingPassBase<LinalgTilingPass> {
   LinalgTilingPass() = default;
   LinalgTilingPass(ArrayRef<int64_t> tileSizes, LinalgTilingLoopType loopType) {
     this->tileSizes = tileSizes;
     this->loopType = "";
     this->loopTypeEnum = loopType;
   }
 
   void runOnOperation() override {

mlir/lib/Dialect/MemRef/Transforms/ExpandOps.cpp

 //===- StdExpandDivs.cpp - Code to prepare Std for lowering Divs to LLVM  -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file Std transformations to expand Divs operation to help for the
 // lowering to LLVM. Currently implemented transformations are Ceil and Floor
 // for Signed Integers.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Arithmetic/Transforms/Passes.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+namespace memref {
+#define GEN_PASS_DEF_EXPANDOPSPASS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
 /// Converts `atomic_rmw` that cannot be lowered to a simple atomic op with
 /// AtomicRMWOpLowering pattern, e.g. with "minf" or "maxf" attributes, to
 /// `memref.generic_atomic_rmw` with the expanded code.
 ///
LogicalResult matchAndRewrite(memref::ReshapeOp op,
     }
     rewriter.replaceOpWithNewOp<memref::ReinterpretCastOp>(
         op, op.getType(), op.getSource(), /*offset=*/rewriter.getIndexAttr(0),
         sizes, strides);
     return success();
   }
 };
 
-struct ExpandOpsPass : public ExpandOpsBase<ExpandOpsPass> {
+struct ExpandOpsPass : public memref::impl::ExpandOpsPassBase<ExpandOpsPass> {
   void runOnOperation() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     memref::populateExpandOpsPatterns(patterns);
     ConversionTarget target(ctx);
 
     target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect>();

mlir/lib/Dialect/MemRef/Transforms/FoldMemRefAliasOps.cpp

 //===- FoldMemRefAliasOps.cpp - Fold memref alias ops -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass folds loading/storing from/to subview ops into
 // loading/storing from/to the original memref.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/Dialect/Utils/IndexingUtils.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+namespace memref {
+#define GEN_PASS_DEF_FOLDMEMREFALIASOPSPASS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
 /// Given the 'indices' of a load/store operation where the memref is a result
 /// of a expand_shape op, returns the indices w.r.t to the source memref of the

 }
 
 //===----------------------------------------------------------------------===//
 // Pass registration
 //===----------------------------------------------------------------------===//
 
 namespace {
 
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-
 struct FoldMemRefAliasOpsPass final
-    : public FoldMemRefAliasOpsBase<FoldMemRefAliasOpsPass> {
+    : public memref::impl::FoldMemRefAliasOpsPassBase<FoldMemRefAliasOpsPass> {
   void runOnOperation() override;
 };
 
 } // namespace
 
 void FoldMemRefAliasOpsPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   memref::populateFoldMemRefAliasOpPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(),
                                      std::move(patterns));
 }
 
 std::unique_ptr<Pass> memref::createFoldMemRefAliasOpsPass() {
   return std::make_unique<FoldMemRefAliasOpsPass>();
 }

mlir/lib/Dialect/MemRef/Transforms/NormalizeMemRefs.cpp

 //===- NormalizeMemRefs.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements an interprocedural pass to normalize memrefs to have
 // identity layout maps.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+namespace memref {
+#define GEN_PASS_DEF_NORMALIZEMEMREFSPASS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
 #define DEBUG_TYPE "normalize-memrefs"
 
 using namespace mlir;
 
 namespace {
 
 /// All memrefs passed across functions with non-trivial layout maps are
 /// converted to ones with trivial identity layout ones.
 /// If all the memref types/uses in a function are normalizable, we treat
 /// such functions as normalizable. Also, if a normalizable function is known
 /// to call a non-normalizable function, we treat that function as
 /// non-normalizable as well. We assume external functions to be normalizable.
-struct NormalizeMemRefs : public NormalizeMemRefsBase<NormalizeMemRefs> {
+struct NormalizeMemRefs : public memref::impl::NormalizeMemRefsPassBase<NormalizeMemRefs> {
   void runOnOperation() override;
   void normalizeFuncOpMemRefs(func::FuncOp funcOp, ModuleOp moduleOp);
   bool areMemRefsNormalizable(func::FuncOp funcOp);
   void updateFunctionSignature(func::FuncOp funcOp, ModuleOp moduleOp);
   void setCalleesAndCallersNonNormalizable(
       func::FuncOp funcOp, ModuleOp moduleOp,
       DenseSet<func::FuncOp> &normalizableFuncs);
   Operation *createOpResultsNormalized(func::FuncOp funcOp, Operation *oldOp);

mlir/lib/Dialect/MemRef/Transforms/PassDetail.h

-//===- PassDetail.h - MemRef Pass class details -----------------*- 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 DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/DialectRegistry.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-class AffineDialect;
-
-// Forward declaration from Dialect.h
-template <typename ConcreteDialect>
-void registerDialect(DialectRegistry &registry);
-
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace func {
-class FuncDialect;
-} // namespace func
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace tensor {
-class TensorDialect;
-} // namespace tensor
-
-namespace vector {
-class VectorDialect;
-} // namespace vector
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_MEMREF_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/MemRef/Transforms/ResolveShapedTypeResultDims.cpp

 //===- ResolveShapedTypeResultDims.cpp - Resolve dim ops of result values -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass resolves `memref.dim` operations of result values in terms of
 // shapes of their operands using the `InferShapedTypeOpInterface`.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/MemRef/Transforms/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
-#include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace memref {
+#define GEN_PASS_DEF_RESOLVERANKEDSHAPETYPERESULTDIMSPASS
+#define GEN_PASS_DEF_RESOLVESHAPEDTYPERESULTDIMSPASS
+#include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
+} // namespace memref
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Fold dim of an operation that implements the InferShapedTypeOpInterface
 template <typename OpTy>
 struct DimOfShapedTypeOpInterface : public OpRewritePattern<OpTy> {
   using OpRewritePattern<OpTy>::OpRewritePattern;
 

 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pass registration
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ResolveRankedShapeTypeResultDimsPass final
-    : public ResolveRankedShapeTypeResultDimsBase<
+    : public memref::impl::ResolveRankedShapeTypeResultDimsPassBase<
           ResolveRankedShapeTypeResultDimsPass> {
   void runOnOperation() override;
 };
 
 struct ResolveShapedTypeResultDimsPass final
-    : public ResolveShapedTypeResultDimsBase<ResolveShapedTypeResultDimsPass> {
+    : public memref::impl::ResolveShapedTypeResultDimsPassBase<
+          ResolveShapedTypeResultDimsPass> {
   void runOnOperation() override;
 };
 
 } // namespace
 
 void memref::populateResolveRankedShapeTypeResultDimsPatterns(
     RewritePatternSet &patterns) {
   patterns.add<DimOfReifyRankedShapedTypeOpInterface<memref::DimOp>,

mlir/lib/Dialect/NVGPU/Transforms/MmaSyncTF32Transform.cpp

 //===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements transforms to enable 1xtf32 and 3xtf32 nvgpu.mma sync
 // operations on f32 input datatype
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
 #include "mlir/Dialect/NVGPU/Passes.h"
 #include "mlir/Dialect/NVGPU/Transforms/Transforms.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"

mlir/lib/Dialect/NVGPU/Transforms/OptimizeSharedMemory.cpp

 //===- OptimizeSharedMemory.cpp - MLIR NVGPU pass implementation ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements transforms to optimize accesses to shared memory.
 //
 //===----------------------------------------------------------------------===//
-#include "PassDetail.h"
+
+#include "mlir/Dialect/NVGPU/Passes.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
-#include "mlir/Dialect/NVGPU/Passes.h"
 #include "mlir/Dialect/NVGPU/Transforms/Transforms.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/MathExtras.h"
 
+namespace mlir {
+namespace nvgpu {
+#define GEN_PASS_DEF_OPTIMIZESHAREDMEMORYPASS
+#include "mlir/Dialect/NVGPU/Passes.h.inc"
+} // namespace nvgpu
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::nvgpu;
 
 /// The size of a shared memory line according to NV documentation.
 constexpr int64_t kSharedMemoryLineSizeBytes = 128;
 /// We optimize for 128bit accesses, but this can be made an argument in the
 /// future.
 constexpr int64_t kDefaultVectorSizeBits = 128;
transformIndices(builder, shmReadOp->getLoc(), transformedIndices,
                      memRefType, srcDim, tgtDim);
     setIndices(shmReadOp, transformedIndices);
   }
 
   return success();
 }
 
 namespace {
-class OptimizeSharedMemoryPass
-    : public OptimizeSharedMemoryBase<OptimizeSharedMemoryPass> {
+class OptimizeSharedMemoryPass : public nvgpu::impl::OptimizeSharedMemoryPassBase<OptimizeSharedMemoryPass> {
 public:
-  OptimizeSharedMemoryPass() = default;
+  using OptimizeSharedMemoryPassBase::OptimizeSharedMemoryPassBase;
 
   void runOnOperation() override {
     Operation *op = getOperation();
     SmallVector<memref::AllocOp> shmAllocOps;
     op->walk([&](memref::AllocOp allocOp) {
       if (allocOp.getMemref()
               .getType()
               .cast<MemRefType>()

mlir/lib/Dialect/NVGPU/Transforms/PassDetail.h

-//===- PassDetail.h - NVGPU Pass class details -----------------*- 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 DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/Dialect.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace vector {
-class VectorDialect;
-} // namespace vector
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/NVGPU/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_NVGPU_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SCF/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - scf bufferize pass ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFBUFFERIZEPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
-struct SCFBufferizePass : public SCFBufferizeBase<SCFBufferizePass> {
+struct SCFBufferizePass : public impl::SCFBufferizePassBase<SCFBufferizePass> {
+  using SCFBufferizePassBase::SCFBufferizePassBase;
+
   void runOnOperation() override {
     auto func = getOperation();
     auto *context = &getContext();
 
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
     bufferization::populateBufferizeMaterializationLegality(target);
     populateSCFStructuralTypeConversionsAndLegality(typeConverter, patterns,
                                                     target);
     if (failed(applyPartialConversion(func, target, std::move(patterns))))
       return signalPassFailure();
   };
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createSCFBufferizePass() {
-  return std::make_unique<SCFBufferizePass>();
-}

mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp

 //===- ForToWhile.cpp - scf.for to scf.while loop conversion --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Transforms SCF.ForOp's into SCF.WhileOp's.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFFORTOWHILELOOPPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace llvm;
 using namespace mlir;
 using scf::ForOp;
 using scf::WhileOp;
 
 namespace {
 
 struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
LogicalResult matchAndRewrite(ForOp forOp,
     for (const auto &arg : llvm::enumerate(forOp.getResults()))
       arg.value().replaceAllUsesWith(whileOp.getResult(arg.index() + 1));
 
     rewriter.eraseOp(forOp);
     return success();
   }
 };
 
-struct ForToWhileLoop : public SCFForToWhileLoopBase<ForToWhileLoop> {
+struct SCFForToWhileLoopPass
+    : public impl::SCFForToWhileLoopPassBase<SCFForToWhileLoopPass> {
+  using SCFForToWhileLoopPassBase::SCFForToWhileLoopPassBase;
+
   void runOnOperation() override {
     auto *parentOp = getOperation();
     MLIRContext *ctx = parentOp->getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<ForLoopLoweringPattern>(ctx);
     (void)applyPatternsAndFoldGreedily(parentOp, std::move(patterns));
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createForToWhileLoopPass() {
-  return std::make_unique<ForToWhileLoop>();
-}

mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp

 //===- LoopCanonicalization.cpp - Cross-dialect canonicalization patterns -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains cross-dialect canonicalization patterns that cannot be
 // actual canonicalization patterns due to undesired additional dependencies.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFFORLOOPCANONICALIZATIONPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 /// A simple, conservative analysis to determine if the loop is shape
 /// conserving. I.e., the type of the arg-th yielded value is the same as the
 /// type of the corresponding basic block argument of the loop.
 /// Note: This function handles only simple cases. Expand as needed.
 static bool isShapePreserving(ForOp forOp, int64_t arg) {
auto loopMatcher = [](Value iv, OpFoldResult &lb, OpFoldResult &ub,
       return failure();
     };
 
     return scf::canonicalizeMinMaxOpInLoop(rewriter, op, op.getAffineMap(),
                                            op.operands(), IsMin, loopMatcher);
   }
 };
 
-struct SCFForLoopCanonicalization
-    : public SCFForLoopCanonicalizationBase<SCFForLoopCanonicalization> {
+struct SCFForLoopCanonicalizationPass
+    : public impl::SCFForLoopCanonicalizationPassBase<
+          SCFForLoopCanonicalizationPass> {
+  using SCFForLoopCanonicalizationPassBase::SCFForLoopCanonicalizationPassBase;
+
   void runOnOperation() override {
     auto *parentOp = getOperation();
     MLIRContext *ctx = parentOp->getContext();
     RewritePatternSet patterns(ctx);
     scf::populateSCFForLoopCanonicalizationPatterns(patterns);
     if (failed(applyPatternsAndFoldGreedily(parentOp, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 void mlir::scf::populateSCFForLoopCanonicalizationPatterns(
     RewritePatternSet &patterns) {
   MLIRContext *ctx = patterns.getContext();
   patterns
       .add<AffineOpSCFCanonicalizationPattern<AffineMinOp, /*IsMin=*/true>,
            AffineOpSCFCanonicalizationPattern<AffineMaxOp, /*IsMin=*/false>,
            DimOfIterArgFolder<tensor::DimOp>, DimOfIterArgFolder<memref::DimOp>,
            DimOfLoopResultFolder<tensor::DimOp>,
            DimOfLoopResultFolder<memref::DimOp>>(ctx);
 }
-
-std::unique_ptr<Pass> mlir::createSCFForLoopCanonicalizationPass() {
-  return std::make_unique<SCFForLoopCanonicalization>();
-}

mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp

 //===- LoopPipelining.cpp - Code to perform loop software pipelining-------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop software pipelining
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Transforms/Patterns.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/MathExtras.h"
+#include "llvm/ADT/MapVector.h"
 
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 
 /// Helper to keep internal information during pipelining transformation.
 struct LoopPipelinerInternal {

mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp

 //===- LoopRangeFolding.cpp - Code to perform loop range folding-----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop range folding.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFFORLOOPRANGEFOLDINGPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
-struct ForLoopRangeFolding
-    : public SCFForLoopRangeFoldingBase<ForLoopRangeFolding> {
+struct SCFForLoopRangeFoldingPass
+    : public impl::SCFForLoopRangeFoldingPassBase<SCFForLoopRangeFoldingPass> {
+  using SCFForLoopRangeFoldingPassBase::SCFForLoopRangeFoldingPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void ForLoopRangeFolding::runOnOperation() {
+void SCFForLoopRangeFoldingPass::runOnOperation() {
   getOperation()->walk([&](ForOp op) {
     Value indVar = op.getInductionVar();
 
     auto canBeFolded = [&](Value value) {
       return op.isDefinedOutsideOfLoop(value) || value == indVar;
     };
 
     // Fold until a fixed point is reached
while (true) {
       }
 
       ValueRange wrapIndvar(indVar);
       user->replaceAllUsesWith(wrapIndvar);
       user->erase();
     }
   });
 }
-
-std::unique_ptr<Pass> mlir::createForLoopRangeFoldingPass() {
-  return std::make_unique<ForLoopRangeFolding>();
-}

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

 //===- LoopSpecialization.cpp - scf.parallel/SCR.for specialization -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Specializes parallel loops and for loops for easier unrolling and
 // vectorization.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/DenseMap.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFFORLOOPPEELINGPASS
+#define GEN_PASS_DEF_SCFFORLOOPSPECIALIZATIONPASS
+#define GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATIONPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using scf::ForOp;
 using scf::ParallelOp;
 
 /// Rewrite a parallel loop with bounds defined by an affine.min with a constant
 /// into 2 loops after checking if the bounds are equal to that constant. This
 /// is beneficial if the loop will almost always have the constant bound and
 /// that version can be fully unrolled and vectorized.
struct ForLoopPeelingPattern : public OpRewritePattern<ForOp> {
   /// iterations are not usually performance critical.
   /// Note: Takes into account the entire chain of parent operations, not just
   /// the direct parent.
   bool skipPartial;
 };
 } // namespace
 
 namespace {
-struct ParallelLoopSpecialization
-    : public SCFParallelLoopSpecializationBase<ParallelLoopSpecialization> {
+struct SCFParallelLoopSpecializationPass
+    : public impl::SCFParallelLoopSpecializationPassBase<SCFParallelLoopSpecializationPass> {
+  using SCFParallelLoopSpecializationPassBase::SCFParallelLoopSpecializationPassBase;
+
   void runOnOperation() override {
     getOperation()->walk(
         [](ParallelOp op) { specializeParallelLoopForUnrolling(op); });
   }
 };
 
-struct ForLoopSpecialization
-    : public SCFForLoopSpecializationBase<ForLoopSpecialization> {
+struct SCFForLoopSpecializationPass : public impl::SCFForLoopSpecializationPassBase<SCFForLoopSpecializationPass> {
+  using SCFForLoopSpecializationPassBase::SCFForLoopSpecializationPassBase;
+
   void runOnOperation() override {
     getOperation()->walk([](ForOp op) { specializeForLoopForUnrolling(op); });
   }
 };
 
-struct ForLoopPeeling : public SCFForLoopPeelingBase<ForLoopPeeling> {
+struct SCFForLoopPeelingPass : public impl::SCFForLoopPeelingPassBase<SCFForLoopPeelingPass> {
+  using SCFForLoopPeelingPassBase::SCFForLoopPeelingPassBase;
+
   void runOnOperation() override {
     auto *parentOp = getOperation();
     MLIRContext *ctx = parentOp->getContext();
     RewritePatternSet patterns(ctx);
     patterns.add<ForLoopPeelingPattern>(ctx, skipPartial);
     (void)applyPatternsAndFoldGreedily(parentOp, std::move(patterns));
 
     // Drop the markers.
     parentOp->walk([](Operation *op) {
       op->removeAttr(kPeeledLoopLabel);
       op->removeAttr(kPartialIterationLabel);
     });
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createParallelLoopSpecializationPass() {
-  return std::make_unique<ParallelLoopSpecialization>();
-}
-
-std::unique_ptr<Pass> mlir::createForLoopSpecializationPass() {
-  return std::make_unique<ForLoopSpecialization>();
-}
-
-std::unique_ptr<Pass> mlir::createForLoopPeelingPass() {
-  return std::make_unique<ForLoopPeeling>();
-}

mlir/lib/Dialect/SCF/Transforms/ParallelLoopCollapsing.cpp

 //===- ParallelLoopCollapsing.cpp - Pass collapsing parallel loop indices -===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Transforms/Passes.h"
+
+#include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFPARALLELLOOPCOLLAPSINGPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "parallel-loop-collapsing"
 
 using namespace mlir;
 
 namespace {
-struct ParallelLoopCollapsing
-    : public SCFParallelLoopCollapsingBase<ParallelLoopCollapsing> {
+struct SCFParallelLoopCollapsingPass
+    : public impl::SCFParallelLoopCollapsingPassBase<
+          SCFParallelLoopCollapsingPass> {
+  using SCFParallelLoopCollapsingPassBase::SCFParallelLoopCollapsingPassBase;
+
   void runOnOperation() override {
     Operation *module = getOperation();
 
     module->walk([&](scf::ParallelOp op) {
       // The common case for GPU dialect will be simplifying the ParallelOp to 3
       // arguments, so we do that here to simplify things.
       llvm::SmallVector<std::vector<unsigned>, 3> combinedLoops;
       if (!clCollapsedIndices0.empty())
         combinedLoops.push_back(clCollapsedIndices0);
       if (!clCollapsedIndices1.empty())
         combinedLoops.push_back(clCollapsedIndices1);
       if (!clCollapsedIndices2.empty())
         combinedLoops.push_back(clCollapsedIndices2);
       collapseParallelLoops(op, combinedLoops);
     });
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createParallelLoopCollapsingPass() {
-  return std::make_unique<ParallelLoopCollapsing>();
-}

mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp

 //===- ParallelLoopFusion.cpp - Code to perform loop fusion ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop fusion on parallel loops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpDefinition.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFPARALLELLOOPFUSIONPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 /// Verify there are no nested ParallelOps.
 static bool hasNestedParallelOp(ParallelOp ploop) {
   auto walkResult =
       ploop.getBody()->walk([](ParallelOp) { return WalkResult::interrupt(); });
   return walkResult.wasInterrupted();
for (auto &block : region) {
     for (ArrayRef<ParallelOp> ploops : ploopChains) {
       for (int i = 0, e = ploops.size(); i + 1 < e; ++i)
         fuseIfLegal(ploops[i], ploops[i + 1], b);
     }
   }
 }
 
 namespace {
-struct ParallelLoopFusion
-    : public SCFParallelLoopFusionBase<ParallelLoopFusion> {
+struct SCFParallelLoopFusionPass
+    : public impl::SCFParallelLoopFusionPassBase<SCFParallelLoopFusionPass> {
+  using SCFParallelLoopFusionPassBase::SCFParallelLoopFusionPassBase;
+
   void runOnOperation() override {
     getOperation()->walk([&](Operation *child) {
       for (Region &region : child->getRegions())
         naivelyFuseParallelOps(region);
     });
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createParallelLoopFusionPass() {
-  return std::make_unique<ParallelLoopFusion>();
-}

mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp

 //===- ParallelLoopTiling.cpp - Tiles scf.parallel ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop tiling on parallel loops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SCF/Transforms/Passes.h"
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
-#include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SCFPARALLELLOOPTILINGPASS
+#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::scf;
 
 /// Tile a parallel loop of the form
 ///   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
 ///                                            step (%arg4, %arg5)
 ///
 /// into
if (noMinMaxBounds && needInboundCheck) {
     }
   }
 
   op.erase();
   return std::make_pair(outerLoop, innerLoop);
 }
 
 namespace {
-struct ParallelLoopTiling
-    : public SCFParallelLoopTilingBase<ParallelLoopTiling> {
-  ParallelLoopTiling() = default;
-  explicit ParallelLoopTiling(ArrayRef<int64_t> tileSizes,
-                              bool noMinMaxBounds = false) {
-    this->tileSizes = tileSizes;
-    this->noMinMaxBounds = noMinMaxBounds;
-  }
+struct SCFParallelLoopTilingPass
+    : public impl::SCFParallelLoopTilingPassBase<SCFParallelLoopTilingPass> {
+  using SCFParallelLoopTilingPassBase::SCFParallelLoopTilingPassBase;
 
   void runOnOperation() override {
     auto *parentOp = getOperation();
     SmallVector<ParallelOp, 2> innermostPloops;
     getInnermostParallelLoops(parentOp, innermostPloops);
     for (ParallelOp ploop : innermostPloops) {
       // FIXME: Add reduction support.
       if (ploop.getNumReductions() == 0)
         tileParallelLoop(ploop, tileSizes, noMinMaxBounds);
     }
   }
 };
 } // namespace
-
-std::unique_ptr<Pass>
-mlir::createParallelLoopTilingPass(ArrayRef<int64_t> tileSizes,
-                                   bool noMinMaxBounds) {
-  return std::make_unique<ParallelLoopTiling>(tileSizes, noMinMaxBounds);
-}

mlir/lib/Dialect/SCF/Transforms/PassDetail.h

-//===- PassDetail.h - Loop Pass class details -------------------*- 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 DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-// Forward declaration from Dialect.h
-template <typename ConcreteDialect>
-void registerDialect(DialectRegistry &registry);
-
-class AffineDialect;
-
-namespace arith {
-class ArithmeticDialect;
-} // namespace arith
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace tensor {
-class TensorDialect;
-} // namespace tensor
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_SCF_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp

 //===- StructuralTypeConversions.cpp - scf structural type conversions ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace mlir::scf;
 

mlir/lib/Dialect/SPIRV/Transforms/CanonicalizeGLPass.cpp

 //===- CanonicalizeGLPass.cpp - GLSL Related Canonicalization Pass ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
 #include "mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVCANONICALIZEGLPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-class CanonicalizeGLPass final
-    : public SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
+class SPIRVCanonicalizeGLPass final
+    : public spirv::impl::SPIRVCanonicalizeGLPassBase<SPIRVCanonicalizeGLPass> {
 public:
+  using SPIRVCanonicalizeGLPassBase::SPIRVCanonicalizeGLPassBase;
+
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
     spirv::populateSPIRVGLCanonicalizationPatterns(patterns);
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<>> spirv::createCanonicalizeGLPass() {
-  return std::make_unique<CanonicalizeGLPass>();
+  return std::make_unique<SPIRVCanonicalizeGLPass>();
 }

mlir/lib/Dialect/SPIRV/Transforms/DecorateCompositeTypeLayoutPass.cpp

 //===- DecorateCompositeTypeLayoutPass.cpp - Decorate composite type ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to decorate the composite types used by
 // composite objects in the StorageBuffer, PhysicalStorageBuffer, Uniform, and
 // PushConstant storage classes with layout information. See SPIR-V spec
 // "2.16.2. Validation Rules for Shader Capabilities" for more details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVDECORATECOMPOSITETYPELAYOUTPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 namespace {
 class SPIRVGlobalVariableOpLayoutInfoDecoration
     : public OpRewritePattern<spirv::GlobalVariableOp> {
 public:
   using OpRewritePattern<spirv::GlobalVariableOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(spirv::GlobalVariableOp op,
                                 PatternRewriter &rewriter) const override {
patterns.add<SPIRVGlobalVariableOpLayoutInfoDecoration,
                SPIRVAddressOfOpLayoutInfoDecoration,
                SPIRVPassThroughConversion<spirv::AccessChainOp>,
                SPIRVPassThroughConversion<spirv::LoadOp>,
                SPIRVPassThroughConversion<spirv::StoreOp>>(
       patterns.getContext());
 }
 
 namespace {
-class DecorateSPIRVCompositeTypeLayoutPass
-    : public SPIRVCompositeTypeLayoutBase<
-          DecorateSPIRVCompositeTypeLayoutPass> {
+class SPIRVDecorateCompositeTypeLayoutPass
+    : public spirv::impl::SPIRVDecorateCompositeTypeLayoutPassBase<
+          SPIRVDecorateCompositeTypeLayoutPass> {
+  using SPIRVDecorateCompositeTypeLayoutPassBase::
+      SPIRVDecorateCompositeTypeLayoutPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void DecorateSPIRVCompositeTypeLayoutPass::runOnOperation() {
+void SPIRVDecorateCompositeTypeLayoutPass::runOnOperation() {
   auto module = getOperation();
   RewritePatternSet patterns(module.getContext());
   populateSPIRVLayoutInfoPatterns(patterns);
   ConversionTarget target(*(module.getContext()));
   target.addLegalDialect<spirv::SPIRVDialect>();
   target.addLegalOp<func::FuncOp>();
   target.addDynamicallyLegalOp<spirv::GlobalVariableOp>(
       [](spirv::GlobalVariableOp op) {
void SPIRVDecorateCompositeTypeLayoutPass::runOnOperation() {
   FrozenRewritePatternSet frozenPatterns(std::move(patterns));
   for (auto spirvModule : module.getOps<spirv::ModuleOp>())
     if (failed(applyFullConversion(spirvModule, target, frozenPatterns)))
       signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass() {
-  return std::make_unique<DecorateSPIRVCompositeTypeLayoutPass>();
+  return std::make_unique<SPIRVDecorateCompositeTypeLayoutPass>();
 }

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

 //===- LowerABIAttributesPass.cpp - Decorate composite type ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to lower attributes that specify the shader ABI
 // for the functions in the generated SPIR-V module.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SetVector.h"
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVLOWERABIATTRIBUTESPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 using namespace mlir;
 
 /// Creates a global variable for an argument based on the ABI info.
 static spirv::GlobalVariableOp
 createGlobalVarForEntryPointArgument(OpBuilder &builder, spirv::FuncOp funcOp,
                                      unsigned argIndex,
                                      spirv::InterfaceVarABIAttr abiInfo) {
   auto spirvModule = funcOp->getParentOfType<spirv::ModuleOp>();
public:
   using OpConversionPattern<spirv::FuncOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pass to implement the ABI information specified as attributes.
-class LowerABIAttributesPass final
-    : public SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
+class SPIRVLowerABIAttributesPass final
+    : public spirv::impl::SPIRVLowerABIAttributesPassBase<SPIRVLowerABIAttributesPass> {
+  using SPIRVLowerABIAttributesPassBase::SPIRVLowerABIAttributesPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
     spirv::FuncOp funcOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>(
LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
   // Creates a new function with the update signature.
   rewriter.updateRootInPlace(funcOp, [&] {
     funcOp.setType(rewriter.getFunctionType(
         signatureConverter.getConvertedTypes(), llvm::None));
   });
   return success();
 }
 
-void LowerABIAttributesPass::runOnOperation() {
+void SPIRVLowerABIAttributesPass::runOnOperation() {
   // Uses the signature conversion methodology of the dialect conversion
   // framework to implement the conversion.
   spirv::ModuleOp module = getOperation();
   MLIRContext *context = &getContext();
 
   spirv::TargetEnv targetEnv(spirv::lookupTargetEnv(module));
 
   SPIRVTypeConverter typeConverter(targetEnv);
for (auto fn : entryPointFns) {
     if (failed(lowerEntryPointABIAttr(fn, builder))) {
       return signalPassFailure();
     }
   }
 }
 
 std::unique_ptr<OperationPass<spirv::ModuleOp>>
 mlir::spirv::createLowerABIAttributesPass() {
-  return std::make_unique<LowerABIAttributesPass>();
+  return std::make_unique<SPIRVLowerABIAttributesPass>();
 }

mlir/lib/Dialect/SPIRV/Transforms/PassDetail.h

-//===- PassDetail.h - SPIRV Pass class details ------------------*- 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 DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/IR/BuiltinOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace spirv {
-class ModuleOp;
-} // namespace spirv
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SPIRV/Transforms/RewriteInsertsPass.cpp

 //===- RewriteInsertsPass.cpp - MLIR conversion pass ----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to rewrite sequential chains of
 // `spirv::CompositeInsert` operations into `spirv::CompositeConstruct`
 // operations.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVREWRITEINSERTSPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
 /// Replaces sequential chains of `spirv::CompositeInsertOp` operation into
 /// `spirv::CompositeConstructOp` operation if possible.
-class RewriteInsertsPass
-    : public SPIRVRewriteInsertsPassBase<RewriteInsertsPass> {
+class SPIRVRewriteInsertsPass
+    : public spirv::impl::SPIRVRewriteInsertsPassBase<SPIRVRewriteInsertsPass> {
 public:
+  using SPIRVRewriteInsertsPassBase::SPIRVRewriteInsertsPassBase;
+
   void runOnOperation() override;
 
 private:
   /// Collects a sequential insertion chain by the given
   /// `spirv::CompositeInsertOp` operation, if the given operation is the last
   /// in the chain.
   LogicalResult
   collectInsertionChain(spirv::CompositeInsertOp op,
                         SmallVectorImpl<spirv::CompositeInsertOp> &insertions);
 };
 
 } // namespace
 
-void RewriteInsertsPass::runOnOperation() {
+void SPIRVRewriteInsertsPass::runOnOperation() {
   SmallVector<SmallVector<spirv::CompositeInsertOp, 4>, 4> workList;
   getOperation().walk([this, &workList](spirv::CompositeInsertOp op) {
     SmallVector<spirv::CompositeInsertOp, 4> insertions;
     if (succeeded(collectInsertionChain(op, insertions)))
       workList.push_back(insertions);
   });
 
   for (const auto &insertions : workList) {
for (const auto &insertions : workList) {
     for (auto insertOp : llvm::reverse(insertions)) {
       auto *op = insertOp.getOperation();
       if (op->use_empty())
         insertOp.erase();
     }
   }
 }
 
-LogicalResult RewriteInsertsPass::collectInsertionChain(
+LogicalResult SPIRVRewriteInsertsPass::collectInsertionChain(
     spirv::CompositeInsertOp op,
     SmallVectorImpl<spirv::CompositeInsertOp> &insertions) {
   auto indicesArrayAttr = op.indices().cast<ArrayAttr>();
   // TODO: handle nested composite object.
   if (indicesArrayAttr.size() == 1) {
     auto numElements =
         op.composite().getType().cast<spirv::CompositeType>().getNumElements();
 
while (true) {
         return failure();
     }
   }
   return failure();
 }
 
 std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
 mlir::spirv::createRewriteInsertsPass() {
-  return std::make_unique<RewriteInsertsPass>();
+  return std::make_unique<SPIRVRewriteInsertsPass>();
 }

mlir/lib/Dialect/SPIRV/Transforms/UnifyAliasedResourcePass.cpp

 //===- UnifyAliasedResourcePass.cpp - Pass to Unify Aliased Resources -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass that unifies access of multiple aliased resources
 // into access of one single resource.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 #include <algorithm>
 #include <iterator>
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVUNIFYALIASEDRESOURCEPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 #define DEBUG_TYPE "spirv-unify-aliased-resource"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//
 
struct ConvertStore : public ConvertAliasResource<spirv::StoreOp> {
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Pass
 //===----------------------------------------------------------------------===//
 
 namespace {
-class UnifyAliasedResourcePass final
-    : public SPIRVUnifyAliasedResourcePassBase<UnifyAliasedResourcePass> {
+class SPIRVUnifyAliasedResourcePass final
+    : public spirv::impl::SPIRVUnifyAliasedResourcePassBase<SPIRVUnifyAliasedResourcePass> {
 public:
+  using SPIRVUnifyAliasedResourcePassBase::SPIRVUnifyAliasedResourcePassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void UnifyAliasedResourcePass::runOnOperation() {
+void SPIRVUnifyAliasedResourcePass::runOnOperation() {
   spirv::ModuleOp moduleOp = getOperation();
   MLIRContext *context = &getContext();
 
   // Analyze aliased resources first.
   ResourceAliasAnalysis &analysis = getAnalysis<ResourceAliasAnalysis>();
 
   ConversionTarget target(*context);
   target.addDynamicallyLegalOp<spirv::GlobalVariableOp, spirv::AddressOfOp,
for (const auto &dr : resourceMap) {
     const auto &resources = dr.second;
     if (resources.size() == 1)
       resources.front()->removeAttr("aliased");
   }
 }
 
 std::unique_ptr<mlir::OperationPass<spirv::ModuleOp>>
 spirv::createUnifyAliasedResourcePass() {
-  return std::make_unique<UnifyAliasedResourcePass>();
+  return std::make_unique<SPIRVUnifyAliasedResourcePass>();
 }

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

 //===- DeduceVersionExtensionCapabilityPass.cpp ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to deduce minimal version/extension/capability
 // requirements for a spirv::ModuleOp.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
+
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
-#include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Visitors.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 
+namespace mlir {
+namespace spirv {
+#define GEN_PASS_DEF_SPIRVUPDATEVCEPASS
+#include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
+} // namespace spirv
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Pass to deduce minimal version/extension/capability requirements for a
 /// spirv::ModuleOp.
-class UpdateVCEPass final : public SPIRVUpdateVCEBase<UpdateVCEPass> {
+class SPIRVUpdateVCEPass final
+    : public spirv::impl::SPIRVUpdateVCEPassBase<SPIRVUpdateVCEPass> {
+  using SPIRVUpdateVCEPassBase::SPIRVUpdateVCEPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
 /// Checks that `candidates` extension requirements are possible to be satisfied
 /// with the given `targetEnv` and updates `deducedExtensions` if so. Emits
 /// errors attaching to the given `op` on failures.
 ///
if (Optional<spirv::Capability> chosen = targetEnv.allows(ors)) {
              << op->getName() << "' requires at least one capability in ["
              << llvm::join(capStrings, ", ")
              << "] but none allowed in target environment";
     }
   }
   return success();
 }
 
-void UpdateVCEPass::runOnOperation() {
+void SPIRVUpdateVCEPass::runOnOperation() {
   spirv::ModuleOp module = getOperation();
 
   spirv::TargetEnvAttr targetAttr = spirv::lookupTargetEnv(module);
   if (!targetAttr) {
     module.emitError("missing 'spv.target_env' attribute");
     return signalPassFailure();
   }
 
void SPIRVUpdateVCEPass::runOnOperation() {
   auto triple = spirv::VerCapExtAttr::get(
       deducedVersion, deducedCapabilities.getArrayRef(),
       deducedExtensions.getArrayRef(), &getContext());
   module->setAttr(spirv::ModuleOp::getVCETripleAttrName(), triple);
 }
 
 std::unique_ptr<OperationPass<spirv::ModuleOp>>
 mlir::spirv::createUpdateVersionCapabilityExtensionPass() {
-  return std::make_unique<UpdateVCEPass>();
+  return std::make_unique<SPIRVUpdateVCEPass>();
 }

mlir/lib/Dialect/Shape/Transforms/Bufferize.cpp

 //====----- Bufferize.cpp - Bufferization of shape ops  ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.h"
+
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.h"
-#include "mlir/Dialect/Shape/Transforms/Passes.h"
 #include "mlir/Pass/Pass.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SHAPEBUFFERIZEPASS
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace bufferization;
 
 namespace {
-struct ShapeBufferizePass : public ShapeBufferizeBase<ShapeBufferizePass> {
+struct ShapeBufferizePass
+    : public impl::ShapeBufferizePassBase<ShapeBufferizePass> {
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     options.opFilter.allowDialect<shape::ShapeDialect>();
 
     if (failed(bufferizeOp(getOperation(), options)))
       signalPassFailure();
   }
 

mlir/lib/Dialect/Shape/Transforms/PassDetail.h

-//===- PassDetail.h - Shape Pass class details ------------------*- 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 DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Shape/Transforms/RemoveShapeConstraints.cpp

 //===-- RemoveShapeConstraints.cpp - Remove Shape Cstr and Assuming Ops ---===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/Shape/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_REMOVESHAPECONSTRAINTSPASS
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Removal patterns.
 class RemoveCstrBroadcastableOp
     : public OpRewritePattern<shape::CstrBroadcastableOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
public:
   LogicalResult matchAndRewrite(shape::CstrEqOp op,
                                 PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<shape::ConstWitnessOp>(op.getOperation(), true);
     return success();
   }
 };
 
 /// Removal pass.
-class RemoveShapeConstraintsPass
-    : public RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
+struct RemoveShapeConstraintsPass
+    : public impl::RemoveShapeConstraintsPassBase<RemoveShapeConstraintsPass> {
+  using RemoveShapeConstraintsPassBase::RemoveShapeConstraintsPassBase;
 
   void runOnOperation() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     populateRemoveShapeConstraintsPatterns(patterns);
 
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));

mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp

 //===- ShapeToShapeLowering.cpp - Prepare for lowering to Standard --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Dialect/Shape/Transforms/Passes.h"
+
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
-#include "mlir/Dialect/Shape/Transforms/Passes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SHAPETOSHAPELOWERINGPASS
+#include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::shape;
 
 namespace {
 /// Converts `shape.num_elements` to `shape.reduce`.
 struct NumElementsOpConverter : public OpRewritePattern<NumElementsOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
Value product = b.create<MulOp>(loc, valueType, body->getArgument(1),
                                   body->getArgument(2));
   b.create<shape::YieldOp>(loc, product);
 
   rewriter.replaceOp(op, reduce.getResult());
   return success();
 }
 
 namespace {
-struct ShapeToShapeLowering
-    : public ShapeToShapeLoweringBase<ShapeToShapeLowering> {
+struct ShapeToShapeLoweringPass
+    : public impl::ShapeToShapeLoweringPassBase<ShapeToShapeLoweringPass> {
+  using ShapeToShapeLoweringPassBase::ShapeToShapeLoweringPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void ShapeToShapeLowering::runOnOperation() {
+void ShapeToShapeLoweringPass::runOnOperation() {
   MLIRContext &ctx = getContext();
 
   RewritePatternSet patterns(&ctx);
   populateShapeRewritePatterns(patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<arith::ArithmeticDialect, ShapeDialect>();
   target.addIllegalOp<NumElementsOp>();
   if (failed(mlir::applyPartialConversion(getOperation(), target,
                                           std::move(patterns))))
     signalPassFailure();
 }
 
 void mlir::populateShapeRewritePatterns(RewritePatternSet &patterns) {
   patterns.add<NumElementsOpConverter>(patterns.getContext());
 }
 
 std::unique_ptr<Pass> mlir::createShapeToShapeLowering() {
-  return std::make_unique<ShapeToShapeLowering>();
+  return std::make_unique<ShapeToShapeLoweringPass>();
 }

mlir/lib/Dialect/SparseTensor/Pipelines/SparseTensorPipelines.cpp

void mlir::sparse_tensor::buildSparseCompiler(
   pm.addPass(createDenseBufferizationPass(
       getBufferizationOptions(/*analysisOnly=*/false)));
   pm.addNestedPass<func::FuncOp>(
       mlir::bufferization::createFinalizingBufferizePass());
   // TODO(springerm): Add sparse support to the BufferDeallocation pass and add
   // it to this pipeline.
   pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
   pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
-  pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
-  pm.addPass(createLowerAffinePass());
+  pm.addNestedPass<func::FuncOp>(createConvertSCFToControlFlowPass());
+  pm.addPass(createConvertAffineToStandardPass());
   pm.addPass(createConvertVectorToLLVMPass(options.lowerVectorToLLVMOptions()));
-  pm.addPass(createMemRefToLLVMPass());
+  pm.addPass(createConvertMemRefToLLVMPass());
   pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
   pm.addNestedPass<mlir::func::FuncOp>(
       mlir::arith::createArithmeticExpandOpsPass());
   pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
   pm.addPass(createConvertMathToLibmPass());
   pm.addPass(createConvertComplexToLibmPass());
   pm.addPass(createConvertComplexToLLVMPass());
   pm.addPass(createConvertFuncToLLVMPass());

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp

 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Linalg/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SparseTensor/IR/SparseTensor.h"
 #include "mlir/Dialect/SparseTensor/Transforms/Passes.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_SPARSIFICATIONPASS
+#define GEN_PASS_DEF_SPARSETENSORCONVERSIONPASS
+#define GEN_PASS_DEF_SPARSETENSORCODEGENPASS
+#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::sparse_tensor;
 
 namespace {
 
 //===----------------------------------------------------------------------===//
-// Passes declaration.
-//===----------------------------------------------------------------------===//
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/SparseTensor/Transforms/Passes.h.inc"
-
-//===----------------------------------------------------------------------===//
 // Passes implementation.
 //===----------------------------------------------------------------------===//
 
-struct SparsificationPass : public SparsificationBase<SparsificationPass> {
+struct SparsificationPass : public mlir::impl::SparsificationPassBase<SparsificationPass> {
 
   SparsificationPass() = default;
   SparsificationPass(const SparsificationPass &pass) = default;
   SparsificationPass(const SparsificationOptions &options) {
     parallelization = static_cast<int32_t>(options.parallelizationStrategy);
     vectorization = static_cast<int32_t>(options.vectorizationStrategy);
     vectorLength = options.vectorLength;
     enableSIMDIndex32 = options.enableSIMDIndex32;
void runOnOperation() override {
     RewritePatternSet patterns(ctx);
     populateSparsificationPatterns(patterns, options);
     vector::populateVectorToVectorCanonicalizationPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 
 struct SparseTensorConversionPass
-    : public SparseTensorConversionBase<SparseTensorConversionPass> {
+    : public mlir::impl::SparseTensorConversionPassBase<SparseTensorConversionPass> {
 
   SparseTensorConversionPass() = default;
   SparseTensorConversionPass(const SparseTensorConversionPass &pass) = default;
   SparseTensorConversionPass(const SparseTensorConversionOptions &options) {
     sparseToSparse = static_cast<int32_t>(options.sparseToSparseStrategy);
   }
 
   void runOnOperation() override {
void runOnOperation() override {
     populateSparseTensorConversionPatterns(converter, patterns, options);
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 
 struct SparseTensorCodegenPass
-    : public SparseTensorCodegenBase<SparseTensorCodegenPass> {
+    : public mlir::impl::SparseTensorCodegenPassBase<SparseTensorCodegenPass> {
 
   SparseTensorCodegenPass() = default;
   SparseTensorCodegenPass(const SparseTensorCodegenPass &pass) = default;
 
   void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     SparseTensorTypeToBufferConverter converter;

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization for `tensor` dialect ops -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements bufferization of `tensor` dialect ops
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Tensor/Transforms/Passes.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/Transforms/DialectConversion.h"
 
+namespace mlir {
+namespace tensor {
+#define GEN_PASS_DEF_TENSORBUFFERIZEPASS
+#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
+} // namespace tensor
+} // namespace mlir
+
 using namespace mlir;
 using namespace bufferization;
 
 namespace {
-struct TensorBufferizePass : public TensorBufferizeBase<TensorBufferizePass> {
+struct TensorBufferizePass
+    : public tensor::impl::TensorBufferizePassBase<TensorBufferizePass> {
+  using TensorBufferizePassBase::TensorBufferizePassBase;
+
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     options.opFilter.allowDialect<tensor::TensorDialect>();
 
     if (failed(bufferizeOp(getOperation(), options)))
       signalPassFailure();
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect,
                     tensor::TensorDialect, scf::SCFDialect,
                     arith::ArithmeticDialect>();
     tensor::registerBufferizableOpInterfaceExternalModels(registry);
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::createTensorBufferizePass() {
-  return std::make_unique<TensorBufferizePass>();
-}

mlir/lib/Dialect/Tensor/Transforms/PassDetail.h

-//===- PassDetail.h - GPU Pass class details --------------------*- 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 DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-namespace scf {
-class SCFDialect;
-} // namespace scf
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

 //===- TosaInferShapes.cpp ------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Propogate shapes forward along TOSA operations to resolve dynamic shape
 // operations.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Tosa/Transforms/Passes.h"
+
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
-#include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Utils/ShapeUtils.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/FormatVariadic.h"
 
+namespace mlir {
+namespace tosa {
+#define GEN_PASS_DEF_TOSAINFERSHAPESPASS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::tosa;
 
 namespace {
 
 void propagateShapesInRegion(Region &region);
 
 void propagateShapesToTosaIf(
if (result.hasRank()) {
       Type t = it.first.getType().cast<ShapedType>().clone(result.getDims());
       it.first.setType(t);
     }
   }
 }
 
 /// Pass that performs shape propagation across TOSA operations. This includes
 /// migrating to within the regions of if/while operations.
-struct TosaInferShapes : public TosaInferShapesBase<TosaInferShapes> {
+struct TosaInferShapesPass : public tosa::impl::TosaInferShapesPassBase<TosaInferShapesPass> {
 public:
+  using TosaInferShapesPassBase::TosaInferShapesPassBase;
+
   void runOnOperation() override {
     func::FuncOp func = getOperation();
 
     IRRewriter rewriter(func.getContext());
 
     propagateShapesInRegion(func.getBody());
 
     // Insert UnrealizedConversionCasts to guarantee ReturnOp agress with
func.walk([&](func::ReturnOp op) {
 
       if (castAdded) {
         rewriter.replaceOpWithNewOp<func::ReturnOp>(op, castedValues);
       }
     });
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaInferShapesPass() {
-  return std::make_unique<TosaInferShapes>();
-}

mlir/lib/Dialect/Tosa/Transforms/TosaLayerwiseConstantFoldPass.cpp

 //===- TosaLayerwiseConstantFoldPass.cpp ----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements constant folding transformations on TOSA operations
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace tosa {
+#define GEN_PASS_DEF_TOSALAYERWISECONSTANTFOLDPASS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::tosa;
 
 namespace {
 
 template <typename... Args>
 void addOpsCanonicalizations(MLIRContext *ctx, RewritePatternSet &patterns) {
   (Args::getCanonicalizationPatterns(patterns, ctx), ...);
 }
 
 void populateTosaOpsCanonicalizationPatterns(MLIRContext *ctx,
                                              RewritePatternSet &patterns) {
   addOpsCanonicalizations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Tosa/IR/TosaOps.cpp.inc"
       >(ctx, patterns);
 }
 
 struct TosaLayerwiseConstantFoldPass
-    : public TosaLayerwiseConstantFoldPassBase<TosaLayerwiseConstantFoldPass> {
+    : public tosa::impl::TosaLayerwiseConstantFoldPassBase<
+          TosaLayerwiseConstantFoldPass> {
+  using TosaLayerwiseConstantFoldPassBase::TosaLayerwiseConstantFoldPassBase;
+
   void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     auto func = getOperation();
 
     mlir::tosa::populateTosaFoldConstantTransposePatterns(ctx, patterns);
     populateTosaOpsCanonicalizationPatterns(ctx, patterns);
 
     if (applyPatternsAndFoldGreedily(func, std::move(patterns)).failed())
       signalPassFailure();
   }
 };
 
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaLayerwiseConstantFoldPass() {
-  return std::make_unique<TosaLayerwiseConstantFoldPass>();
-}

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

 //===- TosaMakeBroadcastable.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Insert reshape to binary op's input if needed to match rank
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
-#include "mlir/Dialect/Tosa/IR//TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace tosa {
+#define GEN_PASS_DEF_TOSAMAKEBROADCASTABLEPASS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
 using namespace mlir;
 using namespace mlir::tosa;
 
 /// There are two potential ways implementing broadcast:
 /// a. https://www.tensorflow.org/xla/broadcasting#formal_definition
 /// b. https://numpy.org/doc/stable/user/basics.broadcasting.html
 /// This pass implements b (numpy style) now.
 
LogicalResult matchAndRewrite(tosa::ArithmeticRightShiftOp tosaBinaryOp,
     return success();
   }
 };
 } // namespace
 
 namespace {
 /// Pass that enables broadcast by making all input arrays have the same
 /// number of dimensions. Insert RESHAPE operations to lower rank operand
-struct TosaMakeBroadcastable
-    : public TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
+struct TosaMakeBroadcastablePass : public tosa::impl::TosaMakeBroadcastablePassBase<TosaMakeBroadcastablePass> {
 public:
+  using TosaMakeBroadcastablePassBase::TosaMakeBroadcastablePassBase;
+
   void runOnOperation() override {
     auto func = getOperation();
     RewritePatternSet patterns(func.getContext());
     MLIRContext *ctx = func.getContext();
     // Add the generated patterns to the list.
     patterns.add<ConvertTosaOp<tosa::BitwiseAndOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::BitwiseOrOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::BitwiseXorOp>>(ctx);
void runOnOperation() override {
     patterns.add<ConvertTosaOp<tosa::LogicalAndOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::LogicalOrOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::LogicalXorOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::PowOp>>(ctx);
     (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaMakeBroadcastablePass() {
-  return std::make_unique<TosaMakeBroadcastable>();
-}

mlir/lib/Dialect/Tosa/Transforms/TosaOptionalDecompositions.cpp

 //===- TosaOptionalDecompositions.cpp -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Pass to apply the Tosa operations decompositions
 // exposed as populate functions in
 // include/mlir/Dialect/Tosa/Transforms/Passes.h
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
+namespace mlir {
+namespace tosa {
+#define GEN_PASS_DEF_TOSAOPTIONALDECOMPOSITIONSPASS
+#include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
+} // namespace tosa
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
-struct TosaOptionalDecompositions
-    : public TosaOptionalDecompositionsBase<TosaOptionalDecompositions> {
+struct TosaOptionalDecompositionsPass
+    : public tosa::impl::TosaOptionalDecompositionsPassBase<
+          TosaOptionalDecompositionsPass> {
+  using TosaOptionalDecompositionsPassBase::TosaOptionalDecompositionsPassBase;
+
   void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     auto func = getOperation();
 
     mlir::tosa::populateTosaDecomposeConv2D(ctx, patterns);
     mlir::tosa::populateTosaDecomposeTransposeConv(ctx, patterns);
     mlir::tosa::populateTosaDecomposeDepthwise(ctx, patterns);
 
     if (applyPatternsAndFoldGreedily(func, std::move(patterns)).failed())
       signalPassFailure();
   }
 };
 
 } // namespace
-
-std::unique_ptr<Pass> mlir::tosa::createTosaOptionalDecompositions() {
-  return std::make_unique<TosaOptionalDecompositions>();
-}

mlir/lib/Dialect/Transform/Transforms/CheckUses.cpp

 //===- CheckUses.cpp - Expensive transform value validity checks ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a pass that performs expensive opt-in checks for Transform
 // dialect values being potentially used after they have been consumed.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/Transforms/Passes.h"
+
+#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/SetOperations.h"
 
+namespace mlir {
+namespace transform {
+#define GEN_PASS_DEF_CHECKUSESPASS
+#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
+} // namespace transform
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 
 /// Returns a reference to a cached set of blocks that are reachable from the
 /// given block via edges computed by the `getNextNodes` function. For example,
 /// if `getNextNodes` returns successors of a block, this will return the set of
 /// reachable blocks; if it returns predecessors of a block, this will return
private:
   /// Transform operations transitively containing such operations.
   DenseMap<Value, llvm::SmallPtrSet<Operation *, 2>> freedBy;
 
   /// Caches for sets of reachable blocks.
   DenseMap<Block *, llvm::SmallPtrSet<Block *, 4>> reachableCache;
   DenseMap<Block *, llvm::SmallPtrSet<Block *, 4>> reachableFromCache;
 };
 
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Transform/Transforms/Passes.h.inc"
-
 //// A simple pass that warns about any use of a value by a transform operation
 // that may be using the value after it has been freed.
-class CheckUsesPass : public CheckUsesBase<CheckUsesPass> {
+class CheckUsesPass : public transform::impl::CheckUsesPassBase<CheckUsesPass> {
 public:
+  using CheckUsesPassBase::CheckUsesPassBase;
+
   void runOnOperation() override {
     auto &analysis = getAnalysis<TransformOpMemFreeAnalysis>();
 
     getOperation()->walk([&](Operation *child) {
       for (OpOperand &operand : child->getOpOperands()) {
         TransformOpMemFreeAnalysis::PotentialDeleters deleters =
             analysis.isUseLive(operand);
         if (!deleters)
           continue;
 
         InFlightDiagnostic diag = child->emitWarning()
                                   << "operand #" << operand.getOperandNumber()
                                   << " may be used after free";
         diag.attachNote(operand.get().getLoc()) << "allocated here";
         for (Operation *d : deleters.getOps()) {
           diag.attachNote(d->getLoc()) << "freed here";
         }
       }
     });
   }
 };
 
 } // namespace
-
-namespace mlir {
-namespace transform {
-std::unique_ptr<Pass> createCheckUsesPass() {
-  return std::make_unique<CheckUsesPass>();
-}
-} // namespace transform
-} // namespace mlir

mlir/lib/Dialect/Vector/Transforms/Bufferize.cpp

 //===- Bufferize.cpp - Bufferization for `vector` dialect ops -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements bufferization of `vector` dialect ops
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Bufferization/Transforms/Bufferize.h"
-#include "PassDetail.h"
+
 #include "mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h"
 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Vector/Transforms/Passes.h"
 
+namespace mlir {
+namespace vector {
+#define GEN_PASS_DEF_VECTORBUFFERIZEPASS
+#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
+} // namespace vector
+} // namespace mlir
+
 using namespace mlir;
 using namespace bufferization;
 
 namespace {
-struct VectorBufferizePass : public VectorBufferizeBase<VectorBufferizePass> {
+struct VectorBufferizePass
+    : public vector::impl::VectorBufferizePassBase<VectorBufferizePass> {
+  using VectorBufferizePassBase::VectorBufferizePassBase;
+
   void runOnOperation() override {
     BufferizationOptions options = getPartialBufferizationOptions();
     options.opFilter.allowDialect<vector::VectorDialect>();
 
     if (failed(bufferizeOp(getOperation(), options)))
       signalPassFailure();
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect, memref::MemRefDialect,
                     tensor::TensorDialect, vector::VectorDialect>();
     vector::registerBufferizableOpInterfaceExternalModels(registry);
   }
 };
 } // namespace
-
-std::unique_ptr<Pass> mlir::vector::createVectorBufferizePass() {
-  return std::make_unique<VectorBufferizePass>();
-}

mlir/lib/Dialect/Vector/Transforms/PassDetail.h

-//===- PassDetail.h - Vector Pass class details -----------------*- 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 DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
-#define DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Dialect/Func/IR/FuncOps.h"
-#include "mlir/Pass/Pass.h"
-
-namespace mlir {
-
-namespace bufferization {
-class BufferizationDialect;
-} // namespace bufferization
-
-namespace memref {
-class MemRefDialect;
-} // namespace memref
-
-#define GEN_PASS_CLASSES
-#include "mlir/Dialect/Vector/Transforms/Passes.h.inc"
-
-} // namespace mlir
-
-#endif // DIALECT_VECTOR_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Reducer/OptReductionPass.cpp

 //===- OptReductionPass.cpp - Optimization Reduction Pass Wrapper ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the Opt Reduction Pass Wrapper. It creates a MLIR pass to
 // run any optimization pass within it and only replaces the output module with
 // the transformed version if it is smaller and interesting.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Pass/PassRegistry.h"
-#include "mlir/Reducer/PassDetail.h"
 #include "mlir/Reducer/Passes.h"
 #include "mlir/Reducer/Tester.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_OPTREDUCTIONPASS
+#include "mlir/Reducer/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "mlir-reduce"
 
 using namespace mlir;
 
 namespace {
 
-class OptReductionPass : public OptReductionBase<OptReductionPass> {
+class OptReductionPass
+    : public mlir::impl::OptReductionPassBase<OptReductionPass> {
 public:
   /// Runs the pass instance in the pass pipeline.
   void runOnOperation() override;
 };
 
 } // namespace
 
 /// Runs the pass instance in the pass pipeline.

mlir/lib/Reducer/ReductionTreePass.cpp

 // allows for custom specification of the variant generation behavior. It
 // implements methods that define the different possible traversals of the
 // reduction tree.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/OpDefinition.h"
-#include "mlir/Reducer/PassDetail.h"
 #include "mlir/Reducer/Passes.h"
 #include "mlir/Reducer/ReductionNode.h"
 #include "mlir/Reducer/ReductionPatternInterface.h"
 #include "mlir/Reducer/Tester.h"
 #include "mlir/Rewrite/FrozenRewritePatternSet.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ManagedStatic.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_REDUCTIONTREEPASS
+#include "mlir/Reducer/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 /// We implicitly number each operation in the region and if an operation's
 /// number falls into rangeToKeep, we need to keep it and apply the given
 /// rewrite patterns on it.
 static void applyPatterns(Region &region,
                           const FrozenRewritePatternSet &patterns,
                           ArrayRef<ReductionNode::Range> rangeToKeep,

 
 //===----------------------------------------------------------------------===//
 // ReductionTreePass
 //===----------------------------------------------------------------------===//
 
 /// This class defines the Reduction Tree Pass. It provides a framework to
 /// to implement a reduction pass using a tree structure to keep track of the
 /// generated reduced variants.
-class ReductionTreePass : public ReductionTreeBase<ReductionTreePass> {
+class ReductionTreePass
+    : public mlir::impl::ReductionTreePassBase<ReductionTreePass> {
 public:
   ReductionTreePass() = default;
   ReductionTreePass(const ReductionTreePass &pass) = default;
 
   LogicalResult initialize(MLIRContext *context) override;
 
   /// Runs the pass instance in the pass pipeline.
   void runOnOperation() override;

mlir/lib/Transforms/CSE.cpp

 //===- CSE.cpp - Common Sub-expression Elimination ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass performs a simple common sub-expression elimination
 // algorithm on operations within a region.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/IR/Dominance.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/ScopedHashTable.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/RecyclingAllocator.h"
 #include <deque>
 
+namespace mlir {
+#define GEN_PASS_DEF_CSEPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 struct SimpleOperationInfo : public llvm::DenseMapInfo<Operation *> {
   static unsigned getHashValue(const Operation *opC) {
     return OperationEquivalence::computeHash(
         const_cast<Operation *>(opC),
         /*hashOperands=*/OperationEquivalence::directHashValue,
return OperationEquivalence::isEquivalentTo(
         /*mapResults=*/OperationEquivalence::ignoreValueEquivalence,
         OperationEquivalence::IgnoreLocations);
   }
 };
 } // namespace
 
 namespace {
 /// Simple common sub-expression elimination.
-struct CSE : public CSEBase<CSE> {
+struct CSEPass : public impl::CSEPassBase<CSEPass> {
+  using CSEPassBase::CSEPassBase;
+
   /// Shared implementation of operation elimination and scoped map definitions.
   using AllocatorTy = llvm::RecyclingAllocator<
       llvm::BumpPtrAllocator,
       llvm::ScopedHashTableVal<Operation *, Operation *>>;
   using ScopedMapTy = llvm::ScopedHashTable<Operation *, Operation *,
                                             SimpleOperationInfo, AllocatorTy>;
 
   /// Cache holding MemoryEffects information between two operations. The first
private:
 
   /// Operations marked as dead and to be erased.
   std::vector<Operation *> opsToErase;
   DominanceInfo *domInfo = nullptr;
   MemEffectsCache memEffectsCache;
 };
 } // namespace
 
-void CSE::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
+void CSEPass::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
                                    Operation *existing, bool hasSSADominance) {
   // If we find one then replace all uses of the current operation with the
   // existing one and mark it for deletion. We can only replace an operand in
   // an operation if it has not been visited yet.
   if (hasSSADominance) {
     // If the region has SSA dominance, then we are guaranteed to have not
     // visited any use of the current operation.
     op->replaceAllUsesWith(existing);
     opsToErase.push_back(op);
void CSEPass::replaceUsesAndDelete(ScopedMapTy &knownValues, Operation *op,
   // operation doesn't, then set the existing op's location to that of the
   // current op.
   if (existing->getLoc().isa<UnknownLoc>() && !op->getLoc().isa<UnknownLoc>())
     existing->setLoc(op->getLoc());
 
   ++numCSE;
 }
 
-bool CSE::hasOtherSideEffectingOpInBetween(Operation *fromOp, Operation *toOp) {
+bool CSEPass::hasOtherSideEffectingOpInBetween(Operation *fromOp, Operation *toOp) {
   assert(fromOp->getBlock() == toOp->getBlock());
   assert(
       isa<MemoryEffectOpInterface>(fromOp) &&
       cast<MemoryEffectOpInterface>(fromOp).hasEffect<MemoryEffects::Read>() &&
       isa<MemoryEffectOpInterface>(toOp) &&
       cast<MemoryEffectOpInterface>(toOp).hasEffect<MemoryEffects::Read>());
   Operation *nextOp = fromOp->getNextNode();
   auto result =
while (nextOp && nextOp != toOp) {
     }
     nextOp = nextOp->getNextNode();
   }
   result.first->second = std::make_pair(toOp, nullptr);
   return false;
 }
 
 /// Attempt to eliminate a redundant operation.
-LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op,
-                                     bool hasSSADominance) {
+LogicalResult CSEPass::simplifyOperation(ScopedMapTy &knownValues,
+                                         Operation *op, bool hasSSADominance) {
   // Don't simplify terminator operations.
   if (op->hasTrait<OpTrait::IsTerminator>())
     return failure();
 
   // If the operation is already trivially dead just add it to the erase list.
   if (isOpTriviallyDead(op)) {
     opsToErase.push_back(op);
     ++numDCE;
if (auto *existing = knownValues.lookup(op)) {
     return success();
   }
 
   // Otherwise, we add this operation to the known values map.
   knownValues.insert(op, op);
   return failure();
 }
 
-void CSE::simplifyBlock(ScopedMapTy &knownValues, Block *bb,
+void CSEPass::simplifyBlock(ScopedMapTy &knownValues, Block *bb,
                         bool hasSSADominance) {
   for (auto &op : *bb) {
     // If the operation is simplified, we don't process any held regions.
     if (succeeded(simplifyOperation(knownValues, &op, hasSSADominance)))
       continue;
 
     // Most operations don't have regions, so fast path that case.
     if (op.getNumRegions() == 0)
for (auto &op : *bb) {
     // Otherwise, process nested regions normally.
     for (auto &region : op.getRegions())
       simplifyRegion(knownValues, region);
   }
   // Clear the MemoryEffects cache since its usage is by block only.
   memEffectsCache.clear();
 }
 
-void CSE::simplifyRegion(ScopedMapTy &knownValues, Region &region) {
+void CSEPass::simplifyRegion(ScopedMapTy &knownValues, Region &region) {
   // If the region is empty there is nothing to do.
   if (region.empty())
     return;
 
   bool hasSSADominance = domInfo->hasSSADominance(&region);
 
   // If the region only contains one block, then simplify it directly.
   if (region.hasOneBlock()) {
while (!stack.empty()) {
     } else {
       // Finally, if the node and all of its children have been processed
       // then we delete the node.
       stack.pop_back();
     }
   }
 }
 
-void CSE::runOnOperation() {
+void CSEPass::runOnOperation() {
   /// A scoped hash table of defining operations within a region.
   ScopedMapTy knownValues;
 
   domInfo = &getAnalysis<DominanceInfo>();
   Operation *rootOp = getOperation();
 
   for (auto &region : rootOp->getRegions())
     simplifyRegion(knownValues, region);
 
   // If no operations were erased, then we mark all analyses as preserved.
   if (opsToErase.empty())
     return markAllAnalysesPreserved();
 
   /// Erase any operations that were marked as dead during simplification.
   for (auto *op : opsToErase)
     op->erase();
   opsToErase.clear();
 
   // We currently don't remove region operations, so mark dominance as
   // preserved.
   markAnalysesPreserved<DominanceInfo, PostDominanceInfo>();
   domInfo = nullptr;
 }
-
-std::unique_ptr<Pass> mlir::createCSEPass() { return std::make_unique<CSE>(); }

mlir/lib/Transforms/Canonicalizer.cpp

 //===- Canonicalizer.cpp - Canonicalize MLIR operations -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass converts operations into their canonical forms by
 // folding constants, applying operation identity transformations etc.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_CANONICALIZERPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
 /// Canonicalize operations in nested regions.
-struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
-  Canonicalizer() = default;
-  Canonicalizer(const GreedyRewriteConfig &config,
+struct CanonicalizerPass
+    : public impl::CanonicalizerPassBase<CanonicalizerPass> {
+  CanonicalizerPass() = default;
+  CanonicalizerPass(const GreedyRewriteConfig &config,
                     ArrayRef<std::string> disabledPatterns,
                     ArrayRef<std::string> enabledPatterns) {
     this->topDownProcessingEnabled = config.useTopDownTraversal;
     this->enableRegionSimplification = config.enableRegionSimplification;
     this->maxIterations = config.maxIterations;
     this->disabledPatterns = disabledPatterns;
     this->enabledPatterns = enabledPatterns;
   }
 
   /// Initialize the canonicalizer by building the set of patterns used during
struct CanonicalizerPass
   }
 
   FrozenRewritePatternSet patterns;
 };
 } // namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
-  return std::make_unique<Canonicalizer>();
+  return std::make_unique<CanonicalizerPass>();
 }
 
 /// Creates an instance of the Canonicalizer pass with the specified config.
 std::unique_ptr<Pass>
 mlir::createCanonicalizerPass(const GreedyRewriteConfig &config,
                               ArrayRef<std::string> disabledPatterns,
                               ArrayRef<std::string> enabledPatterns) {
-  return std::make_unique<Canonicalizer>(config, disabledPatterns,
+  return std::make_unique<CanonicalizerPass>(config, disabledPatterns,
                                              enabledPatterns);
 }

mlir/lib/Transforms/ControlFlowSink.cpp

 //===- ControlFlowSink.cpp - Code to perform control-flow sinking ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a basic control-flow sink pass. Control-flow sinking
 // moves operations whose only uses are in conditionally-executed blocks in to
 // those blocks so that they aren't executed on paths where their results are
 // not needed.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/IR/Dominance.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Transforms/ControlFlowSinkUtils.h"
-#include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/SideEffectUtils.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_CONTROLFLOWSINKPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// A control-flow sink pass.
-struct ControlFlowSink : public ControlFlowSinkBase<ControlFlowSink> {
+struct ControlFlowSinkPass
+    : public impl::ControlFlowSinkPassBase<ControlFlowSinkPass> {
+  using ControlFlowSinkPassBase::ControlFlowSinkPassBase;
+
   void runOnOperation() override;
 };
 } // end anonymous namespace
 
-void ControlFlowSink::runOnOperation() {
+void ControlFlowSinkPass::runOnOperation() {
   auto &domInfo = getAnalysis<DominanceInfo>();
   getOperation()->walk([&](RegionBranchOpInterface branch) {
     SmallVector<Region *> regionsToSink;
     // Get the regions are that known to be executed at most once.
     getSinglyExecutedRegionsToSink(branch, regionsToSink);
     // Sink side-effect free operations.
     numSunk = controlFlowSink(
         regionsToSink, domInfo,
         [](Operation *op, Region *) { return isSideEffectFree(op); },
         [](Operation *op, Region *region) {
           // Move the operation to the beginning of the region's entry block.
           // This guarantees the preservation of SSA dominance of all of the
           // operation's uses are in the region.
           op->moveBefore(&region->front(), region->front().begin());
         });
   });
 }
-
-std::unique_ptr<Pass> mlir::createControlFlowSinkPass() {
-  return std::make_unique<ControlFlowSink>();
-}

mlir/lib/Transforms/Inliner.cpp

 //===- Inliner.cpp - Pass to inline function calls ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a basic inlining algorithm that operates bottom up over
 // the Strongly Connect Components(SCCs) of the CallGraph. This enables a more
 // incremental propagation of inlining decisions from the leafs to the roots of
 // the callgraph.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/Analysis/CallGraph.h"
 #include "mlir/IR/Threading.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/DebugStringHelper.h"
 #include "mlir/Transforms/InliningUtils.h"
-#include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/Support/Debug.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_INLINERPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 #define DEBUG_TYPE "inlining"
 
 using namespace mlir;
 
 /// This function implements the default inliner optimization pipeline.
 static void defaultInlinerOptPipeline(OpPassManager &pm) {
   pm.addPass(createCanonicalizerPass());
 }
static LogicalResult inlineCallsInSCC(Inliner &inliner, CGUseList &useList,
   return success(inlinedAnyCalls);
 }
 
 //===----------------------------------------------------------------------===//
 // InlinerPass
 //===----------------------------------------------------------------------===//
 
 namespace {
-class InlinerPass : public InlinerBase<InlinerPass> {
+class InlinerPass : public impl::InlinerPassBase<InlinerPass> {
 public:
   InlinerPass();
   InlinerPass(const InlinerPass &) = default;
   InlinerPass(std::function<void(OpPassManager &)> defaultPipeline);
   InlinerPass(std::function<void(OpPassManager &)> defaultPipeline,
               llvm::StringMap<OpPassManager> opPipelines);
   void runOnOperation() override;
 

mlir/lib/Transforms/LocationSnapshot.cpp

 //===- LocationSnapshot.cpp - Location Snapshot Utilities -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/LocationSnapshot.h"
-#include "PassDetail.h"
+
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Support/FileUtilities.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ToolOutputFile.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LOCATIONSNAPSHOTPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 /// This function generates new locations from the given IR by snapshotting the
 /// IR to the given stream, and using the printed locations within that stream.
 /// If a 'tag' is non-empty, the generated locations are represented as a
 /// NameLoc with the given tag as the name, and then fused with the existing
 /// locations. Otherwise, the existing locations are replaced.
 static void generateLocationsFromIR(raw_ostream &os, StringRef fileName,

 LogicalResult mlir::generateLocationsFromIR(StringRef fileName, StringRef tag,
                                             Operation *op,
                                             OpPrintingFlags flags) {
   return ::generateLocationsFromIR(fileName, op, flags, tag);
 }
 
 namespace {
 struct LocationSnapshotPass
-    : public LocationSnapshotBase<LocationSnapshotPass> {
+    : public impl::LocationSnapshotPassBase<LocationSnapshotPass> {
   LocationSnapshotPass() = default;
   LocationSnapshotPass(OpPrintingFlags flags, StringRef fileName, StringRef tag)
       : flags(flags) {
     this->fileName = fileName.str();
     this->tag = tag.str();
   }
 
   void runOnOperation() override {

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

 //===- LoopInvariantCodeMotion.cpp - Code to perform loop fusion-----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements loop invariant code motion.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Transforms/LoopInvariantCodeMotionUtils.h"
-#include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/SideEffectUtils.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_LOOPINVARIANTCODEMOTIONPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
 /// Loop invariant code motion (LICM) pass.
-struct LoopInvariantCodeMotion
-    : public LoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+struct LoopInvariantCodeMotionPass
+    : public impl::LoopInvariantCodeMotionPassBase<
+          LoopInvariantCodeMotionPass> {
+  using LoopInvariantCodeMotionPassBase::LoopInvariantCodeMotionPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void LoopInvariantCodeMotion::runOnOperation() {
+void LoopInvariantCodeMotionPass::runOnOperation() {
   // Walk through all loops in a function in innermost-loop-first order. This
   // way, we first LICM from the inner loop, and place the ops in
   // the outer loop, which in turn can be further LICM'ed.
   getOperation()->walk(
       [&](LoopLikeOpInterface loopLike) { moveLoopInvariantCode(loopLike); });
 }
-
-std::unique_ptr<Pass> mlir::createLoopInvariantCodeMotionPass() {
-  return std::make_unique<LoopInvariantCodeMotion>();
-}

mlir/lib/Transforms/OpStats.cpp

 //===- OpStats.cpp - Prints stats of operations in module -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/OperationSupport.h"
-#include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_PRINTOPSTATSPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct PrintOpStatsPass : public PrintOpStatsBase<PrintOpStatsPass> {
+struct PrintOpStatsPass : public impl::PrintOpStatsPassBase<PrintOpStatsPass> {
   explicit PrintOpStatsPass(raw_ostream &os) : os(os) {}
 
   explicit PrintOpStatsPass(raw_ostream &os, bool printAsJSON) : os(os) {
     this->printAsJSON = printAsJSON;
   }
 
   // Prints the resultant operation statistics post iterating over the module.
   void runOnOperation() override;

mlir/lib/Transforms/PassDetail.h

-//===- PassDetail.h - Transforms Pass class details -------------*- 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 TRANSFORMS_PASSDETAIL_H_
-#define TRANSFORMS_PASSDETAIL_H_
-
-#include "mlir/Pass/Pass.h"
-#include "mlir/Pass/PassManager.h"
-#include "mlir/Transforms/Passes.h"
-
-namespace mlir {
-#define GEN_PASS_CLASSES
-#include "mlir/Transforms/Passes.h.inc"
-} // namespace mlir
-
-#endif // TRANSFORMS_PASSDETAIL_H_

mlir/lib/Transforms/SCCP.cpp

 //===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass performs a sparse conditional constant propagation
 // in MLIR. It identifies values known to be constant, propagates that
 // information throughout the IR, and replaces them. This is done with an
 // optimistic dataflow analysis that assumes that all values are constant until
 // proven otherwise.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h"
 #include "mlir/Analysis/DataFlow/DeadCodeAnalysis.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/FoldUtils.h"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SCCPPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 using namespace mlir::dataflow;
 
 //===----------------------------------------------------------------------===//
 // SCCP Rewrites
 //===----------------------------------------------------------------------===//
 
static void rewrite(DataFlowSolver &solver, MLIRContext *context,
   }
 }
 
 //===----------------------------------------------------------------------===//
 // SCCP Pass
 //===----------------------------------------------------------------------===//
 
 namespace {
-struct SCCP : public SCCPBase<SCCP> {
+struct SCCPPass : public impl::SCCPPassBase<SCCPPass> {
+  using SCCPPassBase::SCCPPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void SCCP::runOnOperation() {
+void SCCPPass::runOnOperation() {
   Operation *op = getOperation();
 
   DataFlowSolver solver;
   solver.load<DeadCodeAnalysis>();
   solver.load<SparseConstantPropagation>();
   if (failed(solver.initializeAndRun(op)))
     return signalPassFailure();
   rewrite(solver, op->getContext(), op->getRegions());
 }
-
-std::unique_ptr<Pass> mlir::createSCCPPass() {
-  return std::make_unique<SCCP>();
-}

mlir/lib/Transforms/StripDebugInfo.cpp

 //===- StripDebugInfo.cpp - Pass to strip debug information ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Transforms/Passes.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_STRIPDEBUGINFOPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
 
 using namespace mlir;
 
 namespace {
-struct StripDebugInfo : public StripDebugInfoBase<StripDebugInfo> {
+struct StripDebugInfoPass
+    : public impl::StripDebugInfoPassBase<StripDebugInfoPass> {
+  using StripDebugInfoPassBase::StripDebugInfoPassBase;
+
   void runOnOperation() override;
 };
 } // namespace
 
-void StripDebugInfo::runOnOperation() {
+void StripDebugInfoPass::runOnOperation() {
   auto unknownLoc = UnknownLoc::get(&getContext());
 
   // Strip the debug info from all operations.
   getOperation()->walk([&](Operation *op) {
     op->setLoc(unknownLoc);
     // Strip block arguments debug info.
     for (Region &region : op->getRegions()) {
       for (Block &block : region.getBlocks()) {
         for (BlockArgument &arg : block.getArguments()) {
           arg.setLoc(unknownLoc);
         }
       }
     }
   });
 }
-
-/// Creates a pass to strip debug information from a function.
-std::unique_ptr<Pass> mlir::createStripDebugInfoPass() {
-  return std::make_unique<StripDebugInfo>();
-}

mlir/lib/Transforms/SymbolDCE.cpp

 //===- SymbolDCE.cpp - Pass to delete dead symbols ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements an algorithm for eliminating symbol operations that are
 // known to be dead.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/IR/SymbolTable.h"
 #include "mlir/Transforms/Passes.h"
 
+#include "mlir/IR/SymbolTable.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SYMBOLDCEPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct SymbolDCE : public SymbolDCEBase<SymbolDCE> {
+struct SymbolDCEPass : public impl::SymbolDCEPassBase<SymbolDCEPass> {
+  using SymbolDCEPassBase::SymbolDCEPassBase;
+
   void runOnOperation() override;
 
   /// Compute the liveness of the symbols within the given symbol table.
   /// `symbolTableIsHidden` is true if this symbol table is known to be
   /// unaccessible from operations in its parent regions.
   LogicalResult computeLiveness(Operation *symbolTableOp,
                                 SymbolTableCollection &symbolTable,
                                 bool symbolTableIsHidden,
                                 DenseSet<Operation *> &liveSymbols);
 };
 } // namespace
 
-void SymbolDCE::runOnOperation() {
+void SymbolDCEPass::runOnOperation() {
   Operation *symbolTableOp = getOperation();
 
   // SymbolDCE should only be run on operations that define a symbol table.
   if (!symbolTableOp->hasTrait<OpTrait::SymbolTable>()) {
     symbolTableOp->emitOpError()
         << " was scheduled to run under SymbolDCE, but does not define a "
            "symbol table";
     return signalPassFailure();
for (auto &block : nestedSymbolTable->getRegion(0)) {
       }
     }
   });
 }
 
 /// Compute the liveness of the symbols within the given symbol table.
 /// `symbolTableIsHidden` is true if this symbol table is known to be
 /// unaccessible from operations in its parent regions.
-LogicalResult SymbolDCE::computeLiveness(Operation *symbolTableOp,
-                                         SymbolTableCollection &symbolTable,
-                                         bool symbolTableIsHidden,
-                                         DenseSet<Operation *> &liveSymbols) {
+LogicalResult SymbolDCEPass::computeLiveness(
+    Operation *symbolTableOp, SymbolTableCollection &symbolTable,
+    bool symbolTableIsHidden, DenseSet<Operation *> &liveSymbols) {
   // A worklist of live operations to propagate uses from.
   SmallVector<Operation *, 16> worklist;
 
   // Walk the symbols within the current symbol table, marking the symbols that
   // are known to be live.
   for (auto &block : symbolTableOp->getRegion(0)) {
     // Add all non-symbols or symbols that can't be discarded.
     for (Operation &op : block) {
for (const SymbolTable::SymbolUse &use : *uses) {
       for (Operation *resolvedSymbol : resolvedSymbols)
         if (liveSymbols.insert(resolvedSymbol).second)
           worklist.push_back(resolvedSymbol);
     }
   }
 
   return success();
 }
-
-std::unique_ptr<Pass> mlir::createSymbolDCEPass() {
-  return std::make_unique<SymbolDCE>();
-}

mlir/lib/Transforms/SymbolPrivatize.cpp

 //===- SymbolPrivatize.cpp - Pass to mark symbols private -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements an pass that marks all symbols as private unless
 // excluded.
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
-#include "mlir/IR/SymbolTable.h"
 #include "mlir/Transforms/Passes.h"
 
+#include "mlir/IR/SymbolTable.h"
+
+namespace mlir {
+#define GEN_PASS_DEF_SYMBOLPRIVATIZEPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct SymbolPrivatize : public SymbolPrivatizeBase<SymbolPrivatize> {
-  explicit SymbolPrivatize(ArrayRef<std::string> excludeSymbols);
+struct SymbolPrivatizePass
+    : public impl::SymbolPrivatizePassBase<SymbolPrivatizePass> {
+  explicit SymbolPrivatizePass(ArrayRef<std::string> excludeSymbols);
   LogicalResult initialize(MLIRContext *context) override;
   void runOnOperation() override;
 
   /// Symbols whose visibility won't be changed.
   DenseSet<StringAttr> excludedSymbols;
 };
 } // namespace
 
-SymbolPrivatize::SymbolPrivatize(llvm::ArrayRef<std::string> excludeSymbols) {
+SymbolPrivatizePass::SymbolPrivatizePass(
+    llvm::ArrayRef<std::string> excludeSymbols) {
   exclude = excludeSymbols;
 }
 
-LogicalResult SymbolPrivatize::initialize(MLIRContext *context) {
+LogicalResult SymbolPrivatizePass::initialize(MLIRContext *context) {
   for (const std::string &symbol : exclude)
     excludedSymbols.insert(StringAttr::get(context, symbol));
   return success();
 }
 
-void SymbolPrivatize::runOnOperation() {
+void SymbolPrivatizePass::runOnOperation() {
   for (Region &region : getOperation()->getRegions()) {
     for (Block &block : region) {
       for (Operation &op : block) {
         auto symbol = dyn_cast<SymbolOpInterface>(op);
         if (!symbol)
           continue;
         if (!excludedSymbols.contains(symbol.getNameAttr()))
           symbol.setVisibility(SymbolTable::Visibility::Private);
       }
     }
   }
 }
 
 std::unique_ptr<Pass>
 mlir::createSymbolPrivatizePass(ArrayRef<std::string> exclude) {
-  return std::make_unique<SymbolPrivatize>(exclude);
+  return std::make_unique<SymbolPrivatizePass>(exclude);
 }

mlir/lib/Transforms/TopologicalSort.cpp

 //===- TopologicalSort.cpp - Topological sort pass ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "PassDetail.h"
+#include "mlir/Transforms/Passes.h"
+
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/Transforms/TopologicalSortUtils.h"
 
+namespace mlir {
+#define GEN_PASS_DEF_TOPOLOGICALSORTPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 namespace {
-struct TopologicalSortPass : public TopologicalSortBase<TopologicalSortPass> {
+struct TopologicalSortPass
+    : public impl::TopologicalSortPassBase<TopologicalSortPass> {
+  using TopologicalSortPassBase::TopologicalSortPassBase;
+
   void runOnOperation() override {
     // Topologically sort the regions of the operation without SSA dominance.
     getOperation()->walk([](RegionKindInterface op) {
       for (auto &it : llvm::enumerate(op->getRegions())) {
         if (op.hasSSADominance(it.index()))
           continue;
         for (Block &block : it.value())
           sortTopologically(&block);
       }
     });
   }
 };
 } // end anonymous namespace
-
-std::unique_ptr<Pass> mlir::createTopologicalSortPass() {
-  return std::make_unique<TopologicalSortPass>();
-}

mlir/lib/Transforms/ViewOpGraph.cpp

 //===- ViewOpGraph.cpp - View/write op graphviz graphs --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/ViewOpGraph.h"
-#include "PassDetail.h"
+
 #include "mlir/IR/Block.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Operation.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Support/IndentedOstream.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/GraphWriter.h"
 #include <utility>
 
+namespace mlir {
+#define GEN_PASS_DEF_VIEWOPGRAPHPASS
+#include "mlir/Transforms/Passes.h.inc"
+} // namespace mlir
+
 using namespace mlir;
 
 static const StringRef kLineStyleControlFlow = "dashed";
 static const StringRef kLineStyleDataFlow = "solid";
 static const StringRef kShapeNode = "ellipse";
 static const StringRef kShapeNone = "plain";
 
 /// Return the size limits for eliding large attributes.
public:
 
   int id;
   Optional<int> clusterId;
 };
 
 /// This pass generates a Graphviz dataflow visualization of an MLIR operation.
 /// Note: See https://www.graphviz.org/doc/info/lang.html for more information
 /// about the Graphviz DOT language.
-class PrintOpPass : public ViewOpGraphBase<PrintOpPass> {
+class ViewOpGraphPass : public impl::ViewOpGraphPassBase<ViewOpGraphPass> {
 public:
-  PrintOpPass(raw_ostream &os) : os(os) {}
-  PrintOpPass(const PrintOpPass &o) : PrintOpPass(o.os.getOStream()) {}
+  ViewOpGraphPass(raw_ostream &os) : os(os) {}
+  ViewOpGraphPass(const ViewOpGraphPass &o) : ViewOpGraphPass(o.os.getOStream()) {}
 
   void runOnOperation() override {
     emitGraph([&]() {
       processOperation(getOperation());
       emitAllEdgeStmts();
     });
   }
 
private:
   /// Mapping of SSA values to Graphviz nodes/clusters.
   DenseMap<Value, Node> valueToNode;
   /// Counter for generating unique node/subgraph identifiers.
   int counter = 0;
 };
 
 } // namespace
 
-std::unique_ptr<Pass> mlir::createPrintOpGraphPass(raw_ostream &os) {
-  return std::make_unique<PrintOpPass>(os);
+std::unique_ptr<Pass> mlir::createViewOpGraphPass(raw_ostream &os) {
+  return std::make_unique<ViewOpGraphPass>(os);
 }
 
 /// Generate a CFG for a region and show it in a window.
 static void llvmViewGraph(Region &region, const Twine &name) {
   int fd;
   std::string filename = llvm::createGraphFilename(name.str(), fd);
   {
     llvm::raw_fd_ostream os(fd, /*shouldClose=*/true);
     if (fd == -1) {
       llvm::errs() << "error opening file '" << filename << "' for writing\n";
       return;
     }
-    PrintOpPass pass(os);
+    ViewOpGraphPass pass(os);
     pass.emitRegionCFG(region);
   }
   llvm::DisplayGraph(filename, /*wait=*/false, llvm::GraphProgram::DOT);
 }
 
 void mlir::Region::viewGraph(const Twine &regionName) {
   llvmViewGraph(*this, regionName);
 }
 
 void mlir::Region::viewGraph() { viewGraph("region"); }

mlir/test/CAPI/execution_engine.c

static void registerAllUpstreamDialects(MlirContext ctx) {
   mlirContextAppendDialectRegistry(ctx, registry);
   mlirDialectRegistryDestroy(registry);
 }
 
 void lowerModuleToLLVM(MlirContext ctx, MlirModule module) {
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   MlirOpPassManager opm = mlirPassManagerGetNestedUnder(
       pm, mlirStringRefCreateFromCString("func.func"));
-  mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVM());
-  mlirOpPassManagerAddOwnedPass(opm,
-                                mlirCreateConversionConvertArithmeticToLLVM());
+  mlirPassManagerAddOwnedPass(pm, mlirCreateConversionConvertFuncToLLVMPass());
+  mlirOpPassManagerAddOwnedPass(opm, mlirCreateConversionConvertArithmeticToLLVMPass());
   MlirLogicalResult status = mlirPassManagerRun(pm, module);
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr, "Unexpected failure running pass pipeline\n");
     exit(2);
   }
   mlirPassManagerDestroy(pm);
 }
 

mlir/test/CAPI/pass.c

"}"));
 
   // Run the print-op-stats pass on the top-level module:
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addi        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
     MlirPassManager pm = mlirPassManagerCreate(ctx);
-    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
+    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
     mlirPassManagerAddOwnedPass(pm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success)) {
       fprintf(stderr, "Unexpected failure running pass manager.\n");
       exit(EXIT_FAILURE);
     }
     mlirPassManagerDestroy(pm);
   }
"}"));
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addi        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
     MlirPassManager pm = mlirPassManagerCreate(ctx);
     MlirOpPassManager nestedFuncPm = mlirPassManagerGetNestedUnder(
         pm, mlirStringRefCreateFromCString("func.func"));
-    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
+    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
     mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success))
       exit(2);
     mlirPassManagerDestroy(pm);
   }
   // Run the print-op-stats pass on functions under the nested module:
   // CHECK-LABEL: Operations encountered:
   // CHECK: arith.addf        , 1
   // CHECK: func.func      , 1
   // CHECK: func.return        , 1
   {
     MlirPassManager pm = mlirPassManagerCreate(ctx);
     MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
         pm, mlirStringRefCreateFromCString("builtin.module"));
     MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
         nestedModulePm, mlirStringRefCreateFromCString("func.func"));
-    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
+    MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
     mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
     MlirLogicalResult success = mlirPassManagerRun(pm, module);
     if (mlirLogicalResultIsFailure(success))
       exit(2);
     mlirPassManagerDestroy(pm);
   }
 
   mlirModuleDestroy(module);
   mlirContextDestroy(ctx);
 }
 
 static void printToStderr(MlirStringRef str, void *userData) {
   (void)userData;
   fwrite(str.data, 1, str.length, stderr);
 }
 
 void testPrintPassPipeline() {
   MlirContext ctx = mlirContextCreate();
   MlirPassManager pm = mlirPassManagerCreate(ctx);
   // Populate the pass-manager
   MlirOpPassManager nestedModulePm = mlirPassManagerGetNestedUnder(
       pm, mlirStringRefCreateFromCString("builtin.module"));
   MlirOpPassManager nestedFuncPm = mlirOpPassManagerGetNestedUnder(
       nestedModulePm, mlirStringRefCreateFromCString("func.func"));
-  MlirPass printOpStatPass = mlirCreateTransformsPrintOpStats();
+  MlirPass printOpStatPass = mlirCreateTransformsPrintOpStatsPass();
   mlirOpPassManagerAddOwnedPass(nestedFuncPm, printOpStatPass);
 
   // Print the top level pass manager
   // CHECK: Top-level: builtin.module(func.func(print-op-stats{json=false}))
   fprintf(stderr, "Top-level: ");
   mlirPrintPassPipeline(mlirPassManagerGetAsOpPassManager(pm), printToStderr,
                         NULL);
   fprintf(stderr, "\n");
void testParsePassPipeline() {
   // Expect a failure, we haven't registered the print-op-stats pass yet.
   if (mlirLogicalResultIsSuccess(status)) {
     fprintf(
         stderr,
         "Unexpected success parsing pipeline without registering the pass\n");
     exit(EXIT_FAILURE);
   }
   // Try again after registrating the pass.
-  mlirRegisterTransformsPrintOpStats();
+  mlirRegisterTransformsPrintOpStatsPass();
   status = mlirParsePassPipeline(
       mlirPassManagerGetAsOpPassManager(pm),
       mlirStringRefCreateFromCString(
           "builtin.module(func.func(print-op-stats{json=false}),"
           " func.func(print-op-stats{json=false}))"));
   // Expect a failure, we haven't registered the print-op-stats pass yet.
   if (mlirLogicalResultIsFailure(status)) {
     fprintf(stderr,

mlir/test/Pass/ir-printing.mlir

func.func @foo() {
   %0 = arith.constant 0 : i32
   return
 }
 
 func.func @bar() {
   return
 }
 
-// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE-NEXT: func @foo()
-// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE-NEXT: func @bar()
-// BEFORE-NOT: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
+// BEFORE-NOT: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
 // BEFORE-NOT: // -----// IR Dump After
 
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE_ALL-NEXT: func @foo()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
 // BEFORE_ALL-NEXT: func @foo()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE_ALL-NEXT: func @bar()
-// BEFORE_ALL: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
+// BEFORE_ALL: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
 // BEFORE_ALL-NEXT: func @bar()
 // BEFORE_ALL-NOT: // -----// IR Dump After
 
 // AFTER-NOT: // -----// IR Dump Before
-// AFTER: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // AFTER-NEXT: func @foo()
-// AFTER: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // AFTER-NEXT: func @bar()
-// AFTER-NOT: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
+// AFTER-NOT: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
 
 // AFTER_ALL-NOT: // -----// IR Dump Before
-// AFTER_ALL: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // AFTER_ALL-NEXT: func @foo()
-// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
 // AFTER_ALL-NEXT: func @foo()
-// AFTER_ALL: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // AFTER_ALL-NEXT: func @bar()
-// AFTER_ALL: // -----// IR Dump After{{.*}}Canonicalizer (canonicalize) //----- //
+// AFTER_ALL: // -----// IR Dump After{{.*}}CanonicalizerPass (canonicalize) //----- //
 // AFTER_ALL-NEXT: func @bar()
 
-// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE (cse) ('func.func' operation: @foo) //----- //
+// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSEPass (cse) ('func.func' operation: @foo) //----- //
 // BEFORE_MODULE: func @foo()
 // BEFORE_MODULE: func @bar()
-// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSE (cse) ('func.func' operation: @bar) //----- //
+// BEFORE_MODULE: // -----// IR Dump Before{{.*}}CSEPass (cse) ('func.func' operation: @bar) //----- //
 // BEFORE_MODULE: func @foo()
 // BEFORE_MODULE: func @bar()
 
-// AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER_ALL_CHANGE: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // AFTER_ALL_CHANGE-NEXT: func @foo()
-// AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSE (cse) //----- //
+// AFTER_ALL_CHANGE-NOT: // -----// IR Dump After{{.*}}CSEPass (cse) //----- //
 // We expect that only 'foo' changed during CSE, and the second run of CSE did
 // nothing.
 
-// AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSE
+// AFTER_FAILURE-NOT: // -----// IR Dump After{{.*}}CSEPass
 // AFTER_FAILURE: // -----// IR Dump After{{.*}}TestFailurePass Failed (test-pass-failure) //----- //
 // AFTER_FAILURE: func @foo()

mlir/test/Pass/run-reproducer.mlir

func.func @bar() {
   external_resources: {
     mlir_reproducer: {
       pipeline: "func.func(cse,canonicalize)",
       disable_threading: true
     }
   }
 #-}
 
-// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE-NEXT: func @foo()
-// BEFORE: // -----// IR Dump Before{{.*}}CSE (cse) //----- //
+// BEFORE: // -----// IR Dump Before{{.*}}CSEPass (cse) //----- //
 // BEFORE-NEXT: func @bar()
-// BEFORE-NOT: // -----// IR Dump Before{{.*}}Canonicalizer (canonicalize) //----- //
+// BEFORE-NOT: // -----// IR Dump Before{{.*}}CanonicalizerPass (canonicalize) //----- //
 // BEFORE-NOT: // -----// IR Dump After

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

 //===- TosaTestPasses.cpp -------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Test passes to exercise TOSA helper functions.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
-#include "mlir/Dialect/Tosa/Transforms/PassDetail.h"
 #include "mlir/Dialect/Tosa/Transforms/Passes.h"
 #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 #define PASS_NAME "tosa-test-quant-utils"

mlir/tools/mlir-tblgen/PassCAPIGen.cpp

static bool emitCAPIHeader(const llvm::RecordKeeper &records, raw_ostream &os) {
   return false;
 }
 
 const char *const passCreateDef = R"(
 MlirPass mlirCreate{0}{1}() {
   return wrap({2}.release());
 }
 void mlirRegister{0}{1}() {
-  register{1}Pass();
+  register{1}();
 }
 
 )";
 
 /// {0}: The name of the pass group.
 const char *const passGroupRegistrationCode = R"(
 //===----------------------------------------------------------------------===//
 // {0} Group Registration
for (const auto *def : records.getAllDerivedDefinitions("PassBase")) {
     Pass pass(def);
     StringRef defName = pass.getDef()->getName();
 
     std::string constructorCall;
     if (StringRef constructor = pass.getConstructor(); !constructor.empty())
       constructorCall = constructor.str();
     else
       constructorCall =
-          llvm::formatv("create{0}Pass()", pass.getDef()->getName()).str();
+          llvm::formatv("create{0}()", pass.getDef()->getName()).str();
 
     os << llvm::formatv(passCreateDef, groupName, defName, constructorCall);
   }
   return false;
 }
 
 static mlir::GenRegistration genCAPIHeader("gen-pass-capi-header",
                                            "Generate pass C API header",
                                            &emitCAPIHeader);
 
 static mlir::GenRegistration genCAPIImpl("gen-pass-capi-impl",
                                          "Generate pass C API implementation",
                                          &emitCAPIImpl);

mlir/tools/mlir-tblgen/PassGen.cpp

 using namespace mlir;
 using namespace mlir::tblgen;
 
 static llvm::cl::OptionCategory passGenCat("Options for -gen-pass-decls");
 static llvm::cl::opt<std::string>
     groupName("name", llvm::cl::desc("The name of this group of passes"),
               llvm::cl::cat(passGenCat));
 
-static void emitOldPassDecl(const Pass &pass, raw_ostream &os);
-
 /// Extract the list of passes from the TableGen records.
 static std::vector<Pass> getPasses(const llvm::RecordKeeper &recordKeeper) {
   std::vector<Pass> passes;
 
   for (const auto *def : recordKeeper.getAllDerivedDefinitions("PassBase"))
     passes.emplace_back(def);
 
   return passes;
if (emitDefaultConstructors) {
     if (emitDefaultConstructorWithOptions)
       os << llvm::formatv(defaultConstructorWithOptionsDefTemplate, passName);
   }
 
   os << "#undef " << enableVarName << "\n";
   os << "#endif // " << enableVarName << "\n";
 }
 
-// TODO drop old pass declarations
-// The old pass base class is being kept until all the passes have switched to
-// the new decls/defs design.
-const char *const oldPassDeclBegin = R"(
-template <typename DerivedT>
-class {0}Base : public {1} {
-public:
-  using Base = {0}Base;
-
-  {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
-  {0}Base(const {0}Base &other) : {1}(other) {{}
-
-  /// Returns the command-line argument attached to this pass.
-  static constexpr ::llvm::StringLiteral getArgumentName() {
-    return ::llvm::StringLiteral("{2}");
-  }
-  ::llvm::StringRef getArgument() const override { return "{2}"; }
-
-  ::llvm::StringRef getDescription() const override { return "{3}"; }
-
-  /// Returns the derived pass name.
-  static constexpr ::llvm::StringLiteral getPassName() {
-    return ::llvm::StringLiteral("{0}");
-  }
-  ::llvm::StringRef getName() const override { return "{0}"; }
-
-  /// Support isa/dyn_cast functionality for the derived pass class.
-  static bool classof(const ::mlir::Pass *pass) {{
-    return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
-  }
-
-  /// A clone method to create a copy of this pass.
-  std::unique_ptr<::mlir::Pass> clonePass() const override {{
-    return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
-  }
-
-  /// Return the dialect that must be loaded in the context before this pass.
-  void getDependentDialects(::mlir::DialectRegistry &registry) const override {
-    {4}
-  }
-
-  /// Explicitly declare the TypeID for this class. We declare an explicit private
-  /// instantiation because Pass classes should only be visible by the current
-  /// library.
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID({0}Base<DerivedT>)
-
-protected:
-)";
-
-/// Emit a backward-compatible declaration of the pass base class.
-static void emitOldPassDecl(const Pass &pass, raw_ostream &os) {
-  StringRef defName = pass.getDef()->getName();
-  std::string dependentDialectRegistrations;
-  {
-    llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
-    for (StringRef dependentDialect : pass.getDependentDialects())
-      dialectsOs << llvm::formatv(dialectRegistrationTemplate,
-                                  dependentDialect);
-  }
-  os << llvm::formatv(oldPassDeclBegin, defName, pass.getBaseClass(),
-                      pass.getArgument(), pass.getSummary(),
-                      dependentDialectRegistrations);
-  emitPassOptionDecls(pass, os);
-  emitPassStatisticDecls(pass, os);
-  os << "};\n";
-}
-
 static void emitPass(const Pass &pass, raw_ostream &os) {
   StringRef passName = pass.getDef()->getName();
   os << llvm::formatv(passHeader, passName);
 
   emitPassDecls(pass, os);
   emitPassDefs(pass, os);
 }
 
 static void emitPasses(const llvm::RecordKeeper &recordKeeper,
                        raw_ostream &os) {
   std::vector<Pass> passes = getPasses(recordKeeper);
   os << "/* Autogenerated by mlir-tblgen; don't manually edit */\n";
 
   for (const Pass &pass : passes)
     emitPass(pass, os);
 
   emitRegistrations(passes, os);
-
-  // TODO: Drop old pass declarations.
-  // Emit the old code until all the passes have switched to the new design.
-  os << "#ifdef GEN_PASS_CLASSES\n";
-  for (const Pass &pass : passes)
-    emitOldPassDecl(pass, os);
-  os << "#undef GEN_PASS_CLASSES\n";
-  os << "#endif // GEN_PASS_CLASSES\n";
 }
 
 static mlir::GenRegistration
     genPassDecls("gen-pass-decls", "Generate pass declarations",
                  [](const llvm::RecordKeeper &records, raw_ostream &os) {
                    emitPasses(records, os);
                    return false;
                  });

mlir/unittests/ExecutionEngine/Invoke.cpp

LLVMInitializer() {
     llvm::InitializeNativeTargetAsmPrinter();
   }
 } initializer;
 
 /// Simple conversion pipeline for the purpose of testing sources written in
 /// dialects lowering to LLVM Dialect.
 static LogicalResult lowerToLLVMDialect(ModuleOp module) {
   PassManager pm(module.getContext());
-  pm.addPass(mlir::createMemRefToLLVMPass());
-  pm.addNestedPass<func::FuncOp>(
-      mlir::arith::createConvertArithmeticToLLVMPass());
+  pm.addPass(mlir::createConvertMemRefToLLVMPass());
+  pm.addNestedPass<func::FuncOp>(mlir::createConvertArithmeticToLLVMPass());
   pm.addPass(mlir::createConvertFuncToLLVMPass());
   pm.addPass(mlir::createReconcileUnrealizedCastsPass());
   return pm.run(module);
 }
 
 TEST(MLIRExecutionEngine, SKIP_WITHOUT_JIT(AddInteger)) {
   std::string moduleStr = R"mlir(
   func.func @foo(%arg0 : i32) -> i32 attributes { llvm.emit_c_interface } {