[MLIR] Migrate Arithmetic -> LLVM conversion pass to the auto-generated constructor

[mscuttari]

Summary

See #57475

[rriddle]

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

326

This can be simplified to just using Base::Base;

[mscuttari]

Easier constructor inheritance

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

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

mlir/include/mlir/Conversion/Passes.td

let options = [Option<"chipset", "chipset", "std::string",
                         /*default=*/"\"gfx000\"",
                         "Chipset that these operations will run on">];
 }
 
 //===----------------------------------------------------------------------===//
 // ArithmeticToLLVM
 //===----------------------------------------------------------------------===//
 
-def ConvertArithmeticToLLVM : Pass<"convert-arith-to-llvm"> {
+def ArithmeticToLLVMConversionPass : Pass<"convert-arith-to-llvm"> {
   let summary = "Convert Arithmetic dialect to LLVM dialect";
   let description = [{
     This pass converts supported Arithmetic ops to LLVM dialect instructions.
   }];
-  let constructor = "mlir::arith::createConvertArithmeticToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
   let options = [
     Option<"indexBitwidth", "index-bitwidth", "unsigned",
            /*default=kDeriveIndexBitwidthFromDataLayout*/"0",
            "Bitwidth of the index type, 0 to use size of machine word">,
   ];
 }
 

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 #include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/VectorPattern.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-#define GEN_PASS_DEF_CONVERTARITHMETICTOLLVM
+#define GEN_PASS_DEF_ARITHMETICTOLLVMCONVERSIONPASS
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
 
 namespace {
 
 //===----------------------------------------------------------------------===//
return LLVM::detail::handleMultidimensionalVectors(
       rewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
-struct ConvertArithmeticToLLVMPass
-    : public impl::ConvertArithmeticToLLVMBase<ConvertArithmeticToLLVMPass> {
-  ConvertArithmeticToLLVMPass() = default;
+struct ArithmeticToLLVMConversionPass
+    : public impl::ArithmeticToLLVMConversionPassBase<
+          ArithmeticToLLVMConversionPass> {
+  using Base::Base;
 
   void runOnOperation() override {
     LLVMConversionTarget target(getContext());
     RewritePatternSet patterns(&getContext());
 
     LowerToLLVMOptions options(&getContext());
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
patterns.add<
     SubIOpLowering,
     TruncFOpLowering,
     TruncIOpLowering,
     UIToFPOpLowering,
     XOrIOpLowering
   >(converter);
   // clang-format on
 }
-
-std::unique_ptr<Pass> mlir::arith::createConvertArithmeticToLLVMPass() {
-  return std::make_unique<ConvertArithmeticToLLVMPass>();
-}

mlir/test/CAPI/execution_engine.c

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

mlir/unittests/ExecutionEngine/Invoke.cpp

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