[MLIR] Add LLVMConversionTarget as a customization point. NFC.

[timshen]

Spaces.

[mehdi_amini]

Can you provide a description for this patch which would motivate this please?

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

372

It isn't clear what this means, what is a "Customization class" and what can we customized?

[ftynse]

Same as @mehdi_amini, I'd like to understand why is this necessary.

[timshen]

Update comments.

[timshen]

In D75140#1892771, @mehdi_amini wrote:

Can you provide a description for this patch which would motivate this please?

Updated the comments. It's clearer to refer to D75141 and see that an action is added as illegal / dynamically legal. Without this centeralized place, we have to change all the users who write addLegalDialect<LLVM::LLVMDialect> to add the illegal action in D75141. This real intent is hard to put in the class comments, as it might get stale.

[timshen]

In D75140#1892868, @ftynse wrote:

Same as @mehdi_amini, I'd like to understand why is this necessary.

See above.

[timshen]

Update comments.

[ftynse]

This real intent is hard to put in the class comments, as it might get stale.

Commit description would be the right place. https://mlir.llvm.org/getting_started/Contributing/#commit-messages -> "Prefer describing why the change is implemented rather than what it does."

[mehdi_amini]

LGTM, but please provide a complete description in the commit message when landing.

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

struct ToyToLLVMLoweringPass : public ModulePass<ToyToLLVMLoweringPass> {
   void runOnModule() final;
 };
 } // end anonymous namespace
 
 void ToyToLLVMLoweringPass::runOnModule() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering. For this lowering, we are only targeting
   // the LLVM dialect.
-  ConversionTarget target(getContext());
-  target.addLegalDialect<LLVM::LLVMDialect>();
+  LLVMConversionTarget target(getContext());
   target.addLegalOp<ModuleOp, ModuleTerminatorOp>();
 
   // During this lowering, we will also be lowering the MemRef types, that are
   // currently being operated on, to a representation in LLVM. Do perform this
   // conversion we use a TypeConverter as part of the lowering. This converter
   // details how one type maps to another. This is necessary now that we will be
   // doing more complicated lowerings, involving loop region arguments.
   LLVMTypeConverter typeConverter(&getContext());

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

struct ToyToLLVMLoweringPass : public ModulePass<ToyToLLVMLoweringPass> {
   void runOnModule() final;
 };
 } // end anonymous namespace
 
 void ToyToLLVMLoweringPass::runOnModule() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering. For this lowering, we are only targeting
   // the LLVM dialect.
-  ConversionTarget target(getContext());
-  target.addLegalDialect<LLVM::LLVMDialect>();
+  LLVMConversionTarget target(getContext());
   target.addLegalOp<ModuleOp, ModuleTerminatorOp>();
 
   // During this lowering, we will also be lowering the MemRef types, that are
   // currently being operated on, to a representation in LLVM. Do perform this
   // conversion we use a TypeConverter as part of the lowering. This converter
   // details how one type maps to another. This is necessary now that we will be
   // doing more complicated lowerings, involving loop region arguments.
   LLVMTypeConverter typeConverter(&getContext());

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

ConvertToLLVMPattern(StringRef rootOpName, MLIRContext *context,
                        LLVMTypeConverter &typeConverter,
                        PatternBenefit benefit = 1);
 
 protected:
   /// Reference to the type converter, with potential extensions.
   LLVMTypeConverter &typeConverter;
 };
 
+/// Derived class that populates legalization action information for LLVM
+/// conversion.
+class LLVMConversionTarget : public ConversionTarget {
+public:
+  explicit LLVMConversionTarget(MLIRContext &ctx);
+
+  // TODO: Override isDynamicallyLegal when needed.
+};
+
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

converter.addConversion([&](MemRefType type) -> Optional<Type> {
       if (type.getMemorySpace() != gpu::GPUDialect::getPrivateAddressSpace())
         return llvm::None;
       return converter.convertType(MemRefType::Builder(type).setMemorySpace(0));
     });
 
     OwningRewritePatternList patterns;
     populateStdToLLVMConversionPatterns(converter, patterns);
     populateGpuToNVVMConversionPatterns(converter, patterns);
-    ConversionTarget target(getContext());
+    LLVMConversionTarget target(getContext());
     target.addIllegalDialect<gpu::GPUDialect>();
     target.addIllegalOp<LLVM::FAbsOp, LLVM::FCeilOp, LLVM::CosOp,
                         LLVM::ExpOp>();
     target.addIllegalOp<FuncOp>();
-    target.addLegalDialect<LLVM::LLVMDialect>();
     target.addLegalDialect<NVVM::NVVMDialect>();
     target.addDynamicallyLegalOp<mlir::LLVM::CallOp>(
         gpu::filterIllegalLLVMIntrinsics({"tanh", "tanhf"}, m.getContext()));
     // TODO(csigg): Remove once we support replacing non-root ops.
     target.addLegalOp<gpu::YieldOp, gpu::GPUModuleOp, gpu::ModuleEndOp>();
     if (failed(applyPartialConversion(m, target, patterns, &converter)))
       signalPassFailure();
   }

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

void ConvertLinalgToLLVMPass::runOnModule() {
   populateAffineToStdConversionPatterns(patterns, &getContext());
   populateLoopToStdConversionPatterns(patterns, &getContext());
   populateStdToLLVMConversionPatterns(converter, patterns, /*useAlloca=*/false,
                                       /*emitCWrappers=*/true);
   populateVectorToLLVMConversionPatterns(converter, patterns);
   populateLinalgToStandardConversionPatterns(patterns, &getContext());
   populateLinalgToLLVMConversionPatterns(converter, patterns, &getContext());
 
-  ConversionTarget target(getContext());
-  target.addLegalDialect<LLVM::LLVMDialect>();
+  LLVMConversionTarget target(getContext());
   target.addDynamicallyLegalOp<FuncOp>(
       [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
   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/StandardToLLVM/ConvertStandardToLLVM.cpp

void runOnModule() override {
     OwningRewritePatternList patterns;
     if (useBarePtrCallConv)
       populateStdToLLVMBarePtrConversionPatterns(typeConverter, patterns,
                                                  useAlloca);
     else
       populateStdToLLVMConversionPatterns(typeConverter, patterns, useAlloca,
                                           emitCWrappers);
 
-    ConversionTarget target(getContext());
-    target.addLegalDialect<LLVM::LLVMDialect>();
+    LLVMConversionTarget target(getContext());
     if (failed(applyPartialConversion(m, target, patterns, &typeConverter)))
       signalPassFailure();
   }
 
   /// Use `alloca` instead of `call @malloc` for converting std.alloc.
   Option<bool> useAlloca{
       *this, "use-alloca",
       llvm::cl::desc("Replace emission of malloc/free by alloca"),
struct LLVMLoweringPass : public ModulePass<LLVMLoweringPass> {
   /// Emit wrappers for C-compatible pointer-to-struct memref descriptors.
   Option<bool> emitCWrappers{
       *this, "emit-c-wrappers",
       llvm::cl::desc("Emit C-compatible wrapper functions"),
       llvm::cl::init(false)};
 };
 } // end namespace
 
+mlir::LLVMConversionTarget::LLVMConversionTarget(MLIRContext &ctx)
+    : ConversionTarget(ctx) {
+  this->addLegalDialect<LLVM::LLVMDialect>();
+}
+
 std::unique_ptr<OpPassBase<ModuleOp>>
 mlir::createLowerToLLVMPass(bool useAlloca, bool useBarePtrCallConv,
                             bool emitCWrappers) {
   return std::make_unique<LLVMLoweringPass>(useAlloca, useBarePtrCallConv,
                                             emitCWrappers);
 }
 
 static PassRegistration<LLVMLoweringPass>
     pass(PASS_NAME, "Convert scalar and vector operations from the "
                     "Standard to the LLVM dialect");

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

void LowerVectorToLLVMPass::runOnModule() {
   }
 
   // Convert to the LLVM IR dialect.
   LLVMTypeConverter converter(&getContext());
   OwningRewritePatternList patterns;
   populateVectorToLLVMConversionPatterns(converter, patterns);
   populateStdToLLVMConversionPatterns(converter, patterns);
 
-  ConversionTarget target(getContext());
-  target.addLegalDialect<LLVM::LLVMDialect>();
+  LLVMConversionTarget target(getContext());
   target.addDynamicallyLegalOp<FuncOp>(
       [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
   if (failed(
           applyPartialConversion(getModule(), target, patterns, &converter))) {
     signalPassFailure();
   }
 }
 
 OpPassBase<ModuleOp> *mlir::createLowerVectorToLLVMPass() {
   return new LowerVectorToLLVMPass();
 }
 
 static PassRegistration<LowerVectorToLLVMPass>
     pass("convert-vector-to-llvm",
          "Lower the operations from the vector dialect into the LLVM dialect");