add option to control whether to use conversion attributes

Author: fabianmcg

mlir/include/mlir/Conversion/Passes.td

@@ -22,12 +22,18 @@ def ConvertToLLVMPass : Pass<"convert-to-llvm"> {
     This is a generic pass to convert to LLVM, it uses the
     `ConvertToLLVMPatternInterface` dialect interface to delegate to dialects
     the injection of conversion patterns.
+
+    If `use-conversion-attrs` is set to `true`, the pass will look for
+    `ConvertToLLVMAttrInterface` attributes and use them to further configure
+    the conversion process. Enabling this option incurs in extra overhead.
   }];
 
   let constructor = "mlir::createConvertToLLVMPass()";
   let options = [
     ListOption<"filterDialects", "filter-dialects", "std::string",
                "Test conversion patterns of only the specified dialects">,
+    Option<"useConversionAttrs", "use-conversion-attrs", "bool", "false",
+           "Use op conversion attributes to configure the conversion">,
   ];
 }
 

mlir/lib/Conversion/ConvertToLLVM/ConvertToLLVMPass.cpp

@@ -63,6 +63,9 @@ class ConvertToLLVMPass
     : public impl::ConvertToLLVMPassBase<ConvertToLLVMPass> {
   std::shared_ptr<const SmallVector<ConvertToLLVMPatternInterface *>>
       interfaces;
+  std::shared_ptr<const FrozenRewritePatternSet> patterns;
+  std::shared_ptr<const ConversionTarget> target;
+  std::shared_ptr<const LLVMTypeConverter> typeConverter;
 
 public:
   using impl::ConvertToLLVMPassBase<ConvertToLLVMPass>::ConvertToLLVMPassBase;
@@ -72,8 +75,22 @@ class ConvertToLLVMPass
   }
 
   LogicalResult initialize(MLIRContext *context) final {
-    auto interfaces =
-        std::make_shared<SmallVector<ConvertToLLVMPatternInterface *>>();
+    std::shared_ptr<SmallVector<ConvertToLLVMPatternInterface *>> interfaces;
+    std::shared_ptr<ConversionTarget> target;
+    std::shared_ptr<LLVMTypeConverter> typeConverter;
+    RewritePatternSet tempPatterns(context);
+
+    // Only collect the interfaces if `useConversionAttrs=true` as everything
+    // else must be initialized in `runOnOperation`.
+    if (useConversionAttrs) {
+      interfaces =
+          std::make_shared<SmallVector<ConvertToLLVMPatternInterface *>>();
+    } else {
+      target = std::make_shared<ConversionTarget>(*context);
+      target->addLegalDialect<LLVM::LLVMDialect>();
+      typeConverter = std::make_shared<LLVMTypeConverter>(context);
+    }
+
     if (!filterDialects.empty()) {
       // Test mode: Populate only patterns from the specified dialects. Produce
       // an error if the dialect is not loaded or does not implement the
@@ -88,7 +105,12 @@ class ConvertToLLVMPass
           return emitError(UnknownLoc::get(context))
                  << "dialect does not implement ConvertToLLVMPatternInterface: "
                  << dialectName << "\n";
-        interfaces->push_back(iface);
+        if (useConversionAttrs) {
+          interfaces->push_back(iface);
+          continue;
+        }
+        iface->populateConvertToLLVMConversionPatterns(*target, *typeConverter,
+                                                       tempPatterns);
       }
     } else {
       // Normal mode: Populate all patterns from all dialects that implement the
@@ -99,15 +121,34 @@ class ConvertToLLVMPass
         auto *iface = dyn_cast<ConvertToLLVMPatternInterface>(dialect);
         if (!iface)
           continue;
-        interfaces->push_back(iface);
+        if (useConversionAttrs) {
+          interfaces->push_back(iface);
+          continue;
+        }
+        iface->populateConvertToLLVMConversionPatterns(*target, *typeConverter,
+                                                       tempPatterns);
       }
     }
 
-    this->interfaces = interfaces;
+    if (useConversionAttrs) {
+      this->interfaces = interfaces;
+    } else {
+      this->patterns =
+          std::make_unique<FrozenRewritePatternSet>(std::move(tempPatterns));
+      this->target = target;
+      this->typeConverter = typeConverter;
+    }
     return success();
   }
 
   void runOnOperation() final {
+    // Fast path:
+    if (!useConversionAttrs) {
+      if (failed(applyPartialConversion(getOperation(), *target, *patterns)))
+        signalPassFailure();
+      return;
+    }
+    // Slow path with conversion attributes.
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);

mlir/lib/Conversion/ConvertToLLVM/ToLLVMInterface.cpp

@@ -35,6 +35,8 @@ void mlir::populateOpConvertToLLVMConversionPatterns(
     Operation *op, ConversionTarget &target, LLVMTypeConverter &typeConverter,
     RewritePatternSet &patterns) {
   auto iface = dyn_cast<ConvertToLLVMOpInterface>(op);
+  if (!iface)
+    iface = op->getParentOfType<ConvertToLLVMOpInterface>();
   if (!iface)
     return;
   SmallVector<ConvertToLLVMAttrInterface, 12> attrs;

mlir/test/Conversion/GPUToNVVM/gpu-to-nvvm-target-attr.mlir

@@ -1,4 +1,4 @@
-// RUN: mlir-opt %s --pass-pipeline="builtin.module(gpu.module(convert-to-llvm))" | FileCheck %s
+// RUN: mlir-opt %s --pass-pipeline="builtin.module(gpu.module(convert-to-llvm{use-conversion-attrs=true}))" | FileCheck %s
 
 // CHECK-LABEL: gpu.module @nvvm_module
 gpu.module @nvvm_module [#nvvm.target] {