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

[rriddle]

Summary

This removes the need to statically register conversion passes, and also puts all of the conversions within one centralized file.

Depends On D76657

[jpienaar]

mlir/include/mlir/Conversion/Passes.td

2

What happens if one only wants to include some subset of the passes? Perhaps in a doc somewhere.

[rriddle]

mlir/include/mlir/Conversion/Passes.td

2

That applies to all of the other documents that get generated as well. For example, if we want to split up the operations of a dialect and slice them in different ways(the current documentation for the standard dialect does this). I've been playing around with adding filtering based on some set of tags, or other identifiers. For operations there is already a desire for that, and it seems that could be equally applicable here.

[rriddle]

Rebase

[rriddle]

Rebase

[rriddle]

Rebase

mlir/include/mlir/CMakeLists.txt

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

mlir/include/mlir/Conversion/CMakeLists.txt

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

mlir/include/mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h

 /// 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<OpPassBase<FuncOp>>
 createSimpleLoopsToGPUPass(unsigned numBlockDims, unsigned numThreadDims);
+std::unique_ptr<OpPassBase<FuncOp>> createSimpleLoopsToGPUPass();
 
 /// Create a pass that converts every loop operation within the body of the
 /// FuncOp into a GPU launch. The number of workgroups and workgroup size for
 /// the implementation is controlled by SSA values passed into conversion
 /// method. For testing, the values are set as constants obtained from a command
 /// line flag. See convertLoopToGPULaunch for a description of the required
 /// semantics of the converted loop operation.
 std::unique_ptr<OpPassBase<FuncOp>>
 createLoopToGPUPass(ArrayRef<int64_t> numWorkGroups,
                     ArrayRef<int64_t> workGroupSize);
+std::unique_ptr<OpPassBase<FuncOp>> createLoopToGPUPass();
 
 /// Creates a pass that converts loop.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_LOOPSTOGPU_LOOPSTOGPUPASS_H_

mlir/include/mlir/Conversion/Passes.td

+//===-- Passes.td - Conversion 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_CONVERSION_PASSES
+#define MLIR_CONVERSION_PASSES
+
+include "mlir/Pass/PassBase.td"
+
+//===----------------------------------------------------------------------===//
+// AffineToStandard
+//===----------------------------------------------------------------------===//
+
+def ConvertAffineToStandard : Pass<"lower-affine"> {
+  let summary = "Lower Affine operations to a combination of Standard and Loop "
+                "operations";
+  let constructor = "mlir::createLowerAffinePass()";
+}
+
+//===----------------------------------------------------------------------===//
+// AVX512ToLLVM
+//===----------------------------------------------------------------------===//
+
+def ConvertAVX512ToLLVM : Pass<"convert-avx512-to-llvm"> {
+  let summary = "Convert the operations from the avx512 dialect into the LLVM "
+                "dialect";
+  let constructor = "mlir::createConvertAVX512ToLLVMPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// GPUToCUDA
+//===----------------------------------------------------------------------===//
+
+def ConvertGpuLaunchFuncToCudaCalls : Pass<"launch-func-to-cuda"> {
+  let summary = "Convert all launch_func ops to CUDA runtime calls";
+  let constructor = "mlir::createConvertGpuLaunchFuncToCudaCallsPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// GPUToNVVM
+//===----------------------------------------------------------------------===//
+
+def ConvertGpuOpsToNVVMOps : Pass<"convert-gpu-to-nvvm"> {
+  let summary = "Generate NVVM operations for gpu operations";
+  let constructor = "mlir::createLowerGpuOpsToNVVMOpsPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// GPUToROCDL
+//===----------------------------------------------------------------------===//
+
+def ConvertGpuOpsToROCDLOps : Pass<"convert-gpu-to-rocdl"> {
+  let summary = "Generate ROCDL operations for gpu operations";
+  let constructor = "mlir::createLowerGpuOpsToROCDLOpsPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// GPUToSPIRV
+//===----------------------------------------------------------------------===//
+
+def ConvertGPUToSPIRV : Pass<"convert-gpu-to-spirv"> {
+  let summary = "Convert GPU dialect to SPIR-V dialect";
+  let constructor = "mlir::createConvertGPUToSPIRVPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// GPUToVulkan
+//===----------------------------------------------------------------------===//
+
+def ConvertGpuLaunchFuncToVulkanLaunchFunc
+    : Pass<"convert-gpu-launch-to-vulkan-launch"> {
+  let summary = "Convert gpu.launch_func to vulkanLaunch external call";
+  let constructor = "mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass()";
+}
+
+def ConvertVulkanLaunchFuncToVulkanCalls : Pass<"launch-func-to-vulkan"> {
+  let summary = "Convert vulkanLaunch external call to Vulkan runtime external "
+                "calls";
+  let constructor = "mlir::createConvertVulkanLaunchFuncToVulkanCallsPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// LinalgToLLVM
+//===----------------------------------------------------------------------===//
+
+def ConvertLinalgToLLVM : Pass<"convert-linalg-to-llvm"> {
+  let summary = "Convert the operations from the linalg dialect into the LLVM "
+                "dialect";
+  let constructor = "mlir::createConvertLinalgToLLVMPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// LinalgToSPIRV
+//===----------------------------------------------------------------------===//
+
+def ConvertLinalgToSPIRV : Pass<"convert-linalg-to-spirv"> {
+  let summary = "Convert Linalg ops to SPIR-V ops";
+  let constructor = "mlir::createLinalgToSPIRVPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// LoopToStandard
+//===----------------------------------------------------------------------===//
+
+def ConvertLoopToStandard : Pass<"convert-loop-to-std"> {
+  let summary = "Convert Loop dialect to Standard dialect, replacing structured"
+                " control flow with a CFG";
+  let constructor = "mlir::createLowerToCFGPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// LoopsToGPU
+//===----------------------------------------------------------------------===//
+
+def ConvertSimpleLoopsToGPU : Pass<"convert-loops-to-gpu"> {
+  let summary = "Convert top-level loops to GPU kernels";
+  let constructor = "mlir::createSimpleLoopsToGPUPass()";
+}
+
+def ConvertLoopsToGPU : Pass<"convert-loop-op-to-gpu"> {
+  let summary = "Convert top-level loop::ForOp to GPU kernels";
+  let constructor = "mlir::createLoopToGPUPass()";
+}
+
+def ConvertParallelLoopToGpu : Pass<"convert-parallel-loops-to-gpu"> {
+  let summary = "Convert mapped loop.parallel ops to gpu launch operations";
+  let constructor = "mlir::createParallelLoopToGpuPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// StandardToLLVM
+//===----------------------------------------------------------------------===//
+
+def ConvertStandardToLLVM : Pass<"convert-std-to-llvm"> {
+  let summary = "Convert scalar and vector operations from the Standard to the "
+                "LLVM dialect";
+  let constructor = "mlir::createLowerToLLVMPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// StandardToSPIRV
+//===----------------------------------------------------------------------===//
+
+def LegalizeStandardForSPIRV : Pass<"legalize-std-for-spirv"> {
+  let summary = "Legalize standard ops for SPIR-V lowering";
+  let constructor = "mlir::createLegalizeStdOpsForSPIRVLoweringPass()";
+}
+
+def ConvertStandardToSPIRV : Pass<"convert-std-to-spirv"> {
+  let summary = "Convert Standard Ops to SPIR-V dialect";
+  let constructor = "mlir::createConvertStandardToSPIRVPass()";
+}
+
+//===----------------------------------------------------------------------===//
+// VectorToLLVM
+//===----------------------------------------------------------------------===//
+
+def ConvertVectorToLLVM : Pass<"convert-vector-to-llvm"> {
+  let summary = "Lower the operations from the vector dialect into the LLVM "
+                "dialect";
+  let constructor = "mlir::createConvertVectorToLLVMPass()";
+}
+
+#endif // MLIR_CONVERSION_PASSES

mlir/include/mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h

 //===- ConvertVectorToLoops.h - Utils to convert from the vector 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_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
 #define MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
 
-#include "mlir/Transforms/DialectConversion.h"
-
 namespace mlir {
 class MLIRContext;
-class ModuleOp;
-template <typename T> class OpPassBase;
+class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert from the Vector dialect to loops + std.
 void populateVectorToAffineLoopsConversionPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns);
 
-/// Create a pass to convert vector operations to affine loops + std dialect.
-OpPassBase<ModuleOp> *createLowerVectorToLoopsPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h"
 #include "mlir/Conversion/GPUToCUDA/GPUToCUDAPass.h"
 #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
 #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
+#include "mlir/Conversion/LoopToStandard/ConvertLoopToStandard.h"
 #include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
+#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/FxpMathOps/Passes.h"
 #include "mlir/Dialect/GPU/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/LoopOps/Passes.h"
 #include "mlir/Dialect/Quant/Passes.h"
 #include "mlir/Dialect/SPIRV/Passes.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"
 
+  // Conversion passes
+#define GEN_PASS_REGISTRATION
+#include "mlir/Conversion/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"
 

 #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
-  createLowerAffinePass();
-
-  // AVX512
-  createConvertAVX512ToLLVMPass();
-
-  // GPUtoRODCLPass
-  createLowerGpuOpsToROCDLOpsPass();
-
-  // GPU
-  createSimpleLoopsToGPUPass(0, 0);
-  createLoopToGPUPass({}, {});
-
-  // CUDA
-  createConvertGpuLaunchFuncToCudaCallsPass();
-  createLowerGpuOpsToNVVMOpsPass();
-
-  // Linalg
-  createConvertLinalgToLLVMPass();
-
-  // SPIR-V
-  createConvertGPUToSPIRVPass();
-  createConvertStandardToSPIRVPass();
-  createLegalizeStdOpsForSPIRVLoweringPass();
-  createLinalgToSPIRVPass();
-
-  // Vulkan
-  createConvertGpuLaunchFuncToVulkanLaunchFuncPass();
-  createConvertVulkanLaunchFuncToVulkanCallsPass();
 }
 
 } // namespace mlir
 
 #endif // MLIR_INITALLPASSES_H_

mlir/lib/Conversion/AVX512ToLLVM/CMakeLists.txt

 add_mlir_conversion_library(MLIRAVX512ToLLVM
   ConvertAVX512ToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AVX512ToLLVM
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 
 set(LIBS
   MLIRAVX512
   MLIRLLVMAVX512
   MLIRLLVMIR
   MLIRStandardToLLVM
   MLIRTransforms
   LLVMCore
   LLVMSupport
   )
 
 add_dependencies(MLIRAVX512ToLLVM ${LIBS})
 target_link_libraries(MLIRAVX512ToLLVM PUBLIC ${LIBS})

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

if (failed(
           applyPartialConversion(getModule(), target, patterns, &converter))) {
     signalPassFailure();
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertAVX512ToLLVMPass() {
   return std::make_unique<ConvertAVX512ToLLVMPass>();
 }
-
-static PassRegistration<ConvertAVX512ToLLVMPass> pass(
-    "convert-avx512-to-llvm",
-    "Convert the operations from the avx512 dialect into the LLVM dialect");

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 };
 } // namespace
 
 /// Lowers If and For operations within a function into their lower level CFG
 /// equivalent blocks.
 std::unique_ptr<OpPassBase<FuncOp>> mlir::createLowerAffinePass() {
   return std::make_unique<LowerAffinePass>();
 }
-
-static PassRegistration<LowerAffinePass>
-    pass("lower-affine",
-         "Lower affine dialect operations to loop/standard dialect ones");

mlir/lib/Conversion/AffineToStandard/CMakeLists.txt

 add_mlir_conversion_library(MLIRAffineToStandard
   AffineToStandard.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AffineToStandard
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 target_link_libraries(
   MLIRAffineToStandard
   PUBLIC
   MLIRAffine
   MLIRLoopOps
   MLIRPass
   MLIRStandardOps
   MLIRTransforms
   MLIRIR
   LLVMCore
   LLVMSupport
   )

mlir/lib/Conversion/GPUToCUDA/CMakeLists.txt

  list(APPEND SOURCES "ConvertKernelFuncToCubin.cpp")
   set(NVPTX_LIBS
     LLVMNVPTXCodeGen
     LLVMNVPTXDesc
     LLVMNVPTXInfo
   )
 endif()
 
-add_mlir_conversion_library(MLIRGPUtoCUDATransforms ${SOURCES})
+add_mlir_conversion_library(MLIRGPUtoCUDATransforms
+  ${SOURCES}
+
+  DEPENDS
+  MLIRConversionPassIncGen
+)
 target_link_libraries(MLIRGPUtoCUDATransforms
   PUBLIC
   ${NVPTX_LIBS}
   LLVMCore
   LLVMMC
   LLVMSupport
   MLIRGPU
   MLIRIR
   MLIRLLVMIR
   MLIRNVVMIR
   MLIRPass
   MLIRSupport
   MLIRTargetNVVMIR
 )

mlir/lib/Conversion/GPUToCUDA/ConvertLaunchFuncToCudaCalls.cpp

builder.create<LLVM::CallOp>(loc, ArrayRef<Type>{getCUResultType()},
                                ArrayRef<Value>(cuStream.getResult(0)));
   launchOp.erase();
 }
 
 std::unique_ptr<mlir::OpPassBase<mlir::ModuleOp>>
 mlir::createConvertGpuLaunchFuncToCudaCallsPass() {
   return std::make_unique<GpuLaunchFuncToCudaCallsPass>();
 }
-
-static PassRegistration<GpuLaunchFuncToCudaCallsPass>
-    pass("launch-func-to-cuda",
-         "Convert all launch_func ops to CUDA runtime calls");

mlir/lib/Conversion/GPUToNVVM/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS GPUToNVVM.td)
 mlir_tablegen(GPUToNVVM.cpp.inc -gen-rewriters)
 add_public_tablegen_target(MLIRGPUToNVVMIncGen)
 
 add_mlir_conversion_library(MLIRGPUtoNVVMTransforms
   LowerGpuOpsToNVVMOps.cpp
 
   DEPENDS
+  MLIRConversionPassIncGen
   MLIRGPUToNVVMIncGen
   )
 
 target_link_libraries(MLIRGPUtoNVVMTransforms
   PUBLIC
   LLVMSupport
   MLIRGPU
   MLIRLLVMIR
   MLIRNVVMIR
   MLIRPass
   MLIRStandardToLLVM
   MLIRTransformUtils
   )

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void mlir::populateGpuToNVVMConversionPatterns(
   patterns.insert<OpToFuncCallLowering<TanhOp>>(converter, "__nv_tanhf",
                                                 "__nv_tanh");
 }
 
 std::unique_ptr<OpPassBase<gpu::GPUModuleOp>>
 mlir::createLowerGpuOpsToNVVMOpsPass() {
   return std::make_unique<LowerGpuOpsToNVVMOpsPass>();
 }
-
-static PassRegistration<LowerGpuOpsToNVVMOpsPass>
-    pass("convert-gpu-to-nvvm", "Generate NVVM operations for gpu operations");

mlir/lib/Conversion/GPUToROCDL/CMakeLists.txt

 add_mlir_conversion_library(MLIRGPUtoROCDLTransforms
   LowerGpuOpsToROCDLOps.cpp
+
+  DEPENDS
+  MLIRConversionPassIncGen
   )
 target_link_libraries(MLIRGPUtoROCDLTransforms
   PUBLIC
   LLVMSupport
   MLIRGPU
   MLIRLLVMIR
   MLIRROCDLIR
   MLIRPass
   MLIRStandardToLLVM
   )

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

 
 } // anonymous namespace
 
 std::unique_ptr<OpPassBase<gpu::GPUModuleOp>>
 mlir::createLowerGpuOpsToROCDLOpsPass() {
   return std::make_unique<LowerGpuOpsToROCDLOpsPass>();
 }
 
-static PassRegistration<LowerGpuOpsToROCDLOpsPass>
-    pass("convert-gpu-to-rocdl",
-         "Generate ROCDL operations for gpu operations");

mlir/lib/Conversion/GPUToSPIRV/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS GPUToSPIRV.td)
 mlir_tablegen(GPUToSPIRV.cpp.inc -gen-rewriters)
 add_public_tablegen_target(MLIRGPUToSPIRVIncGen)
 
 add_mlir_conversion_library(MLIRGPUtoSPIRVTransforms
   ConvertGPUToSPIRV.cpp
   ConvertGPUToSPIRVPass.cpp
 
   DEPENDS
+  MLIRConversionPassIncGen
   MLIRGPUToSPIRVIncGen
   )
 
 target_link_libraries(MLIRGPUtoSPIRVTransforms
   PUBLIC
   MLIRGPU
   MLIRIR
   MLIRPass
   MLIRSPIRV
   MLIRStandardOps
   MLIRStandardToSPIRVTransforms
   MLIRSupport
   MLIRTransforms
   )

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.cpp

 //===- ConvertGPUToSPIRVPass.cpp - GPU to SPIR-V dialect lowering 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/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVLowering.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Pass/PassRegistry.h"
 
 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
 ///
if (failed(applyFullConversion(kernelModules, *target, patterns,
                                  &typeConverter))) {
     return signalPassFailure();
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertGPUToSPIRVPass() {
   return std::make_unique<GPUToSPIRVPass>();
 }
-
-static PassRegistration<GPUToSPIRVPass>
-    pass("convert-gpu-to-spirv", "Convert GPU dialect to SPIR-V dialect");

mlir/lib/Conversion/GPUToVulkan/CMakeLists.txt

 add_mlir_conversion_library(MLIRGPUtoVulkanTransforms
   ConvertLaunchFuncToVulkanCalls.cpp
   ConvertGPULaunchFuncToVulkanLaunchFunc.cpp
+
+  DEPENDS
+  MLIRConversionPassIncGen
   )
 
 target_link_libraries(MLIRGPUtoVulkanTransforms
   PUBLIC
   MLIRGPU
   MLIRIR
   MLIRLLVMIR
   MLIRPass
   MLIRSPIRV
   MLIRSPIRVSerialization
   MLIRStandardOps
   MLIRSupport
   MLIRTransforms
   MLIRTranslation
   LLVMSupport
   )

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

void ConvertGpuLaunchFuncToVulkanLaunchFunc::convertGpuLaunchFunc(
 
   launchOp.erase();
 }
 
 std::unique_ptr<mlir::OpPassBase<mlir::ModuleOp>>
 mlir::createConvertGpuLaunchFuncToVulkanLaunchFuncPass() {
   return std::make_unique<ConvertGpuLaunchFuncToVulkanLaunchFunc>();
 }
-
-static PassRegistration<ConvertGpuLaunchFuncToVulkanLaunchFunc>
-    pass("convert-gpu-launch-to-vulkan-launch",
-         "Convert gpu.launch_func to vulkanLaunch external call");

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

void VulkanLaunchFuncToVulkanCallsPass::translateVulkanLaunchCall(
 
   cInterfaceVulkanLaunchCallOp.erase();
 }
 
 std::unique_ptr<mlir::OpPassBase<mlir::ModuleOp>>
 mlir::createConvertVulkanLaunchFuncToVulkanCallsPass() {
   return std::make_unique<VulkanLaunchFuncToVulkanCallsPass>();
 }
-
-static PassRegistration<VulkanLaunchFuncToVulkanCallsPass>
-    pass("launch-func-to-vulkan",
-         "Convert vulkanLaunch external call to Vulkan runtime external calls");

mlir/lib/Conversion/LinalgToLLVM/CMakeLists.txt

 add_mlir_conversion_library(MLIRLinalgToLLVM
   LinalgToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LinalgToLLVM
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 set(LIBS
   MLIRAffineToStandard
   MLIREDSC
   MLIRIR
   MLIRLinalgOps
   MLIRLLVMIR
   MLIRLoopToStandard

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

void ConvertLinalgToLLVMPass::runOnModule() {
   target.addLegalOp<ModuleOp, ModuleTerminatorOp>();
   if (failed(applyFullConversion(module, target, patterns, &converter)))
     signalPassFailure();
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertLinalgToLLVMPass() {
   return std::make_unique<ConvertLinalgToLLVMPass>();
 }
-
-static PassRegistration<ConvertLinalgToLLVMPass> pass(
-    "convert-linalg-to-llvm",
-    "Convert the operations from the linalg dialect into the LLVM dialect");

mlir/lib/Conversion/LinalgToSPIRV/CMakeLists.txt

 add_mlir_conversion_library(MLIRLinalgToSPIRVTransforms
   LinalgToSPIRV.cpp
   LinalgToSPIRVPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
+
+  DEPENDS
+  MLIRConversionPassIncGen
   )
 
 target_link_libraries(MLIRLinalgToSPIRVTransforms
   PUBLIC
   MLIRIR
   MLIRLinalgOps
   MLIRLinalgUtils
   MLIRPass
   MLIRSPIRV
   MLIRSupport
   )

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

void LinalgToSPIRVPass::runOnModule() {
 
   if (failed(applyFullConversion(module, *target, patterns)))
     return signalPassFailure();
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createLinalgToSPIRVPass() {
   return std::make_unique<LinalgToSPIRVPass>();
 }
-
-static PassRegistration<LinalgToSPIRVPass>
-    pass("convert-linalg-to-spirv", "Convert Linalg ops to SPIR-V ops");

mlir/lib/Conversion/LoopToStandard/CMakeLists.txt

 add_mlir_conversion_library(MLIRLoopToStandard
   LoopToStandard.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LoopToStandard
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 target_link_libraries(
   MLIRLoopToStandard
   PUBLIC
   MLIRLoopOps
   MLIRTransforms
   LLVMCore
   LLVMSupport
   )

mlir/lib/Conversion/LoopToStandard/LoopToStandard.cpp

void LoopToStandardPass::runOnOperation() {
   target.addLegalDialect<StandardOpsDialect>();
   if (failed(applyPartialConversion(getOperation(), target, patterns)))
     signalPassFailure();
 }
 
 std::unique_ptr<Pass> mlir::createLowerToCFGPass() {
   return std::make_unique<LoopToStandardPass>();
 }
-
-static PassRegistration<LoopToStandardPass>
-    pass("convert-loop-to-std", "Convert Loop dialect to Standard dialect, "
-                                "replacing structured control flow with a CFG");

mlir/lib/Conversion/LoopsToGPU/CMakeLists.txt

 add_mlir_conversion_library(MLIRLoopsToGPU
   LoopsToGPU.cpp
   LoopsToGPUPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/LoopsToGPU
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 target_link_libraries(MLIRLoopsToGPU
   PUBLIC
   MLIRAffine
   MLIRAffineToStandard
   MLIRGPU
   MLIRIR
   MLIRLinalgOps
   MLIRPass
   MLIRStandardOps
   MLIRSupport
   MLIRTransforms
   LLVMSupport
   )

mlir/lib/Conversion/LoopsToGPU/LoopsToGPUPass.cpp

 
 } // namespace
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createSimpleLoopsToGPUPass(unsigned numBlockDims,
                                  unsigned numThreadDims) {
   return std::make_unique<ForLoopMapper>(numBlockDims, numThreadDims);
 }
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createSimpleLoopsToGPUPass() {
+  return std::make_unique<ForLoopMapper>();
+}
 
 std::unique_ptr<OpPassBase<FuncOp>>
 mlir::createLoopToGPUPass(ArrayRef<int64_t> numWorkGroups,
                           ArrayRef<int64_t> workGroupSize) {
   return std::make_unique<ImperfectlyNestedForLoopMapper>(numWorkGroups,
                                                           workGroupSize);
 }
+std::unique_ptr<OpPassBase<FuncOp>> mlir::createLoopToGPUPass() {
+  return std::make_unique<ImperfectlyNestedForLoopMapper>();
+}
 
 std::unique_ptr<Pass> mlir::createParallelLoopToGpuPass() {
   return std::make_unique<ParallelLoopToGpuPass>();
 }
-
-static PassRegistration<ForLoopMapper>
-    registration(PASS_NAME, "Convert top-level loops to GPU kernels");
-
-static PassRegistration<ImperfectlyNestedForLoopMapper>
-    loopOpToGPU(LOOPOP_TO_GPU_PASS_NAME,
-                "Convert top-level loop::ForOp to GPU kernels");
-
-static PassRegistration<ParallelLoopToGpuPass>
-    pass("convert-parallel-loops-to-gpu", "Convert mapped loop.parallel ops"
-                                          " to gpu launch operations.");

mlir/lib/Conversion/StandardToLLVM/CMakeLists.txt

 add_mlir_conversion_library(MLIRStandardToLLVM
   StandardToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/StandardToLLVM
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 target_link_libraries(
   MLIRStandardToLLVM
   PUBLIC
   MLIRLLVMIR
   MLIRTransforms
   LLVMCore
   LLVMSupport
   )

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 }
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::createLowerToLLVMPass(bool useAlloca, bool useBarePtrCallConv,
                             bool emitCWrappers, unsigned indexBitwidth) {
   return std::make_unique<LLVMLoweringPass>(useAlloca, useBarePtrCallConv,
                                             emitCWrappers, indexBitwidth);
 }
-
-static PassRegistration<LLVMLoweringPass>
-    pass(PASS_NAME, "Convert scalar and vector operations from the "
-                    "Standard to the LLVM dialect");

mlir/lib/Conversion/StandardToSPIRV/CMakeLists.txt

 add_mlir_conversion_library(MLIRStandardToSPIRVTransforms
   ConvertStandardToSPIRV.cpp
   ConvertStandardToSPIRVPass.cpp
   LegalizeStandardForSPIRV.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
+
+  DEPENDS
+  MLIRConversionPassIncGen
   )
 
 target_link_libraries(MLIRStandardToSPIRVTransforms
   PUBLIC
   MLIRIR
   MLIRPass
   MLIRSPIRV
   MLIRSupport
   MLIRTransformUtils
   MLIRSPIRV
   MLIRStandardOps
   )

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.cpp

void ConvertStandardToSPIRVPass::runOnModule() {
   if (failed(applyPartialConversion(module, *target, patterns))) {
     return signalPassFailure();
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertStandardToSPIRVPass() {
   return std::make_unique<ConvertStandardToSPIRVPass>();
 }
-
-static PassRegistration<ConvertStandardToSPIRVPass>
-    pass("convert-std-to-spirv", "Convert Standard Ops to SPIR-V dialect");

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

void SPIRVLegalization::runOnOperation() {
   auto *context = &getContext();
   populateStdLegalizationPatternsForSPIRVLowering(context, patterns);
   applyPatternsGreedily(getOperation()->getRegions(), patterns);
 }
 
 std::unique_ptr<Pass> mlir::createLegalizeStdOpsForSPIRVLoweringPass() {
   return std::make_unique<SPIRVLegalization>();
 }
-
-static PassRegistration<SPIRVLegalization>
-    pass("legalize-std-for-spirv", "Legalize standard ops for SPIR-V lowering");

mlir/lib/Conversion/VectorToLLVM/CMakeLists.txt

 add_mlir_conversion_library(MLIRVectorToLLVM
   ConvertVectorToLLVM.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/VectorToLLVM
+
+  DEPENDS
+  MLIRConversionPassIncGen
 )
 set(LIBS
   MLIRLLVMIR
   MLIRStandardToLLVM
   MLIRVector
   MLIRTransforms
   LLVMCore
   LLVMSupport
   )
 
 add_dependencies(MLIRVectorToLLVM ${LIBS})
 target_link_libraries(MLIRVectorToLLVM
   PUBLIC
   ${LIBS})

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

if (failed(
           applyPartialConversion(getModule(), target, patterns, &converter))) {
     signalPassFailure();
   }
 }
 
 std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertVectorToLLVMPass() {
   return std::make_unique<LowerVectorToLLVMPass>();
 }
-
-static PassRegistration<LowerVectorToLLVMPass>
-    pass("convert-vector-to-llvm",
-         "Lower the operations from the vector dialect into the LLVM dialect");