[mlir] Port Conversion Passes to LLVM to use TableGen generated constructors and options

[zero9178]

Summary

See https://github.com/llvm/llvm-project/issues/57475 for more context.

Using auto-generated constructors and options has significant advantages:

• It forces a uniform style and expectation for consuming a pass
• It allows to very easily add, remove or change options to a pass by simply making the changes in TableGen
• Its less code

This patch in particular ports all the conversion passes which lower to LLVM to use the auto generated constructors and options. For the most part, care was taken so that auto generated constructor functions have the same name as they previously did. Only following slight breaking changes (which I consider as worth the churn) have been made:

• mlir::cf::createConvertControlFlowToLLVMPass has been moved to the mlir namespace. This is consistent with basically all conversion passes
• createGpuToLLVMConversionPass now takes a proper options struct array for its pass options. The pass options are now also autogenerated.
• LowerVectorToLLVMOptions has been replaced by the autogenerated ConvertVectorToLLVMPassOptions which is automatically kept up to date by TableGen
• I had to move one function in the GPU to LLVM lowering as it is used as default value for an option.
• All passes that previously returned unique_ptr<OperationPass<...>> now simply return unique_ptr<Pass>

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

 //===- AsyncToLLVM.h - Convert Async to LLVM 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_ASYNCTOLLVM_ASYNCTOLLVM_H
 #define MLIR_CONVERSION_ASYNCTOLLVM_ASYNCTOLLVM_H
 
 #include <memory>
 
 namespace mlir {
 
 class ConversionTarget;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 class MLIRContext;
 class TypeConverter;
 class RewritePatternSet;
 
-#define GEN_PASS_DECL_CONVERTASYNCTOLLVM
+#define GEN_PASS_DECL_CONVERTASYNCTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 
-/// Create a pass to convert Async operations to the LLVM dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertAsyncToLLVMPass();
-
 /// 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);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_ASYNCTOLLVM_ASYNCTOLLVM_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_CONVERTCOMPLEXTOLLVM
+#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/ControlFlowToLLVM/ControlFlowToLLVM.h

 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
-#define GEN_PASS_DECL_CONVERTCONTROLFLOWTOLLVM
+#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);
 
 /// Populate the cf.assert to LLVM conversion pattern. If `abortOnFailure` is
 /// set to false, the program execution continues when a condition is
 /// unsatisfied.
 void populateAssertToLLVMConversionPattern(LLVMTypeConverter &converter,
                                            RewritePatternSet &patterns,
                                            bool abortOnFailure = true);
-
-/// 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/GPUCommon/GPUCommonPass.h

 //===- GPUCommonPass.h - MLIR GPU runtime support -------------------------===//
 //
 // 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_GPUCOMMON_GPUCOMMONPASS_H_
 #define MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_
 
+#include "mlir/Dialect/GPU/Transforms/Utils.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <vector>
 
 namespace llvm {
 class LLVMContext;
 class Module;
 } // namespace llvm
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class Location;
 struct LogicalResult;
 class ModuleOp;
 class Operation;
 class RewritePatternSet;
 
-template <typename T>
-class OperationPass;
+class Pass;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 
 namespace LLVM {
 class LLVMDialect;
 } // namespace LLVM
 
 #define GEN_PASS_DECL_GPUTOLLVMCONVERSIONPASS
 #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)>;
 
-/// 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);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUCOMMON_GPUCOMMONPASS_H_

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

 //===- LinalgToLLVM.h - Utils to convert from the 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_
 #define MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class MLIRContext;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 class RewritePatternSet;
 
-#define GEN_PASS_DECL_CONVERTLINALGTOLLVM
+#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/MathToLLVM/MathToLLVM.h

 #include <memory>
 
 namespace mlir {
 
 class LLVMTypeConverter;
 class RewritePatternSet;
 class Pass;
 
-#define GEN_PASS_DECL_CONVERTMATHTOLLVM
+#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/OpenACCToLLVM/ConvertOpenACCToLLVM.h

 //===- ConvertOpenACCToLLVM.h - OpenACC conversion pass entrypoint --------===//
 //
 // 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_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H
 #define MLIR_CONVERSION_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H
 
 #include "mlir/Conversion/LLVMCommon/StructBuilder.h"
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 class RewritePatternSet;
 
-#define GEN_PASS_DECL_CONVERTOPENACCTOLLVM
+#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.
public:
   void setPointer(OpBuilder &builder, Location loc, Value ptr);
   void setBasePointer(OpBuilder &builder, Location loc, Value basePtr);
   void setSize(OpBuilder &builder, Location loc, Value size);
 };
 
 /// Collect the patterns to convert from the OpenACC dialect LLVMIR dialect.
 void populateOpenACCToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                              RewritePatternSet &patterns);
-
-/// Create a pass to convert the OpenACC dialect into the LLVMIR dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertOpenACCToLLVMPass();
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_OPENACCTOLLVM_CONVERTOPENACCTOLLVM_H

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

 //===- OpenMPToLLVM.h - Utils to convert from the OpenMP 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_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H
 #define MLIR_CONVERSION_OPENMPTOLLVM_CONVERTOPENMPTOLLVM_H
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ConversionTarget;
 class MLIRContext;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 class RewritePatternSet;
 
-#define GEN_PASS_DECL_CONVERTOOPENMPTOLLVM
+#define GEN_PASS_DECL_CONVERTOPENMPTOLLVMPASS
 #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/Passes.td

def ConvertArmNeon2dToIntr : Pass<"arm-neon-2d-to-intr"> {
   let constructor = "mlir::createConvertArmNeon2dToIntrPass()";
   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::ArithDialect",
     "async::AsyncDialect",
     "LLVM::LLVMDialect",
     "func::FuncDialect",
   ];
   let options = [
     Option<"useOpaquePointers", "use-opaque-pointers", "bool",
def ConvertBufferizationToMemRef : Pass<"convert-bufferization-to-memref"> {
   let constructor = "mlir::createBufferizationToMemRefPass()";
   let dependentDialects = ["arith::ArithDialect", "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 ConvertComplexToStandard : Pass<"convert-complex-to-standard"> {
   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">,
     Option<"useOpaquePointers", "use-opaque-pointers", "bool",
                    /*default=*/"false", "Generate LLVM IR using opaque pointers "
                    "instead of typed pointers">,

 }
 
 //===----------------------------------------------------------------------===//
 // GPUCommon
 //===----------------------------------------------------------------------===//
 
 def GpuToLLVMConversionPass : Pass<"gpu-to-llvm", "ModuleOp"> {
   let summary = "Convert GPU dialect to LLVM dialect with GPU runtime calls";
-  let constructor = "mlir::createGpuToLLVMConversionPass()";
+
+  let description = [{
+    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).
+  }];
+
+  let options = [
+    Option<"kernelBarePtrCallConv", "use-bare-pointers-for-kernels", "bool",
+           /*default=*/"false",
+             "Use bare pointers to pass memref arguments to kernels. "
+             "The kernel must use the same setting for this option."
+           >,
+    Option<"gpuBinaryAnnotation", "gpu-binary-annotation", "std::string",
+               /*default=*/"gpu::getDefaultGpuBinaryAnnotation()",
+               "Annotation attribute string for GPU binary"
+               >,
+  ];
+
   let dependentDialects = [
     "LLVM::LLVMDialect",
     "memref::MemRefDialect",
   ];
 }
 
-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 description = [{
+    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.
+  }];
+
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // GPUToNVVM
 //===----------------------------------------------------------------------===//
 
 def ConvertGpuOpsToNVVMOps : Pass<"convert-gpu-to-nvvm", "gpu::GPUModuleOp"> {
Option<"indexBitwidth", "index-bitwidth", "unsigned",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // 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"> {
let dependentDialects = [
     "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 ConvertOpenACCToSCF : Pass<"convert-openacc-to-scf", "ModuleOp"> {
   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 ConvertShapeConstraints : Pass<"convert-shape-constraints"> {
   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"> {
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
     (AMX, X86Vector, ArmNeon, ArmSVE, etc.) in combination with the
     architectural-neutral vector dialect lowering.
 
   }];
-  let constructor = "mlir::createConvertVectorToLLVMPass()";
   // Override explicitly in C++ to allow conditional dialect dependence.
   // let dependentDialects;
   let options = [
     Option<"reassociateFPReductions", "reassociate-fp-reductions",
            "bool", /*default=*/"false",
            "Allows llvm to reassociate floating-point reductions for speed">,
     Option<"force32BitVectorIndices", "force-32bit-vector-indices",
            "bool", /*default=*/"true",

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

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H
 #define MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H
 
 #include <memory>
 
 namespace mlir {
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 
-#define GEN_PASS_DECL_LOWERHOSTCODETOLLVM
-#define GEN_PASS_DECL_CONVERTSPIRVTOLLVM
+#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/VectorToLLVM/ConvertVectorToLLVM.h

 //===- ConvertVectorToLLVM.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_CONVERTVECTORTOLLVM_H_
 #define MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLLVM_H_
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class LLVMTypeConverter;
-class ModuleOp;
-template <typename T>
-class OperationPass;
+class Pass;
 
-#define GEN_PASS_DECL_CONVERTVECTORTOLLVM
+#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) {
-    reassociateFPReductions = b;
-    return *this;
-  }
-  LowerVectorToLLVMOptions &enableIndexOptimizations(bool b = true) {
-    force32BitVectorIndices = b;
-    return *this;
-  }
-  LowerVectorToLLVMOptions &enableArmNeon(bool b = true) {
-    armNeon = b;
-    return *this;
-  }
-  LowerVectorToLLVMOptions &enableArmSVE(bool b = true) {
-    armSVE = b;
-    return *this;
-  }
-  LowerVectorToLLVMOptions &enableAMX(bool b = true) {
-    amx = b;
-    return *this;
-  }
-  LowerVectorToLLVMOptions &enableX86Vector(bool b = true) {
-    x86Vector = b;
-    return *this;
-  }
-
-  bool reassociateFPReductions{false};
-  bool force32BitVectorIndices{true};
-  bool armNeon{false};
-  bool armSVE{false};
-  bool amx{false};
-  bool x86Vector{false};
-};
-
 /// Collect a set of patterns to convert from Vector contractions to LLVM Matrix
 /// Intrinsics. To lower to assembly, the LLVM flag -lower-matrix-intrinsics
 /// will be needed when invoking LLVM.
 void populateVectorToLLVMMatrixConversionPatterns(LLVMTypeConverter &converter,
                                                   RewritePatternSet &patterns);
 
 /// Collect a set of patterns to convert from the Vector dialect to LLVM.
 void populateVectorToLLVMConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns,
     bool reassociateFPReductions = false, bool force32BitVectorIndices = false);
 
-/// Create a pass to convert vector operations to the LLVMIR dialect.
-std::unique_ptr<OperationPass<ModuleOp>> createConvertVectorToLLVMPass(
-    const LowerVectorToLLVMOptions &options = LowerVectorToLLVMOptions());
-
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLLVM_H_

mlir/include/mlir/Dialect/GPU/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
 //
 //===----------------------------------------------------------------------===//
 //
 // This header file defines prototypes that expose pass constructors.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_GPU_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_GPU_TRANSFORMS_PASSES_H_
 
+#include "Utils.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Pass/Pass.h"
 #include <optional>
 
 namespace llvm {
 class TargetMachine;
 class LLVMContext;
 class Module;

 void populateGpuAllReducePatterns(RewritePatternSet &patterns);
 
 /// Collect all patterns to rewrite ops within the GPU dialect.
 inline void populateGpuRewritePatterns(RewritePatternSet &patterns) {
   populateGpuAllReducePatterns(patterns);
 }
 
 namespace gpu {
-/// Returns the default annotation name for GPU binary blobs.
-std::string getDefaultGpuBinaryAnnotation();
-
 /// Base pass class to serialize kernel functions through LLVM into
 /// user-specified IR and add the resulting blob as module attribute.
 class SerializeToBlobPass : public OperationPass<gpu::GPUModuleOp> {
 public:
   SerializeToBlobPass(TypeID passID);
   SerializeToBlobPass(const SerializeToBlobPass &other);
 
   void runOnOperation() final;

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_GPU_TRANSFORMS_UTILS_H_
 #define MLIR_DIALECT_GPU_TRANSFORMS_UTILS_H_
 
 #include "mlir/Support/LLVM.h"
 
+#include <string>
+
 namespace mlir {
 struct LogicalResult;
 class Operation;
 class Value;
 
 namespace gpu {
 class GPUFuncOp;
 class LaunchOp;
+
+/// Returns the default annotation name for GPU binary blobs.
+std::string getDefaultGpuBinaryAnnotation();
 } // namespace gpu
 
 /// Get a gpu.func created from outlining the region of a gpu.launch op with the
 /// given `kernelFnName`. The region of the `launchOp` can use values from
 /// above. These need to be captured and passed as arguments to the generated
 /// gpu.func. The generated function has arguments
 /// - corresponding to the values passed in as `operands`, in that order.
 /// - any additional values that might be used within the region of the

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

struct SparseCompilerOptions
 
   /// Projects out the options for `createSparseTensorConversionPass`.
   SparseTensorConversionOptions sparseTensorConversionOptions() const {
     return SparseTensorConversionOptions(
         sparseToSparseConversionStrategy(sparseToSparse));
   }
 
   /// Projects out the options for `createConvertVectorToLLVMPass`.
-  LowerVectorToLLVMOptions lowerVectorToLLVMOptions() const {
-    LowerVectorToLLVMOptions opts{};
-    opts.enableReassociateFPReductions(reassociateFPReductions);
-    opts.enableIndexOptimizations(force32BitVectorIndices);
-    opts.enableArmNeon(armNeon);
-    opts.enableArmSVE(armSVE);
-    opts.enableAMX(amx);
-    opts.enableX86Vector(x86Vector);
+  ConvertVectorToLLVMPassOptions lowerVectorToLLVMOptions() const {
+    ConvertVectorToLLVMPassOptions opts{};
+    opts.reassociateFPReductions = reassociateFPReductions;
+    opts.force32BitVectorIndices = force32BitVectorIndices;
+    opts.armNeon = armNeon;
+    opts.armSVE = armSVE;
+    opts.amx = amx;
+    opts.x86Vector = x86Vector;
     return opts;
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Building and Registering.
 //===----------------------------------------------------------------------===//
 

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

 #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_CONVERTASYNCTOLLVM
+#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;
 
public:
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertAsyncToLLVMPass
-    : public impl::ConvertAsyncToLLVMBase<ConvertAsyncToLLVMPass> {
+    : public impl::ConvertAsyncToLLVMPassBase<ConvertAsyncToLLVMPass> {
+  using Base::Base;
+
   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); });
 }

mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp

 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Dialect/Arith/IR/Arith.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_CONVERTCOMPLEXTOLLVM
+#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 impl::ConvertComplexToLLVMBase<ConvertComplexToLLVMPass> {
+    : public impl::ConvertComplexToLLVMPassBase<ConvertComplexToLLVMPass> {
+  using Base::Base;
+
   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/ControlFlowToLLVM/ControlFlowToLLVM.cpp

 #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_CONVERTCONTROLFLOWTOLLVM
+#define GEN_PASS_DEF_CONVERTCONTROLFLOWTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 #define PASS_NAME "convert-cf-to-llvm"
 
 static std::string generateGlobalMsgSymbolName(ModuleOp moduleOp) {

 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A pass converting MLIR operations into the LLVM IR dialect.
 struct ConvertControlFlowToLLVM
-    : public impl::ConvertControlFlowToLLVMBase<ConvertControlFlowToLLVM> {
-  ConvertControlFlowToLLVM() = default;
+    : public impl::ConvertControlFlowToLLVMPassBase<ConvertControlFlowToLLVM> {
+
+  using Base::Base;
 
   /// 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);
     options.useOpaquePointers = useOpaquePointers;
 
     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/GPUCommon/GPUToLLVMConversion.cpp

 
 static constexpr const char *kGpuBinaryStorageSuffix = "_gpubin_cst";
 
 namespace {
 
 class GpuToLLVMConversionPass
     : public impl::GpuToLLVMConversionPassBase<GpuToLLVMConversionPass> {
 public:
-  GpuToLLVMConversionPass() = default;
-
-  GpuToLLVMConversionPass(bool kernelBarePtrCallConv)
-      : GpuToLLVMConversionPass() {
-    if (this->kernelBarePtrCallConv.getNumOccurrences() == 0)
-      this->kernelBarePtrCallConv = kernelBarePtrCallConv;
-  }
-
-  GpuToLLVMConversionPass(const GpuToLLVMConversionPass &other)
-      : GpuToLLVMConversionPassBase(other) {}
+  using Base::Base;
 
   // 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"),
-      llvm::cl::init(gpu::getDefaultGpuBinaryAnnotation())};
-  Option<bool> kernelBarePtrCallConv{
-      *this, "use-bare-pointers-for-kernels",
-      llvm::cl::desc("Use bare pointers to pass memref arguments to kernels. "
-                     "The kernel must use the same setting for this option."),
-      llvm::cl::init(false)};
 };
 
 struct FunctionCallBuilder {
   FunctionCallBuilder(StringRef functionName, Type returnType,
                       ArrayRef<Type> argumentTypes)
       : functionName(functionName),
         functionType(LLVM::LLVMFunctionType::get(returnType, argumentTypes)) {}
   LLVM::CallOp create(Location loc, OpBuilder &builder,
LogicalResult ConvertSetDefaultDeviceOpToGpuRuntimeCallPattern::matchAndRewrite(
     gpu::SetDefaultDeviceOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Location loc = op.getLoc();
   setDefaultDeviceCallBuilder.create(loc, rewriter, {adaptor.getDevIndex()});
   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));
       });

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 #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_CONVERTLINALGTOLLVM
+#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>

 /// 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 impl::ConvertLinalgToLLVMBase<ConvertLinalgToLLVMPass> {
+    : public impl::ConvertLinalgToLLVMPassBase<ConvertLinalgToLLVMPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to the LLVM IR dialect using the converter defined above.
   RewritePatternSet patterns(&getContext());
   LLVMTypeConverter converter(&getContext());
   populateLinalgToLLVMConversionPatterns(converter, patterns);
   populateFinalizeMemRefToLLVMConversionPatterns(converter, patterns);
 
   LLVMConversionTarget target(getContext());
   target.addLegalOp<ModuleOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertLinalgToLLVMPass() {
-  return std::make_unique<ConvertLinalgToLLVMPass>();
-}

mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp

 #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_CONVERTMATHTOLLVM
+#define GEN_PASS_DEF_CONVERTMATHTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 template <typename SourceOp, typename TargetOp>
return LLVM::detail::handleMultidimensionalVectors(
           return rewriter.create<LLVM::FDivOp>(
               loc, llvm1DVectorTy, ValueRange{one, sqrt}, divAttrs.getAttrs());
         },
         rewriter);
   }
 };
 
 struct ConvertMathToLLVMPass
-    : public impl::ConvertMathToLLVMBase<ConvertMathToLLVMPass> {
-  ConvertMathToLLVMPass() = default;
+    : public impl::ConvertMathToLLVMPassBase<ConvertMathToLLVMPass> {
+  using Base::Base;
 
   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<
     RoundOpLowering,
     RsqrtOpLowering,
     SinOpLowering,
     SqrtOpLowering,
     FTruncOpLowering
   >(converter);
   // clang-format on
 }
-
-std::unique_ptr<Pass> mlir::createConvertMathToLLVMPass() {
-  return std::make_unique<ConvertMathToLLVMPass>();
-}

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

 
 #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_CONVERTOPENACCTOLLVM
+#define GEN_PASS_DEF_CONVERTOPENACCTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // DataDescriptor implementation
 //===----------------------------------------------------------------------===//
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 impl::ConvertOpenACCToLLVMBase<ConvertOpenACCToLLVMPass> {
+    : public impl::ConvertOpenACCToLLVMPassBase<ConvertOpenACCToLLVMPass> {
+  using Base::Base;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertOpenACCToLLVMPass::runOnOperation() {
   auto op = getOperation();
   auto *context = op.getContext();
 
target.addDynamicallyLegalOp<acc::UpdateOp>(
       [allDataOperandsAreConverted](acc::UpdateOp op) {
         return allDataOperandsAreConverted(op.getHostOperands()) &&
                allDataOperandsAreConverted(op.getDeviceOperands());
       });
 
   if (failed(applyPartialConversion(op, target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<OperationPass<ModuleOp>>
-mlir::createConvertOpenACCToLLVMPass() {
-  return std::make_unique<ConvertOpenACCToLLVMPass>();
-}

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

 #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_CONVERTOPENMPTOLLVM
+#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
patterns.add<
       RegionLessOpWithVarOperandsConversion<omp::ThreadprivateOp>,
       LegalizeDataOpForLLVMTranslation<omp::DataOp>,
       LegalizeDataOpForLLVMTranslation<omp::EnterDataOp>,
       LegalizeDataOpForLLVMTranslation<omp::ExitDataOp>>(converter);
 }
 
 namespace {
 struct ConvertOpenMPToLLVMPass
-    : public impl::ConvertOpenMPToLLVMBase<ConvertOpenMPToLLVMPass> {
+    : public impl::ConvertOpenMPToLLVMPassBase<ConvertOpenMPToLLVMPass> {
+  using Base::Base;
+
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertOpenMPToLLVMPass::runOnOperation() {
   auto module = getOperation();
 
   // Convert to OpenMP operations with LLVM IR dialect
   RewritePatternSet patterns(&getContext());
   LLVMTypeConverter converter(&getContext());
   arith::populateArithToLLVMConversionPatterns(converter, patterns);
   cf::populateControlFlowToLLVMConversionPatterns(converter, patterns);
   populateFinalizeMemRefToLLVMConversionPatterns(converter, patterns);
   populateFuncToLLVMConversionPatterns(converter, patterns);
   populateOpenMPToLLVMConversionPatterns(converter, patterns);
 
   LLVMConversionTarget target(getContext());
   target.addLegalOp<omp::TerminatorOp, omp::TaskyieldOp, omp::FlushOp,
                     omp::BarrierOp, omp::TaskwaitOp>();
   configureOpenMPToLLVMConversionLegality(target, converter);
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertOpenMPToLLVMPass() {
-  return std::make_unique<ConvertOpenMPToLLVMPass>();
-}

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

 #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_LOWERHOSTCODETOLLVM
+#define GEN_PASS_DEF_LOWERHOSTCODETOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 static constexpr const char kSPIRVModule[] = "__spv__";
 
 //===----------------------------------------------------------------------===//
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 impl::LowerHostCodeToLLVMBase<LowerHostCodeToLLVM> {
+    : public impl::LowerHostCodeToLLVMPassBase<LowerHostCodeToLLVM> {
 public:
+
+  using Base::Base;
+
   void runOnOperation() override {
     ModuleOp module = getOperation();
 
     // Erase the GPU module.
     for (auto gpuModule :
          llvm::make_early_inc_range(module.getOps<gpu::GPUModuleOp>()))
       gpuModule.erase();
 
for (auto spvModule : module.getOps<spirv::ModuleOp>()) {
       if (failed(encodeKernelName(spvModule))) {
         signalPassFailure();
         return;
       }
     }
   }
 };
 } // namespace
-
-std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
-mlir::createLowerHostCodeToLLVMPass() {
-  return std::make_unique<LowerHostCodeToLLVM>();
-}

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.cpp

 
 #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_CONVERTSPIRVTOLLVM
+#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 impl::ConvertSPIRVToLLVMBase<ConvertSPIRVToLLVMPass> {
+    : public impl::ConvertSPIRVToLLVMPassBase<ConvertSPIRVToLLVMPass> {
   void runOnOperation() override;
+
+public:
+  using Base::Base;
 };
 } // namespace
 
 void ConvertSPIRVToLLVMPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
   LLVMTypeConverter converter(&getContext());
 
void ConvertSPIRVToLLVMPass::runOnOperation() {
   target.addIllegalDialect<spirv::SPIRVDialect>();
   target.addLegalDialect<LLVM::LLVMDialect>();
 
   // Set `ModuleOp` as legal for `spirv.module` conversion.
   target.addLegalOp<ModuleOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
-
-std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertSPIRVToLLVMPass() {
-  return std::make_unique<ConvertSPIRVToLLVMPass>();
-}

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVMPass.cpp

 #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_CONVERTVECTORTOLLVM
+#define GEN_PASS_DEF_CONVERTVECTORTOLLVMPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 using namespace mlir::vector;
 
 namespace {
 struct LowerVectorToLLVMPass
-    : public impl::ConvertVectorToLLVMBase<LowerVectorToLLVMPass> {
-  LowerVectorToLLVMPass(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;
-  }
+    : public impl::ConvertVectorToLLVMPassBase<LowerVectorToLLVMPass> {
+
+  using Base::Base;
+
   // Override explicitly to allow conditional dialect dependence.
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect>();
     registry.insert<arith::ArithDialect>();
     registry.insert<memref::MemRefDialect>();
     if (armNeon)
       registry.insert<arm_neon::ArmNeonDialect>();
     if (armSVE)
if (x86Vector) {
     configureX86VectorLegalizeForExportTarget(target);
     populateX86VectorLegalizeForLLVMExportPatterns(converter, patterns);
   }
 
   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);
-}

mlir/test/lib/Dialect/LLVM/TestLowerToLLVM.cpp

void buildTestLowerToLLVM(OpPassManager &pm,
   // Sprinkle some cleanups.
   pm.addPass(createCanonicalizerPass());
   pm.addPass(createCSEPass());
   // Blanket-convert any remaining linalg ops to LLVM if any remain.
   pm.addPass(createConvertLinalgToLLVMPass());
   // Convert vector to LLVM (always needed).
   pm.addPass(createConvertVectorToLLVMPass(
       // TODO: add more options on a per-need basis.
-      LowerVectorToLLVMOptions().enableReassociateFPReductions(
-          options.reassociateFPReductions)));
+      ConvertVectorToLLVMPassOptions{options.reassociateFPReductions}));
   // Convert Math to LLVM (always needed).
   pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
   // Expand complicated MemRef operations before lowering them.
   pm.addPass(memref::createExpandStridedMetadataPass());
   // The expansion may create affine expressions. Get rid of them.
   pm.addPass(createLowerAffinePass());
   // Convert MemRef to LLVM (always needed).
   pm.addPass(createFinalizeMemRefToLLVMConversionPass());