[mlir][Pass] Move the registration of dialect passes to tablegen

[rriddle]

Summary

This generates a Passes.td for all of the dialects that have transformation passes. This removes the need for global registration for all of the dialect passes.

Depends On D76656

[rriddle]

Rebase

[rriddle]

Rebase

[rriddle]

Rebase

mlir/include/mlir/CMakeLists.txt

 add_subdirectory(Dialect)
 add_subdirectory(IR)
 add_subdirectory(Interfaces)
+add_subdirectory(Quantizer)
 add_subdirectory(Transforms)

mlir/include/mlir/Dialect/Affine/CMakeLists.txt

 add_subdirectory(IR)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRAffinePassIncGen)

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

 
 /// Performs packing (or explicit copying) of accessed memref regions into
 /// buffers in the specified faster memory space through either pointwise copies
 /// or DMA operations.
 std::unique_ptr<OpPassBase<FuncOp>> createAffineDataCopyGenerationPass(
     unsigned slowMemorySpace, unsigned fastMemorySpace,
     unsigned tagMemorySpace = 0, int minDmaTransferSize = 1024,
     uint64_t fastMemCapacityBytes = std::numeric_limits<uint64_t>::max());
+/// Overload relying on pass options for initialization.
+std::unique_ptr<OpPassBase<FuncOp>> createAffineDataCopyGenerationPass();
 
 /// Creates a pass to perform tiling on loop nests.
 std::unique_ptr<OpPassBase<FuncOp>>
 createLoopTilingPass(uint64_t cacheSizeBytes);
+/// Overload relying on pass options for initialization.
+std::unique_ptr<OpPassBase<FuncOp>> createLoopTilingPass();
 
 /// Creates a loop unrolling pass with the provided parameters.
 /// 'getUnrollFactor' is a function callback for clients to supply a function
 /// that computes an unroll factor - the callback takes precedence over unroll
 /// factors supplied through other means. If -1 is passed as the unrollFactor
 /// and no callback is provided, anything passed from the command-line (if at
 /// all) or the default unroll factor is used (LoopUnroll:kDefaultUnrollFactor).
 std::unique_ptr<OpPassBase<FuncOp>> createLoopUnrollPass(
     int unrollFactor = -1, int unrollFull = -1,
     const std::function<unsigned(AffineForOp)> &getUnrollFactor = nullptr);
 
 /// Creates a loop unroll jam pass to unroll jam by the specified factor. A
 /// factor of -1 lets the pass use the default factor or the one on the command
 /// line if provided.
 std::unique_ptr<OpPassBase<FuncOp>>
 createLoopUnrollAndJamPass(int unrollJamFactor = -1);
 
 /// Creates a pass to vectorize loops, operations and data types using a
 /// target-independent, n-D super-vector abstraction.
 std::unique_ptr<OpPassBase<FuncOp>>
 createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize);
+/// Overload relying on pass options for initialization.
+std::unique_ptr<OpPassBase<FuncOp>> createSuperVectorizePass();
 
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_RANSFORMS_PASSES_H

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

+//===-- Passes.td - Affine 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains definitions for passes within the Affine/ directory.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_AFFINE_PASSES
+#define MLIR_DIALECT_AFFINE_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def AffineDataCopyGeneration : Pass<"affine-data-copy-generate"> {
+  let summary = "Generate explicit copying for affine memory operations";
+  let constructor = "mlir::createAffineDataCopyGenerationPass()";
+}
+
+def AffineLoopInvariantCodeMotion : Pass<"affine-loop-invariant-code-motion"> {
+  let summary = "Hoist loop invariant instructions outside of affine loops";
+  let constructor = "mlir::createAffineLoopInvariantCodeMotionPass()";
+}
+
+def AffineLoopTiling : Pass<"affine-loop-tile"> {
+  let summary = "Tile affine loop nests";
+  let constructor = "mlir::createLoopTilingPass()";
+}
+
+def AffineLoopUnroll : Pass<"affine-loop-unroll"> {
+  let summary = "Unroll affine loops";
+  let constructor = "mlir::createLoopUnrollPass()";
+}
+
+def AffineLoopUnrollAndJam : Pass<"affine-loop-unroll-jam"> {
+  let summary = "Unroll and jam affine loops";
+  let constructor = "mlir::createLoopUnrollAndJamPass()";
+}
+
+def AffineVectorize : Pass<"affine-super-vectorize"> {
+  let summary = "Vectorize to a target independent n-D vector abstraction";
+  let constructor = "mlir::createSuperVectorizePass()";
+}
+
+def SimplifyAffineStructures : Pass<"simplify-affine-structures"> {
+  let summary = "Simplify affine expressions in maps/sets and normalize "
+                "memrefs";
+  let constructor = "mlir::createSimplifyAffineStructuresPass()";
+}
+
+#endif // MLIR_DIALECT_AFFINE_PASSES

mlir/include/mlir/Dialect/FxpMathOps/CMakeLists.txt

 add_mlir_dialect(FxpMathOps fxpmath)
 add_mlir_doc(FxpMathOps -gen-dialect-doc FxpMathDialect Dialects/)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRFxpMathPassIncGen)

mlir/include/mlir/Dialect/FxpMathOps/Passes.h

 //===- Passes.h - Fixed point math 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines all of the passes owned by the FxpMathOps dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_FXPMATHOPS_PASSES_H
 #define MLIR_DIALECT_FXPMATHOPS_PASSES_H
 
+#include <memory>
+
 namespace mlir {
 class FuncOp;
 template <typename T> class OpPassBase;
 
 namespace fxpmath {
 
 /// Creates a pass that lowers uniform-quantized real math ops to integer
 /// arithmetic. This will leave unrecognized real math ops as-is and is
 /// typically followed by a pass that lowers any unrecognized ops to a pure
 /// floating point form.
-OpPassBase<FuncOp> *createLowerUniformRealMathPass();
+std::unique_ptr<OpPassBase<FuncOp>> createLowerUniformRealMathPass();
 
 /// Creates a pass that lowers uniform-quantized qcast/dcast ops to equivalent
 /// operations that perform quantize/dequantize.
-OpPassBase<FuncOp> *createLowerUniformCastsPass();
+std::unique_ptr<OpPassBase<FuncOp>> createLowerUniformCastsPass();
 
 } // namespace fxpmath
 } // namespace mlir
 
 #endif // MLIR_DIALECT_FXPMATHOPS_PASSES_H

mlir/include/mlir/Dialect/FxpMathOps/Passes.td

+//===-- Passes.td - FxpMath 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_FXPMATH_PASSES
+#define MLIR_DIALECT_FXPMATH_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def FxpMathLowerUniformCasts : Pass<"fxpmath-lower-uniform-casts"> {
+  let summary = "Lowers uniform-quantized casts";
+  let constructor = "mlir::fxpmath::createLowerUniformCastsPass()";
+}
+
+def FxpMathLowerUniformRealMath : Pass<"fxpmath-lower-uniform-real-math"> {
+  let summary = "Lowers uniform-quantized real math ops to integer arithmetic";
+  let constructor = "mlir::fxpmath::createLowerUniformRealMathPass()";
+}
+
+#endif // MLIR_DIALECT_FXPMATH_PASSES

mlir/include/mlir/Dialect/GPU/CMakeLists.txt

 add_mlir_dialect(GPUOps gpu)
 add_mlir_doc(GPUOps -gen-op-doc GPUOps Dialects/)
 
 set(LLVM_TARGET_DEFINITIONS ParallelLoopMapperAttr.td)
 mlir_tablegen(ParallelLoopMapperAttr.h.inc -gen-struct-attr-decls)
 mlir_tablegen(ParallelLoopMapperAttr.cpp.inc -gen-struct-attr-defs)
 add_public_tablegen_target(MLIRParallelLoopMapperAttrGen)
 
 set(LLVM_TARGET_DEFINITIONS ParallelLoopMapperAttr.td)
 mlir_tablegen(ParallelLoopMapperEnums.h.inc -gen-enum-decls)
 mlir_tablegen(ParallelLoopMapperEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRParallelLoopMapperEnumsGen)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRGPUPassIncGen)

mlir/include/mlir/Dialect/GPU/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 GpuKernelOutlining : Pass<"gpu-kernel-outlining"> {
+  let summary = "Outline gpu.launch bodies to kernel functions";
+  let constructor = "mlir::createGpuKernelOutliningPass()";
+}
+
+#endif // MLIR_DIALECT_GPU_PASSES

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

 mlir_tablegen(ROCDLConversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRROCDLConversionsIncGen)
 
 add_mlir_dialect(LLVMAVX512 llvm_avx512 LLVMAVX512)
 
 set(LLVM_TARGET_DEFINITIONS LLVMAVX512.td)
 mlir_tablegen(LLVMAVX512Conversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRLLVMAVX512ConversionsIncGen)
+
+set(LLVM_TARGET_DEFINITIONS Transforms/Passes.td)
+mlir_tablegen(Transforms/Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRLLVMPassIncGen)

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"> {
+  let summary = "Legalize LLVM dialect to be convertible to LLVM IR";
+  let constructor = "mlir::LLVM::createLegalizeForExportPass()";
+}
+
+#endif // MLIR_DIALECT_LLVMIR_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Linalg/CMakeLists.txt

 add_subdirectory(IR)
 add_subdirectory(Transforms)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRLinalgPassIncGen)

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

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 class FuncOp;
 class ModuleOp;
 template <typename T> class OpPassBase;
+class Pass;
 
 std::unique_ptr<OpPassBase<FuncOp>> createLinalgFusionPass();
+std::unique_ptr<Pass> createLinalgFusionOfTensorOpsPass();
 
 std::unique_ptr<OpPassBase<FuncOp>>
 createLinalgTilingPass(ArrayRef<int64_t> tileSizes = {});
 
 std::unique_ptr<OpPassBase<FuncOp>>
 createLinalgTilingToParallelLoopsPass(ArrayRef<int64_t> tileSizes = {});
 
 std::unique_ptr<OpPassBase<FuncOp>>
 createLinalgPromotionPass(bool dynamicBuffers);
+std::unique_ptr<OpPassBase<FuncOp>> createLinalgPromotionPass();
 
 /// Create a pass to convert Linalg operations to loop.for loops and
 /// std.load/std.store accesses.
 std::unique_ptr<OpPassBase<FuncOp>> createConvertLinalgToLoopsPass();
 
 /// Create a pass to convert Linalg operations to loop.parallel loops and
 /// std.load/std.store accesses.
 std::unique_ptr<OpPassBase<FuncOp>> createConvertLinalgToParallelLoopsPass();

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 LinalgFusion : Pass<"linalg-fusion"> {
+  let summary = "Fuse operations in the linalg dialect";
+  let constructor = "mlir::createLinalgFusionPass()";
+}
+
+def LinalgFusionOfTensorOps : Pass<"linalg-fusion-for-tensor-ops"> {
+  let summary = "Fuse operations on RankedTensorType in linalg dialect";
+  let constructor = "mlir::createLinalgFusionOfTensorOpsPass()";
+}
+
+def LinalgLowerToAffineLoops : Pass<"convert-linalg-to-affine-loops"> {
+  let summary = "Lower the operations from the linalg dialect into affine "
+                "loops";
+  let constructor = "mlir::createConvertLinalgToAffineLoopsPass()";
+}
+
+def LinalgLowerToLoops : Pass<"convert-linalg-to-loops"> {
+  let summary = "Lower the operations from the linalg dialect into loops";
+  let constructor = "mlir::createConvertLinalgToLoopsPass()";
+}
+
+def LinalgLowerToParallelLoops : Pass<"convert-linalg-to-parallel-loops"> {
+  let summary = "Lower the operations from the linalg dialect into parallel "
+                "loops";
+  let constructor = "mlir::createConvertLinalgToParallelLoopsPass()";
+}
+
+def LinalgPromotion : Pass<"linalg-promote-subviews"> {
+  let summary = "Promote subview ops to local buffers";
+  let constructor = "mlir::createLinalgPromotionPass()";
+}
+
+def LinalgTiling : Pass<"linalg-tile"> {
+  let summary = "Tile operations in the linalg dialect";
+  let constructor = "mlir::createLinalgTilingPass()";
+}
+
+def LinalgTilingToParallelLoops : Pass<"linalg-tile-to-parallel-loops"> {
+  let summary = "Tile operations in the linalg dialect to parallel loops";
+  let constructor = "mlir::createLinalgTilingToParallelLoopsPass()";
+}
+
+#endif // MLIR_DIALECT_LINALG_PASSES

mlir/include/mlir/Dialect/LoopOps/CMakeLists.txt

 add_mlir_dialect(LoopOps loop)
 add_mlir_doc(LoopOps -gen-dialect-doc LoopDialect Dialects/)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRLoopPassIncGen)

mlir/include/mlir/Dialect/LoopOps/Passes.td

+//===-- Passes.td - Loop 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_LOOP_PASSES
+#define MLIR_DIALECT_LOOP_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def LoopParallelLoopFusion : Pass<"parallel-loop-fusion"> {
+  let summary = "Fuse adjacent parallel loops";
+  let constructor = "mlir::createParallelLoopFusionPass()";
+}
+
+def LoopParallelLoopSpecialization : Pass<"parallel-loop-specialization"> {
+  let summary = "Specialize parallel loops for vectorization";
+  let constructor = "mlir::createParallelLoopSpecializationPass()";
+}
+
+def LoopParallelLoopTiling : Pass<"parallel-loop-tiling"> {
+  let summary = "Tile parallel loops";
+  let constructor = "mlir::createParallelLoopTilingPass()";
+}
+
+#endif // MLIR_DIALECT_LOOP_PASSES

mlir/include/mlir/Dialect/Quant/CMakeLists.txt

 add_mlir_dialect(QuantOps quant)
 add_mlir_doc(QuantOps -gen-dialect-doc QuantDialect Dialects/)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRQuantPassIncGen)

mlir/include/mlir/Dialect/Quant/Passes.td

+//===-- Passes.td - Quant 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_QUANT_PASSES
+#define MLIR_DIALECT_QUANT_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def QuantConvertConst : Pass<"quant-convert-const"> {
+  let summary = "Converts constants followed by qbarrier to actual quantized "
+                "values";
+  let constructor = "mlir::quant::createConvertConstPass()";
+}
+
+def QuantConvertSimulatedQuant : Pass<"quant-convert-simulated-quantization"> {
+  let summary = "Converts training-time simulated quantization ops to "
+                "corresponding quantize/dequantize casts";
+  let constructor = "mlir::quant::createConvertSimulatedQuantPass()";
+}
+
+#endif // MLIR_DIALECT_QUANT_PASSES

mlir/include/mlir/Dialect/SPIRV/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
 mlir_tablegen(SPIRVOpUtils.inc -gen-spirv-op-utils)
 add_public_tablegen_target(MLIRSPIRVOpUtilsGen)
 
 set(LLVM_TARGET_DEFINITIONS TargetAndABI.td)
 mlir_tablegen(TargetAndABI.h.inc -gen-struct-attr-decls)
 mlir_tablegen(TargetAndABI.cpp.inc -gen-struct-attr-defs)
 add_public_tablegen_target(MLIRSPIRVTargetAndABIIncGen)
+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRSPIRVPassIncGen)

mlir/include/mlir/Dialect/SPIRV/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_PASSES
+#define MLIR_DIALECT_SPIRV_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def SPIRVCompositeTypeLayout : Pass<"decorate-spirv-composite-type-layout"> {
+  let summary = "Decorate SPIR-V composite type with layout info";
+  let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
+}
+
+def SPIRVLowerABIAttributes : Pass<"spirv-lower-abi-attrs"> {
+  let summary = "Decorate SPIR-V composite type with layout info";
+  let constructor = "mlir::spirv::createLowerABIAttributesPass()";
+}
+
+def SPIRVUpdateVCE : Pass<"spirv-update-vce"> {
+  let summary = "Deduce and attach minimal (version, capabilities, extensions) "
+                "requirements to spv.module ops";
+  let constructor = "mlir::spirv::createUpdateVersionCapabilityExtensionPass()";
+}
+
+#endif // MLIR_DIALECT_SPIRV_PASSES

mlir/include/mlir/InitAllPasses.h

 // registry, since it would already be calling the creation routine of the
 // individual passes.
 // The global registry is interesting to interact with the command-line tools.
 inline void registerAllPasses() {
   // Init general passes
 #define GEN_PASS_REGISTRATION
 #include "mlir/Transforms/Passes.h.inc"
 
+  // Affine
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/Affine/Passes.h.inc"
+
+  // FxpMath
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/FxpMathOps/Passes.h.inc"
+
+  // GPU
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/GPU/Passes.h.inc"
+
+  // Linalg
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/Linalg/Passes.h.inc"
+
+  // LLVM
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
+
+  // Loop
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/LoopOps/Passes.h.inc"
+
+  // Quant
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/Quant/Passes.h.inc"
+#define GEN_PASS_REGISTRATION
+#include "mlir/Quantizer/Transforms/Passes.h.inc"
+
+  // SPIR-V
+#define GEN_PASS_REGISTRATION
+#include "mlir/Dialect/SPIRV/Passes.h.inc"
+
   // At the moment we still rely on global initializers for registering passes,
   // but we may not do it in the future.
   // We must reference the passes in such a way that compilers will not
   // delete it all as dead code, even with whole program optimization,
   // yet is effectively a NO-OP. As the compiler isn't smart enough
   // to know that getenv() never returns -1, this will do the job.
   if (std::getenv("bar") != (char *)-1)
     return;
 
   // Affine
-  createSuperVectorizePass({});
-  createLoopUnrollPass();
-  createLoopUnrollAndJamPass();
-  createSimplifyAffineStructuresPass();
-  createLoopInvariantCodeMotionPass();
-  createAffineLoopInvariantCodeMotionPass();
   createLowerAffinePass();
-  createLoopTilingPass(0);
-  createAffineDataCopyGenerationPass(0, 0);
-  createMemRefDataFlowOptPass();
 
   // AVX512
   createConvertAVX512ToLLVMPass();
 
   // GPUtoRODCLPass
   createLowerGpuOpsToROCDLOpsPass();
 
-  // FxpOpsDialect passes
-  fxpmath::createLowerUniformRealMathPass();
-  fxpmath::createLowerUniformCastsPass();
-
   // GPU
-  createGpuKernelOutliningPass();
   createSimpleLoopsToGPUPass(0, 0);
   createLoopToGPUPass({}, {});
 
   // CUDA
   createConvertGpuLaunchFuncToCudaCallsPass();
   createLowerGpuOpsToNVVMOpsPass();
 
   // Linalg
-  createLinalgFusionPass();
-  createLinalgTilingPass();
-  createLinalgTilingToParallelLoopsPass();
-  createLinalgPromotionPass(0);
-  createConvertLinalgToLoopsPass();
-  createConvertLinalgToParallelLoopsPass();
-  createConvertLinalgToAffineLoopsPass();
   createConvertLinalgToLLVMPass();
 
-  // LLVM
-  LLVM::createLegalizeForExportPass();
-
-  // LoopOps
-  createParallelLoopCollapsingPass();
-  createParallelLoopFusionPass();
-  createParallelLoopSpecializationPass();
-  createParallelLoopTilingPass();
-
-  // QuantOps
-  quant::createConvertSimulatedQuantPass();
-  quant::createConvertConstPass();
-  quantizer::createAddDefaultStatsPass();
-  quantizer::createRemoveInstrumentationPass();
-  quantizer::registerInferQuantizedTypesPass();
-
   // SPIR-V
-  spirv::createDecorateSPIRVCompositeTypeLayoutPass();
-  spirv::createLowerABIAttributesPass();
-  spirv::createUpdateVersionCapabilityExtensionPass();
   createConvertGPUToSPIRVPass();
   createConvertStandardToSPIRVPass();
   createLegalizeStdOpsForSPIRVLoweringPass();
   createLinalgToSPIRVPass();
 
   // Vulkan
   createConvertGpuLaunchFuncToVulkanLaunchFuncPass();
   createConvertVulkanLaunchFuncToVulkanCallsPass();
 }
 
 } // namespace mlir
 
 #endif // MLIR_INITALLPASSES_H_

mlir/include/mlir/Quantizer/CMakeLists.txt

-add_subdirectory(IR)
 add_subdirectory(Transforms)

mlir/include/mlir/Quantizer/Transforms/CMakeLists.txt

+
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls)
+add_public_tablegen_target(MLIRQuantizerPassIncGen)

mlir/include/mlir/Quantizer/Transforms/Passes.h

 class SolverContext;
 class TargetConfiguration;
 
 /// Creates a pass that infers quantized types based on metadata discovered
 /// in the computation.
 std::unique_ptr<OpPassBase<ModuleOp>>
 createInferQuantizedTypesPass(SolverContext &solverContext,
                               const TargetConfiguration &config);
-
-/// Registers the InferQuantizedTypes pass with the global registry.
-void registerInferQuantizedTypesPass();
+std::unique_ptr<OpPassBase<ModuleOp>> createInferQuantizedTypesPass();
 
 /// Creates a pass which removes any instrumentation and hint ops which have
 /// no effect on final runtime.
 std::unique_ptr<OpPassBase<FuncOp>> createRemoveInstrumentationPass();
 
 /// Adds default (dummy) statistics to ops that can benefit from runtime stats.
 /// Meant for testing.
 std::unique_ptr<OpPassBase<FuncOp>> createAddDefaultStatsPass();
 
 } // namespace quantizer
 } // namespace mlir
 
 #endif // MLIR_QUANTIZER_TRANSFORMS_PASSES_H

mlir/include/mlir/Quantizer/Transforms/Passes.td

+//===-- Passes.td - Quantizer 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_QUANTIZER_TRANSFORMS_PASSES
+#define MLIR_QUANTIZER_TRANSFORMS_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+def QuantizerAddDefaultStats : Pass<"quantizer-add-default-stats-test"> {
+  let summary = "Add default (dummy) statistics to all ops that can benefit "
+                "from runtime statistics";
+  let constructor = "mlir::quantizer::createAddDefaultStatsPass()";
+}
+
+def QuantizerInferQuantizedTypes : Pass<"quantizer-infer-quantized-types"> {
+  let summary = "Infer quantized types for a module";
+  let constructor = "mlir::quantizer::createInferQuantizedTypesPass()";
+}
+
+def QuantizerRemoveInstrumentation : Pass<"quantizer-remove-instrumentation"> {
+  let summary = "Remove instrumentation and hints which have no effect on "
+                "final execution";
+  let constructor = "mlir::quantizer::createRemoveInstrumentationPass()";
+}
+
+#endif // MLIR_QUANTIZER_TRANSFORMS_PASSES

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

 /// TODO(bondhugula): extend this to store op's.
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createAffineDataCopyGenerationPass(
     unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned tagMemorySpace,
     int minDmaTransferSize, uint64_t fastMemCapacityBytes) {
   return std::make_unique<AffineDataCopyGeneration>(
       slowMemorySpace, fastMemorySpace, tagMemorySpace, minDmaTransferSize,
       fastMemCapacityBytes);
 }
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createAffineDataCopyGenerationPass() {
+  return std::make_unique<AffineDataCopyGeneration>();
+}
 
 /// 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).
 LogicalResult
 AffineDataCopyGeneration::runOnBlock(Block *block,
                                      DenseSet<Operation *> &copyNests) {
void AffineDataCopyGeneration::runOnFunction() {
   for (auto &block : f)
     runOnBlock(&block, copyNests);
 
   // Promote any single iteration loops in the copy nests.
   for (auto nest : copyNests) {
     nest->walk([](AffineForOp forOp) { promoteIfSingleIteration(forOp); });
   }
 }
-
-static PassRegistration<AffineDataCopyGeneration>
-    pass("affine-data-copy-generate",
-         "Generate explicit copying for memory operations");

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

getFunction().walk([&](AffineForOp op) {
     runOnAffineForOp(op);
   });
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createAffineLoopInvariantCodeMotionPass() {
   return std::make_unique<LoopInvariantCodeMotion>();
 }
-
-static PassRegistration<LoopInvariantCodeMotion>
-    pass("affine-loop-invariant-code-motion",
-         "Hoist loop invariant instructions outside of the loop");

mlir/lib/Dialect/Affine/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRAffineTransforms
   AffineDataCopyGeneration.cpp
   AffineLoopInvariantCodeMotion.cpp
   LoopTiling.cpp
   LoopUnroll.cpp
   LoopUnrollAndJam.cpp
   SuperVectorize.cpp
   SimplifyAffineStructures.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Affine
 
   DEPENDS
   MLIRAffineOpsIncGen
+  MLIRAffinePassIncGen
   MLIRLoopLikeInterfaceIncGen
   )
 target_link_libraries(MLIRAffineTransforms
   PUBLIC
   MLIRAffine
   MLIREDSC
   MLIRIR
   MLIRPass
   MLIRSideEffects
   MLIRStandardOps
   MLIRTransformUtils
   MLIRVector
   MLIRVectorToLLVM
   )
 

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

 } // end anonymous namespace
 
 /// Creates a pass to perform loop tiling on all suitable loop nests of a
 /// Function.
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createLoopTilingPass(uint64_t cacheSizeBytes) {
   return std::make_unique<LoopTiling>(cacheSizeBytes);
 }
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createLoopTilingPass() {
+  return std::make_unique<LoopTiling>();
+}
 
 // Move the loop body of AffineForOp 'src' from 'src' into the specified
 // location in destination's body, ignoring the terminator.
 static inline void moveLoopBody(AffineForOp src, AffineForOp dest,
                                 Block::iterator loc) {
   auto &insts = src.getBody()->getOperations();
   dest.getBody()->getOperations().splice(loc, insts, insts.begin(),
                                          std::prev(insts.end()));
if (clSeparate) {
           MutableArrayRef<AffineForOp>(tiledNest).drop_front(band.size());
       separateFullTiles(intraTileLoops);
     }
   }
 }
 
 constexpr unsigned LoopTiling::kDefaultTileSize;
 constexpr uint64_t LoopTiling::kDefaultCacheMemCapacity;
-
-static PassRegistration<LoopTiling> pass("affine-loop-tile", "Tile loop nests");

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

 
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createLoopUnrollPass(
     int unrollFactor, int unrollFull,
     const std::function<unsigned(AffineForOp)> &getUnrollFactor) {
   return std::make_unique<LoopUnroll>(
       unrollFactor == -1 ? None : Optional<unsigned>(unrollFactor),
       unrollFull == -1 ? None : Optional<bool>(unrollFull), getUnrollFactor);
 }
-
-static PassRegistration<LoopUnroll> pass("affine-loop-unroll", "Unroll loops");

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

if (unrollJamFactor.hasValue())
     return loopUnrollJamByFactor(forOp, unrollJamFactor.getValue());
   // Otherwise, unroll jam by the command-line factor if one was specified.
   if (clUnrollJamFactor.getNumOccurrences() > 0)
     return loopUnrollJamByFactor(forOp, clUnrollJamFactor);
 
   // Unroll and jam by four otherwise.
   return loopUnrollJamByFactor(forOp, kDefaultUnrollJamFactor);
 }
-
-static PassRegistration<LoopUnrollAndJam> pass("affine-loop-unroll-jam",
-                                               "Unroll and jam loops");

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

void SimplifyAffineStructures::runOnFunction() {
   // alloc ops first and then process since normalizeMemRef replaces/erases ops
   // during memref rewriting.
   SmallVector<AllocOp, 4> allocOps;
   func.walk([&](AllocOp op) { allocOps.push_back(op); });
   for (auto allocOp : allocOps) {
     normalizeMemRef(allocOp);
   }
 }
-
-static PassRegistration<SimplifyAffineStructures>
-    pass("simplify-affine-structures",
-         "Simplify affine expressions in maps/sets and normalize memrefs");

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

void Vectorize::runOnFunction() {
   }
   LLVM_DEBUG(dbgs() << "\n");
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize) {
   return std::make_unique<Vectorize>(virtualVectorSize);
 }
-
-static PassRegistration<Vectorize>
-    pass("affine-super-vectorize",
-         "Vectorize to a target independent n-D vector abstraction");
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createSuperVectorizePass() {
+  return std::make_unique<Vectorize>();
+}

mlir/lib/Dialect/FxpMathOps/CMakeLists.txt

 add_mlir_dialect_library(MLIRFxpMathOps
   IR/FxpMathOps.cpp
   Transforms/LowerUniformRealMath.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/FxpMathOps
 
   DEPENDS
   MLIRFxpMathOpsIncGen
+  MLIRFxpMathPassIncGen
   )
 
 target_link_libraries(MLIRFxpMathOps
   PUBLIC
   MLIRQuant
   MLIRIR
   MLIRPass
   MLIRSideEffects
   MLIRSupport
   MLIRStandardOps
   )

mlir/lib/Dialect/FxpMathOps/Transforms/LowerUniformRealMath.cpp

 void LowerUniformRealMathPass::runOnFunction() {
   auto fn = getFunction();
   OwningRewritePatternList patterns;
   auto *context = &getContext();
   patterns.insert<UniformRealAddEwPattern, UniformRealMulEwPattern>(context);
   applyPatternsGreedily(fn, patterns);
 }
 
-OpPassBase<FuncOp> *mlir::fxpmath::createLowerUniformRealMathPass() {
-  return new LowerUniformRealMathPass();
+std::unique_ptr<OpPassBase<FuncOp>>
+mlir::fxpmath::createLowerUniformRealMathPass() {
+  return std::make_unique<LowerUniformRealMathPass>();
 }
 
-static PassRegistration<LowerUniformRealMathPass> lowerUniformRealMathPass(
-    "fxpmath-lower-uniform-real-math",
-    "Lowers uniform-quantized real math ops to integer arithmetic.");
-
 //===----------------------------------------------------------------------===//
 // LowerUniformCasts pass
 //===----------------------------------------------------------------------===//
 
 void LowerUniformCastsPass::runOnFunction() {
   auto fn = getFunction();
   OwningRewritePatternList patterns;
   auto *context = &getContext();
   patterns.insert<UniformDequantizePattern>(context);
   applyPatternsGreedily(fn, patterns);
 }
 
-OpPassBase<FuncOp> *mlir::fxpmath::createLowerUniformCastsPass() {
-  return new LowerUniformCastsPass();
+std::unique_ptr<OpPassBase<FuncOp>>
+mlir::fxpmath::createLowerUniformCastsPass() {
+  return std::make_unique<LowerUniformCastsPass>();
 }
-
-static PassRegistration<LowerUniformCastsPass>
-    lowerUniformCastsPass("fxpmath-lower-uniform-casts",
-                          "Lowers uniform-quantized casts.");

mlir/lib/Dialect/GPU/CMakeLists.txt

 add_mlir_dialect_library(MLIRGPU
   IR/GPUDialect.cpp
   Transforms/AllReduceLowering.cpp
   Transforms/KernelOutlining.cpp
   Transforms/MemoryPromotion.cpp
   Transforms/ParallelLoopMapper.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/GPU
 
   DEPENDS
   MLIRGPUOpsIncGen
+  MLIRGPUPassIncGen
   MLIRParallelLoopMapperAttrGen
   MLIRParallelLoopMapperEnumsGen
   )
 target_link_libraries(MLIRGPU
   PUBLIC
   MLIREDSC
   MLIRIR
   MLIRLLVMIR
   MLIRLoopOps
   MLIRPass
   MLIRSideEffects
   MLIRStandardOps
   MLIRSupport
   MLIRTransformUtils
   LLVMSupport
   )

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

private:
   }
 };
 
 } // namespace
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createGpuKernelOutliningPass() {
   return std::make_unique<GpuKernelOutliningPass>();
 }
-
-static PassRegistration<GpuKernelOutliningPass>
-    pass("gpu-kernel-outlining",
-         "Outline gpu.launch bodies to kernel functions.");

mlir/lib/Dialect/LLVMIR/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRLLVMIRTransforms
   LegalizeForExport.cpp
+
+  DEPENDS
+  MLIRLLVMPassIncGen
   )
 
 target_link_libraries(MLIRLLVMIRTransforms
   PUBLIC
   MLIRIR
   MLIRLLVMIR
   MLIRPass
   )

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

void runOnOperation() override {
     LLVM::ensureDistinctSuccessors(getOperation());
   }
 };
 } // end namespace
 
 std::unique_ptr<Pass> LLVM::createLegalizeForExportPass() {
   return std::make_unique<LegalizeForExportPass>();
 }
-
-static PassRegistration<LegalizeForExportPass>
-    pass("llvm-legalize-for-export",
-         "Legalize LLVM dialect to be convertible to LLVM IR");

mlir/lib/Dialect/Linalg/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRLinalgTransforms
   Fusion.cpp
   LinalgTransforms.cpp
   LinalgToLoops.cpp
   Promotion.cpp
   Tiling.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg
 
   DEPENDS
   intrinsics_gen
+  MLIRLinalgPassIncGen
   MLIRLinalgTransformPatternsIncGen
   )
 target_link_libraries(MLIRLinalgTransforms
   PUBLIC
   MLIRAffine
   MLIRAnalysis
   MLIREDSC
   MLIRIR

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

struct LinalgFusionPass : public FunctionPass<LinalgFusionPass> {
   void runOnFunction() override { fuseLinalgOpsGreedily(getFunction()); }
 };
 } // namespace
 
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createLinalgFusionPass() {
   return std::make_unique<LinalgFusionPass>();
 }
 
-static PassRegistration<LinalgFusionPass>
-    pass("linalg-fusion", "Fuse operations in the linalg dialect");
-
-static PassRegistration<FusionOfTensorOpsPass>
-    tensorOpsPass("linalg-fusion-for-tensor-ops",
-                  "Fuse operations on RankedTensorType in linalg dialect");
+std::unique_ptr<Pass> mlir::createLinalgFusionOfTensorOpsPass() {
+  return std::make_unique<FusionOfTensorOpsPass>();
+}

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

 INSTANTIATE_LINALG_OP_TO_LOOPS(GenericOp)
 INSTANTIATE_LINALG_OP_TO_LOOPS(IndexedGenericOp)
 
 // TODO(pifon): Enable lowering to parallel loops for ops other than
 // linalg.generic for now to be on the safe side.
 template LogicalResult
 mlir::linalg::linalgOpToParallelLoops<GenericOp>(PatternRewriter &rewriter,
                                                  Operation *op);
-
-static PassRegistration<LowerLinalgToLoopsPass<loop::ForOp, StdIndexedValue>>
-    structuredLoopsPass(
-        "convert-linalg-to-loops",
-        "Lower the operations from the linalg dialect into loops");
-
-static PassRegistration<
-    LowerLinalgToLoopsPass<loop::ParallelOp, StdIndexedValue>>
-    parallelLoopsPass(
-        "convert-linalg-to-parallel-loops",
-        "Lower the operations from the linalg dialect into parallel loops");
-
-static PassRegistration<LowerLinalgToLoopsPass<AffineForOp, AffineIndexedValue>>
-    affineLoopsPass(
-        "convert-linalg-to-affine-loops",
-        "Lower the operations from the linalg dialect into affine loops");

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

Option<bool> dynamicBuffers{
       llvm::cl::init(false)};
 };
 } // namespace
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createLinalgPromotionPass(bool dynamicBuffers) {
   return std::make_unique<LinalgPromotionPass>(dynamicBuffers);
 }
-
-static PassRegistration<LinalgPromotionPass>
-    pass("linalg-promote-subviews", "promote subview ops to local buffers");
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createLinalgPromotionPass() {
+  return std::make_unique<LinalgPromotionPass>();
+}

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

 mlir::createLinalgTilingPass(ArrayRef<int64_t> tileSizes) {
   return std::make_unique<LinalgTilingPass<loop::ForOp>>(tileSizes);
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createLinalgTilingToParallelLoopsPass(ArrayRef<int64_t> tileSizes) {
   return std::make_unique<LinalgTilingPass<loop::ParallelOp>>(tileSizes);
 }
-
-static PassRegistration<LinalgTilingPass<loop::ForOp>>
-    tiling_pass("linalg-tile", "Tile operations in the linalg dialect");
-
-static PassRegistration<LinalgTilingPass<loop::ParallelOp>>
-    tiling_to_parallel_loops(
-        "linalg-tile-to-parallel-loops",
-        "Tile operations in the linalg dialect to parallel loops");

mlir/lib/Dialect/LoopOps/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRLoopOpsTransforms
   ParallelLoopFusion.cpp
   ParallelLoopSpecialization.cpp
   ParallelLoopTiling.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LoopOps
+
+  DEPENDS
+  MLIRLoopPassIncGen
   )
 target_link_libraries(MLIRLoopOpsTransforms
   PUBLIC
   MLIRAffine
   MLIRIR
   MLIRPass
   MLIRLoopOps
   MLIRStandardOps
   MLIRSupport
   LLVMSupport
   )

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

struct ParallelLoopFusion : public OperationPass<ParallelLoopFusion> {
   }
 };
 
 } // namespace
 
 std::unique_ptr<Pass> mlir::createParallelLoopFusionPass() {
   return std::make_unique<ParallelLoopFusion>();
 }
-
-static PassRegistration<ParallelLoopFusion>
-    pass("parallel-loop-fusion", "Fuse adjacent parallel loops.");

mlir/lib/Dialect/LoopOps/Transforms/ParallelLoopSpecialization.cpp

void runOnFunction() override {
     getFunction().walk([](ParallelOp op) { specializeLoopForUnrolling(op); });
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createParallelLoopSpecializationPass() {
   return std::make_unique<ParallelLoopSpecialization>();
 }
-
-static PassRegistration<ParallelLoopSpecialization>
-    pass("parallel-loop-specialization",
-         "Specialize parallel loops for vectorization.");

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

ListOption<int64_t> tileSizes{
       llvm::cl::MiscFlags::CommaSeparated};
 };
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::createParallelLoopTilingPass(ArrayRef<int64_t> tileSizes) {
   return std::make_unique<ParallelLoopTiling>(tileSizes);
 }
-
-static PassRegistration<ParallelLoopTiling> pass("parallel-loop-tiling",
-                                                 "Tile parallel loops.");

mlir/lib/Dialect/Quant/CMakeLists.txt

 add_mlir_dialect_library(MLIRQuant
   IR/QuantOps.cpp
   IR/QuantTypes.cpp
   IR/TypeDetail.h
   IR/TypeParser.cpp
   Transforms/ConvertConst.cpp
   Transforms/ConvertSimQuant.cpp
   Utils/QuantizeUtils.cpp
   Utils/UniformSupport.cpp
   Utils/FakeQuantSupport.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/QuantOps
 
   DEPENDS
   MLIRQuantOpsIncGen
+  MLIRQuantPassIncGen
   )
 target_link_libraries(MLIRQuant
   PUBLIC
   MLIRIR
   MLIRPass
   MLIRSideEffects
   MLIRSupport
   MLIRStandardOps
   MLIRTransformUtils
   )

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

void ConvertConstPass::runOnFunction() {
   auto *context = &getContext();
   patterns.insert<QuantizedConstRewrite>(context);
   applyPatternsGreedily(func, patterns);
 }
 
 std::unique_ptr<OpPassBase<FuncOp>> mlir::quant::createConvertConstPass() {
   return std::make_unique<ConvertConstPass>();
 }
-
-static PassRegistration<ConvertConstPass>
-    pass("quant-convert-const",
-         "Converts constants followed by qbarrier to actual quantized values");

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

void ConvertSimulatedQuantPass::runOnFunction() {
   if (hadFailure)
     signalPassFailure();
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::quant::createConvertSimulatedQuantPass() {
   return std::make_unique<ConvertSimulatedQuantPass>();
 }
-
-static PassRegistration<ConvertSimulatedQuantPass>
-    pass("quant-convert-simulated-quantization",
-         "Converts training-time simulated quantization ops to corresponding "
-         "quantize/dequantize casts.");

mlir/lib/Dialect/SPIRV/Transforms/CMakeLists.txt

 add_mlir_dialect_library(MLIRSPIRVTransforms
   DecorateSPIRVCompositeTypeLayoutPass.cpp
   LowerABIAttributesPass.cpp
   UpdateVCEPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
+
+  DEPENDS
+  MLIRSPIRVPassIncGen
   )
 
 target_link_libraries(MLIRSPIRVTransforms
   PUBLIC
   MLIRPass
   MLIRSPIRV
   )

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

for (auto spirvModule : module.getOps<spirv::ModuleOp>()) {
     }
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass() {
   return std::make_unique<DecorateSPIRVCompositeTypeLayoutPass>();
 }
-
-static PassRegistration<DecorateSPIRVCompositeTypeLayoutPass>
-    pass("decorate-spirv-composite-type-layout",
-         "Decorate SPIR-V composite type with layout info");

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

for (auto fn : entryPointFns) {
     }
   }
 }
 
 std::unique_ptr<OpPassBase<spirv::ModuleOp>>
 mlir::spirv::createLowerABIAttributesPass() {
   return std::make_unique<LowerABIAttributesPass>();
 }
-
-static PassRegistration<LowerABIAttributesPass>
-    pass("spirv-lower-abi-attrs", "Lower SPIR-V ABI Attributes");

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

auto triple = spirv::VerCapExtAttr::get(
       deducedExtensions.getArrayRef(), &getContext());
   module.setAttr(spirv::ModuleOp::getVCETripleAttrName(), triple);
 }
 
 std::unique_ptr<OpPassBase<spirv::ModuleOp>>
 mlir::spirv::createUpdateVersionCapabilityExtensionPass() {
   return std::make_unique<UpdateVCEPass>();
 }
-
-static PassRegistration<UpdateVCEPass>
-    pass("spirv-update-vce",
-         "Deduce and attach minimal (version, capabilities, extensions) "
-         "requirements to spv.module ops");

mlir/lib/Quantizer/CMakeLists.txt

 
 # Transforms.
 add_mlir_library(MLIRQuantizerTransforms
   Transforms/AddDefaultStatsTestPass.cpp
   Transforms/InferQuantizedTypesPass.cpp
   Transforms/RemoveInstrumentationPass.cpp
 
   ADDITIONAL_HEADER_DIRS
+
+  DEPENDS
+  MLIRQuantizerPassIncGen
   )
 target_link_libraries(MLIRQuantizerTransforms
   PUBLIC
   MLIRIR
   MLIRQuantizerFxpMathConfig
   MLIRQuantizerSupport
   MLIRQuant
   MLIRPass
   LLVMSupport
   )

mlir/lib/Quantizer/Transforms/AddDefaultStatsTestPass.cpp

func.walk([&](Operation *op) {
     statsOp.getOperation()->replaceUsesOfWith(statsOp, originalResult);
   });
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::quantizer::createAddDefaultStatsPass() {
   return std::make_unique<AddDefaultStatsPass>();
 }
-
-static PassRegistration<AddDefaultStatsPass> pass(
-    "quantizer-add-default-stats-test",
-    "Adds default (dummy) statistics to all ops that can benefit from "
-    "runtime statistics. This is meant to help in early stage bootstrapping.");

mlir/lib/Quantizer/Transforms/InferQuantizedTypesPass.cpp

void InferQuantizedTypesPass::transformResultType(CAGResultAnchor *anchor,
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::quantizer::createInferQuantizedTypesPass(
     SolverContext &solverContext, const TargetConfiguration &config) {
   return std::make_unique<InferQuantizedTypesPass>(solverContext, config);
 }
-void mlir::quantizer::registerInferQuantizedTypesPass() {
-  // Do nothing, this will be enough to force link this file and the static
-  // registration will kick-in. This is temporary while we're refactoring pass
-  // registration to move away from static constructors.
+std::unique_ptr<OpPassBase<ModuleOp>>
+mlir::quantizer::createInferQuantizedTypesPass() {
+  return std::make_unique<InferQuantizedTypesPass>();
 }
-
-static PassRegistration<InferQuantizedTypesPass>
-    pass("quantizer-infer-quantized-types",
-         "Infers quantized types for a module");

mlir/lib/Quantizer/Transforms/RemoveInstrumentationPass.cpp

patterns.insert<RemoveIdentityOpRewrite<StatisticsOp>,
                   RemoveIdentityOpRewrite<CoupledRefOp>>(context);
   applyPatternsGreedily(func, patterns);
 }
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::quantizer::createRemoveInstrumentationPass() {
   return std::make_unique<RemoveInstrumentationPass>();
 }
-
-static PassRegistration<RemoveInstrumentationPass>
-    pass("quantizer-remove-instrumentation",
-         "Removes instrumentation and hints which have no effect on final "
-         "execution");