[mlir][Transform] Add support to drive conversions of func to LLVM with TD

[nicolasvasilache]

Summary

This revision adds a transform.apply_conversion_patterns.func.func_to_llvm transformation.

It is unclear at this point whether this should be spelled out as a standalone transformation
or whether it should resemble transform.apply_conversion_patterns.dialect_to_llvm "fun".

This is dependent on how we want to handle the type converter creation.
In particular the current implementation exhibits the fact that
transform.apply_conversion_patterns.memref.memref_to_llvm_type_converter was not rich enough
and did not match the LowerToLLVMOptions.

Keeping those options in sync across all the passes that lower to LLVM is very error prone.
Instead, we should have a single to_llvm_type_converter.

[nicolasvasilache]

Add a (currently failing) transform with data_layout

[nicolasvasilache]

Attempt to apply partial conversion without failures, this is currently unsuccesful.

[nicolasvasilache]

Rebase

[nicolasvasilache]

Rebase

[nicolasvasilache]

Fix test and rebase

[nicolasvasilache]

Rebase

[nicolasvasilache]

There is some followup here to better layer this with @mehdi_amini 's work and deciding whether we indeed want a new transform.apply_conversion_patterns.func.func_to_llvm or whether we prefer
transform.apply_conversion_patterns.dialect_to_llvm "llvm" but in the meantime this allows progress.

[nicolasvasilache]

Fix Typo

mlir/include/mlir/Dialect/Func/CMakeLists.txt

 add_subdirectory(IR)
 add_subdirectory(Transforms)
+add_subdirectory(TransformOps)

mlir/include/mlir/Dialect/Func/TransformOps/CMakeLists.txt

+set(LLVM_TARGET_DEFINITIONS FuncTransformOps.td)
+mlir_tablegen(FuncTransformOps.h.inc -gen-op-decls)
+mlir_tablegen(FuncTransformOps.cpp.inc -gen-op-defs)
+add_public_tablegen_target(MLIRFuncTransformOpsIncGen)
+
+add_mlir_doc(FuncTransformOps FuncTransformOps Dialects/ -gen-op-doc)

mlir/include/mlir/Dialect/Func/TransformOps/FuncTransformOps.h

+//===- FuncTransformOps.h - CF transformation ops --------*- 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_DIALECT_FUNC_TRANSFORMOPS_FUNCTRANSFORMOPS_H
+#define MLIR_DIALECT_FUNC_TRANSFORMOPS_FUNCTRANSFORMOPS_H
+
+#include "mlir/Bytecode/BytecodeOpInterface.h"
+#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
+#include "mlir/IR/OpImplementation.h"
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/Func/TransformOps/FuncTransformOps.h.inc"
+
+namespace mlir {
+class DialectRegistry;
+
+namespace func {
+void registerTransformDialectExtension(DialectRegistry &registry);
+} // namespace func
+} // namespace mlir
+
+#endif // MLIR_DIALECT_FUNC_TRANSFORMOPS_FUNCTRANSFORMOPS_H

mlir/include/mlir/Dialect/Func/TransformOps/FuncTransformOps.td

+//===- FuncTransformOps.td - CF transformation ops -*- 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 FUNC_TRANSFORM_OPS
+#define FUNC_TRANSFORM_OPS
+
+include "mlir/Dialect/Transform/IR/TransformDialect.td"
+include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
+include "mlir/Dialect/Transform/IR/TransformTypes.td"
+include "mlir/IR/OpBase.td"
+
+def ApplyFuncToLLVMConversionPatternsOp : Op<Transform_Dialect,
+    "apply_conversion_patterns.func.func_to_llvm",
+    [DeclareOpInterfaceMethods<ConversionPatternDescriptorOpInterface,
+                               ["verifyTypeConverter"]>]> {
+  let description = [{
+    Collects patterns that convert Func dialect ops to LLVM dialect ops.
+    These patterns require an "LLVMTypeConverter".
+  }];
+
+  let assemblyFormat = "attr-dict";
+}
+
+#endif // FUNC_TRANSFORM_OPS

mlir/include/mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.td

let description = [{
     - `use_aligned_alloc`: Use aligned_alloc in place of malloc for heap
       allocations.
     - `index_bitwidth`: Bitwidth of the index type, "0" indicates the size of a
       machine word.
     - `use_generic_functions`: Use generic allocation and deallocation functions
       instead of the classic "malloc", "aligned_alloc" and "free" functions.
     - `use_opaque_pointers`: Generate LLVM IR using opaque pointers instead of
       typed pointers.
+    // TODO: the following two options don't really make sense for 
+    // memref_to_llvm_type_converter specifically.
+    // We should have a single to_llvm_type_converter.
+    - `use_bare_ptr_call_conv`: Replace FuncOp's MemRef arguments with bare 
+      pointers to the MemRef element types.
+    - `data-layout`: String description (LLVM format) of the data layout that is
+      expected on the produced module.
   }];
 
   let arguments = (ins
-      DefaultValuedAttr<BoolAttr, "false">:$use_aligned_alloc,
-      DefaultValuedAttr<I64Attr, "0">:$index_bitwidth,
-      DefaultValuedAttr<BoolAttr, "false">:$use_generic_functions,
-      DefaultValuedAttr<BoolAttr, "false">:$use_opaque_pointers);
+      DefaultValuedOptionalAttr<BoolAttr, "false">:$use_aligned_alloc,
+      DefaultValuedOptionalAttr<I64Attr, "64">:$index_bitwidth,
+      DefaultValuedOptionalAttr<BoolAttr, "false">:$use_generic_functions,
+      DefaultValuedOptionalAttr<BoolAttr, "false">:$use_opaque_pointers,
+      DefaultValuedOptionalAttr<BoolAttr, "false">:$use_bare_ptr_call_conv,
+      OptionalAttr<StrAttr>:$data_layout);
   let assemblyFormat = "attr-dict";
 }
 
 def ApplyExpandOpsPatternsOp : Op<Transform_Dialect,
     "apply_patterns.memref.expand_ops",
     [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
     Collects patterns to rewrite ops within the memref dialect.

mlir/include/mlir/InitAllDialects.h

 #include "mlir/Dialect/Bufferization/IR/Bufferization.h"
 #include "mlir/Dialect/Bufferization/TransformOps/BufferizationTransformOps.h"
 #include "mlir/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h"
 #include "mlir/Dialect/DLTI/DLTI.h"
 #include "mlir/Dialect/EmitC/IR/EmitC.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/Func/TransformOps/FuncTransformOps.h"
 #include "mlir/Dialect/GPU/IR/GPUDialect.h"
 #include "mlir/Dialect/GPU/TransformOps/GPUTransformOps.h"
 #include "mlir/Dialect/IRDL/IR/IRDL.h"
 #include "mlir/Dialect/Index/IR/IndexDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
registry.insert<acc::OpenACCDialect,
                   ub::UBDialect,
                   vector::VectorDialect,
                   x86vector::X86VectorDialect>();
   // clang-format on
 
   // Register all dialect extensions.
   affine::registerTransformDialectExtension(registry);
   bufferization::registerTransformDialectExtension(registry);
+  func::registerTransformDialectExtension(registry);
   gpu::registerTransformDialectExtension(registry);
   linalg::registerTransformDialectExtension(registry);
   memref::registerTransformDialectExtension(registry);
   nvgpu::registerTransformDialectExtension(registry);
   scf::registerTransformDialectExtension(registry);
   sparse_tensor::registerTransformDialectExtension(registry);
   tensor::registerTransformDialectExtension(registry);
   transform::registerPDLExtension(registry);

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

 namespace {
 
 struct FuncOpConversionBase : public ConvertOpToLLVMPattern<func::FuncOp> {
 protected:
   using ConvertOpToLLVMPattern<func::FuncOp>::ConvertOpToLLVMPattern;
 
   // Convert input FuncOp to LLVMFuncOp by using the LLVMTypeConverter provided
   // to this legalization pattern.
-  LLVM::LLVMFuncOp
+  FailureOr<LLVM::LLVMFuncOp>
   convertFuncOpToLLVMFuncOp(func::FuncOp funcOp,
                             ConversionPatternRewriter &rewriter) const {
     // Convert the original function arguments. They are converted using the
     // LLVMTypeConverter provided to this legalization pattern.
     auto varargsAttr = funcOp->getAttrOfType<BoolAttr>(varargsAttrName);
     TypeConverter::SignatureConversion result(funcOp.getNumArguments());
     auto llvmType = getTypeConverter()->convertFunctionSignature(
         funcOp.getFunctionType(), varargsAttr && varargsAttr.getValue(),
         shouldUseBarePtrCallConv(funcOp, getTypeConverter()), result);
     if (!llvmType)
-      return nullptr;
+      return rewriter.notifyMatchFailure(funcOp, "signature conversion failed");
 
     // Propagate argument/result attributes to all converted arguments/result
     // obtained after converting a given original argument/result.
     SmallVector<NamedAttribute, 4> attributes;
     filterFuncAttributes(funcOp, /*filterArgAndResAttrs=*/true, attributes);
     if (ArrayAttr resAttrDicts = funcOp.getAllResultAttrs()) {
       assert(!resAttrDicts.empty() && "expected array to be non-empty");
       auto newResAttrDicts =
convertFuncOpToLLVMFuncOp(func::FuncOp funcOp,
 
     // Create an LLVM function, use external linkage by default until MLIR
     // functions have linkage.
     LLVM::Linkage linkage = LLVM::Linkage::External;
     if (funcOp->hasAttr(linkageAttrName)) {
       auto attr =
           dyn_cast<mlir::LLVM::LinkageAttr>(funcOp->getAttr(linkageAttrName));
       if (!attr) {
-        funcOp->emitError() << "Contains " << linkageAttrName
-                            << " attribute not of type LLVM::LinkageAttr";
-        return nullptr;
+        return rewriter.notifyMatchFailure(
+            funcOp, "Contains attribute not of type LLVM::LinkageAttr");
       }
       linkage = attr.getLinkage();
     }
 
     // Create a memory effect attribute corresponding to readnone.
     StringRef readnoneAttrName = LLVM::LLVMDialect::getReadnoneAttrName();
     LLVM::MemoryEffectsAttr memoryAttr = {};
     if (funcOp->hasAttr(readnoneAttrName)) {
       auto attr = funcOp->getAttrOfType<UnitAttr>(readnoneAttrName);
       if (!attr) {
-        funcOp->emitError() << "Contains " << readnoneAttrName
-                            << " attribute not of type UnitAttr";
-        return nullptr;
+        return rewriter.notifyMatchFailure(
+            funcOp, "Contains attribute not of type UnitAttr");
       }
       memoryAttr = LLVM::MemoryEffectsAttr::get(rewriter.getContext(),
                                                 {LLVM::ModRefInfo::NoModRef,
                                                  LLVM::ModRefInfo::NoModRef,
                                                  LLVM::ModRefInfo::NoModRef});
     }
     auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
         funcOp.getLoc(), funcOp.getName(), llvmType, linkage,
         /*dsoLocal=*/false, /*cconv=*/LLVM::CConv::C, /*comdat=*/nullptr,
         attributes);
     // If the memory attribute was created, add it to the function.
     if (memoryAttr)
       newFuncOp.setMemoryAttr(memoryAttr);
     rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                                 newFuncOp.end());
     if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), *typeConverter,
-                                           &result)))
-      return nullptr;
+                                           &result))) {
+      return rewriter.notifyMatchFailure(funcOp,
+                                         "retgion types conversion failed");
+    }
 
     return newFuncOp;
   }
 };
 
 /// FuncOp legalization pattern that converts MemRef arguments to pointers to
 /// MemRef descriptors (LLVM struct data types) containing all the MemRef type
 /// information.
 struct FuncOpConversion : public FuncOpConversionBase {
   FuncOpConversion(LLVMTypeConverter &converter)
       : FuncOpConversionBase(converter) {}
 
   LogicalResult
   matchAndRewrite(func::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter);
-    if (!newFuncOp)
-      return failure();
+    FailureOr<LLVM::LLVMFuncOp> newFuncOp =
+        convertFuncOpToLLVMFuncOp(funcOp, rewriter);
+    if (failed(newFuncOp))
+      return rewriter.notifyMatchFailure(funcOp, "Could not convert funcop");
 
     if (!shouldUseBarePtrCallConv(funcOp, this->getTypeConverter())) {
       if (funcOp->getAttrOfType<UnitAttr>(
               LLVM::LLVMDialect::getEmitCWrapperAttrName())) {
-        if (newFuncOp.isVarArg())
+        if (newFuncOp->isVarArg())
           return funcOp->emitError("C interface for variadic functions is not "
                                    "supported yet.");
 
-        if (newFuncOp.isExternal())
-          wrapExternalFunction(rewriter, funcOp.getLoc(), *getTypeConverter(),
-                               funcOp, newFuncOp);
+        if (newFuncOp->isExternal())
+          wrapExternalFunction(rewriter, funcOp->getLoc(), *getTypeConverter(),
+                               funcOp, *newFuncOp);
         else
-          wrapForExternalCallers(rewriter, funcOp.getLoc(), *getTypeConverter(),
-                                 funcOp, newFuncOp);
+          wrapForExternalCallers(rewriter, funcOp->getLoc(),
+                                 *getTypeConverter(), funcOp, *newFuncOp);
       }
     } else {
-      modifyFuncOpToUseBarePtrCallingConv(rewriter, funcOp.getLoc(),
-                                          *getTypeConverter(), newFuncOp,
+      modifyFuncOpToUseBarePtrCallingConv(rewriter, funcOp->getLoc(),
+                                          *getTypeConverter(), *newFuncOp,
                                           funcOp.getFunctionType().getInputs());
     }
 
     rewriter.eraseOp(funcOp);
     return success();
   }
 };
 

mlir/lib/Dialect/Func/CMakeLists.txt

 add_subdirectory(Extensions)
 add_subdirectory(IR)
 add_subdirectory(Transforms)
+add_subdirectory(TransformOps)

mlir/lib/Dialect/Func/TransformOps/CMakeLists.txt

+add_mlir_dialect_library(MLIRFuncTransformOps
+  FuncTransformOps.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Func/TransformOps
+
+  DEPENDS
+  MLIRFuncTransformOpsIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRFuncDialect
+  MLIRFuncToLLVM
+  MLIRIR
+  MLIRLLVMCommonConversion
+  MLIRLLVMDialect
+  MLIRTransformDialect
+)

mlir/lib/Dialect/Func/TransformOps/FuncTransformOps.cpp

+//===- FuncTransformOps.cpp - Implementation of CF transform ops ---===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Func/TransformOps/FuncTransformOps.h"
+
+#include "mlir/Conversion/FuncToLLVM/ConvertFuncToLLVM.h"
+#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/Transform/IR/TransformDialect.h"
+#include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
+#include "mlir/Dialect/Transform/IR/TransformOps.h"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// Apply...ConversionPatternsOp
+//===----------------------------------------------------------------------===//
+
+void transform::ApplyFuncToLLVMConversionPatternsOp::populatePatterns(
+    TypeConverter &typeConverter, RewritePatternSet &patterns) {
+  populateFuncToLLVMConversionPatterns(
+      static_cast<LLVMTypeConverter &>(typeConverter), patterns);
+}
+
+LogicalResult
+transform::ApplyFuncToLLVMConversionPatternsOp::verifyTypeConverter(
+    transform::TypeConverterBuilderOpInterface builder) {
+  if (builder.getTypeConverterType() != "LLVMTypeConverter")
+    return emitOpError("expected LLVMTypeConverter");
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
+// Transform op registration
+//===----------------------------------------------------------------------===//
+
+namespace {
+class FuncTransformDialectExtension
+    : public transform::TransformDialectExtension<
+          FuncTransformDialectExtension> {
+public:
+  using Base::Base;
+
+  void init() {
+    declareGeneratedDialect<LLVM::LLVMDialect>();
+
+    registerTransformOps<
+#define GET_OP_LIST
+#include "mlir/Dialect/Func/TransformOps/FuncTransformOps.cpp.inc"
+        >();
+  }
+};
+} // namespace
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/Func/TransformOps/FuncTransformOps.cpp.inc"
+
+void mlir::func::registerTransformDialectExtension(DialectRegistry &registry) {
+  registry.addExtensions<FuncTransformDialectExtension>();
+}

mlir/lib/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp

options.allocLowering =
       (getUseAlignedAlloc() ? LowerToLLVMOptions::AllocLowering::AlignedAlloc
                             : LowerToLLVMOptions::AllocLowering::Malloc);
   options.useGenericFunctions = getUseGenericFunctions();
   options.useOpaquePointers = getUseOpaquePointers();
 
   if (getIndexBitwidth() != kDeriveIndexBitwidthFromDataLayout)
     options.overrideIndexBitwidth(getIndexBitwidth());
 
+  // TODO: the following two options don't really make sense for
+  // memref_to_llvm_type_converter specifically but we should have a single
+  // to_llvm_type_converter.
+  if (getDataLayout().has_value())
+    options.dataLayout = llvm::DataLayout(getDataLayout().value());
+  options.useBarePtrCallConv = getUseBarePtrCallConv();
+
   return std::make_unique<LLVMTypeConverter>(getContext(), options);
 }
 
 StringRef transform::MemrefToLLVMTypeConverterOp::getTypeConverterType() {
   return "LLVMTypeConverter";
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Transform/IR/TransformOps.cpp

 //===- TransformOps.cpp - Transform dialect operations --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Transform/IR/TransformOps.h"
 
 #include "mlir/Conversion/ConvertToLLVM/ToLLVMInterface.h"
+#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Dialect/Transform/IR/MatchInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformAttrs.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformTypes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dominance.h"
DiagnosedSilenceableFailure transform::ApplyConversionPatternsOp::apply(
   // specified.
   std::unique_ptr<TypeConverter> defaultTypeConverter;
   transform::TypeConverterBuilderOpInterface typeConverterBuilder =
       getDefaultTypeConverter();
   if (typeConverterBuilder)
     defaultTypeConverter = typeConverterBuilder.getTypeConverter();
 
   // Configure conversion target.
-  ConversionTarget conversionTarget(*ctx);
+  ConversionTarget conversionTarget(*getContext());
   if (getLegalOps())
     for (Attribute attr : cast<ArrayAttr>(*getLegalOps()))
       conversionTarget.addLegalOp(
           OperationName(cast<StringAttr>(attr).getValue(), ctx));
   if (getIllegalOps())
     for (Attribute attr : cast<ArrayAttr>(*getIllegalOps()))
       conversionTarget.addIllegalOp(
           OperationName(cast<StringAttr>(attr).getValue(), ctx));

mlir/test/Conversion/FuncToLLVM/func-memref-return.mlir

 // RUN: mlir-opt -convert-func-to-llvm='use-opaque-pointers=1' -reconcile-unrealized-casts %s | FileCheck %s
-// RUN: mlir-opt -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1 use-opaque-pointers=1'  -split-input-file %s | FileCheck %s --check-prefix=BAREPTR
+
+// RUN: mlir-opt -convert-func-to-llvm='use-bare-ptr-memref-call-conv=1 use-opaque-pointers=1'  %s | FileCheck %s --check-prefix=BAREPTR
+
+// RUN: mlir-opt -test-transform-dialect-interpreter %s | FileCheck %s --check-prefix=BAREPTR
 
 // These tests were separated from func-memref.mlir because applying
 // -reconcile-unrealized-casts resulted in `llvm.extractvalue` ops getting
 // folded away.
 
 // CHECK-LABEL: func @check_static_return
 // CHECK-COUNT-2: !llvm.ptr
 // CHECK-COUNT-5: i64

 // BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64
 // BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr
   return %static : memref<32x18xf32>
 }
 
-// -----
-
 // CHECK-LABEL: func @check_static_return_with_offset
 // CHECK-COUNT-2: !llvm.ptr
 // CHECK-COUNT-5: i64
 // CHECK-SAME: -> !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-LABEL: func @check_static_return_with_offset
 // BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr) -> !llvm.ptr {
 func.func @check_static_return_with_offset(%static : memref<32x18xf32, strided<[22,1], offset: 7>>) -> memref<32x18xf32, strided<[22,1], offset: 7>> {
 // CHECK:  llvm.return %{{.*}} : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>

 // BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64
 // BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)>
 // BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr
   return %static : memref<32x18xf32, strided<[22,1], offset: 7>>
 }
 
-// -----
 
 // BAREPTR: llvm.func @foo(!llvm.ptr) -> !llvm.ptr
 func.func private @foo(memref<10xi8>) -> memref<20xi8>
 
 // BAREPTR-LABEL: func @check_memref_func_call
 // BAREPTR-SAME:    %[[in:.*]]: !llvm.ptr) -> !llvm.ptr
 func.func @check_memref_func_call(%in : memref<10xi8>) -> memref<20xi8> {
   // BAREPTR:         %[[inDesc:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0]
func.func @check_memref_func_call(%in : memref<10xi8>) -> memref<20xi8> {
   // BAREPTR-NEXT:    %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
   // BAREPTR-NEXT:    %[[outDesc:.*]] = llvm.insertvalue %[[c1]], %[[desc6]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>
   %res = call @foo(%in) : (memref<10xi8>) -> (memref<20xi8>)
   // BAREPTR-NEXT:    %[[res:.*]] = llvm.extractvalue %[[outDesc]][0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>
   // BAREPTR-NEXT:    llvm.return %[[res]] : !llvm.ptr
   return %res : memref<20xi8>
 }
 
-// -----
-
 // BAREPTR-LABEL: func @check_return(
 // BAREPTR-SAME: %{{.*}}: memref<?xi8>) -> memref<?xi8>
 func.func @check_return(%in : memref<?xi8>) -> memref<?xi8> {
   // BAREPTR: llvm.return {{.*}} : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>
   return %in : memref<?xi8>
 }
 
-// -----
-
 // BAREPTR-LABEL: func @unconvertible_multiresult
 // BAREPTR-SAME: %{{.*}}: memref<?xf32>, %{{.*}}: memref<?xf32>) -> (memref<?xf32>, memref<?xf32>)
 func.func @unconvertible_multiresult(%arg0: memref<?xf32> , %arg1: memref<?xf32>) -> (memref<?xf32>, memref<?xf32>) {
   return %arg0, %arg1 : memref<?xf32>, memref<?xf32>
 }
 
-// -----
 // BAREPTR-LABEL: func @unranked_memref(
 // BAREPTR-SAME: %{{.*}}: memref<*xi32>)
 func.func @unranked_memref(%arg0:memref<*xi32>) {
   // BAREPTR:      call @printMemrefI32(%arg{{.*}}) : (memref<*xi32>) -> ()
   // BAREPTR-NEXT: llvm.return
   call @printMemrefI32(%arg0) : (memref<*xi32>) -> ()
   return
 }
 func.func private @printMemrefI32(memref<*xi32>)
+
+transform.sequence failures(propagate) {
+^bb1(%toplevel_module: !transform.any_op):
+  %func = transform.structured.match ops{["func.func"]} in %toplevel_module
+    : (!transform.any_op) -> !transform.any_op
+  transform.apply_conversion_patterns to %func {
+    transform.apply_conversion_patterns.func.func_to_llvm
+  } with type_converter {
+    transform.apply_conversion_patterns.memref.memref_to_llvm_type_converter
+      {use_bare_ptr_call_conv = true, use_opaque_pointers = true}
+  } {
+    partial_conversion = true
+  } : !transform.any_op
+}

mlir/test/Conversion/FuncToLLVM/func-to-llvm.mlir

 // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-math-to-llvm,convert-arith-to-llvm),convert-func-to-llvm{use-opaque-pointers=1},reconcile-unrealized-casts)" %s -split-input-file | FileCheck %s
+
 // RUN: mlir-opt -pass-pipeline="builtin.module(func.func(convert-math-to-llvm,convert-arith-to-llvm{index-bitwidth=32}),convert-func-to-llvm{index-bitwidth=32 use-opaque-pointers=1},reconcile-unrealized-casts)" %s -split-input-file | FileCheck --check-prefix=CHECK32 %s
 
+// RUN: mlir-opt -test-transform-dialect-interpreter %s | FileCheck --check-prefix=CHECK32 %s
+
 // CHECK-LABEL: func @empty() {
 // CHECK-NEXT:  llvm.return
 // CHECK-NEXT: }
 func.func @empty() {
 ^bb0:
   return
 }
 
^bb1:
   return %2 : i32
 
 // CHECK-NEXT: ^bb2:
 ^bb2:
 // CHECK-NEXT:  llvm.br ^bb1
   cf.br ^bb1
 }
 
-// -----
-
 // CHECK-LABEL: func @ceilf(
 // CHECK-SAME: f32
 func.func @ceilf(%arg0 : f32) {
   // CHECK: llvm.intr.ceil(%arg0) : (f32) -> f32
   %0 = math.ceil %arg0 : f32
   func.return
 }
 
-// -----
-
 // CHECK-LABEL: func @floorf(
 // CHECK-SAME: f32
 func.func @floorf(%arg0 : f32) {
   // CHECK: llvm.intr.floor(%arg0) : (f32) -> f32
   %0 = math.floor %arg0 : f32
   func.return
 }
 
-// -----
-
 // Lowers `cf.assert` to a function call to `abort` if the assertion is violated.
 // CHECK: llvm.func @abort()
 // CHECK-LABEL: @assert_test_function
 // CHECK-SAME:  (%[[ARG:.*]]: i1)
 func.func @assert_test_function(%arg : i1) {
   // CHECK: llvm.cond_br %[[ARG]], ^[[CONTINUATION_BLOCK:.*]], ^[[FAILURE_BLOCK:.*]]
   // CHECK: ^[[CONTINUATION_BLOCK]]:
   // CHECK: llvm.return
   // CHECK: ^[[FAILURE_BLOCK]]:
   // CHECK: llvm.call @abort() : () -> ()
   // CHECK: llvm.unreachable
   cf.assert %arg, "Computer says no"
   return
 }
 
-// -----
-
 // This should not trigger an assertion by creating an LLVM::CallOp with a
 // nullptr result type.
 
 // CHECK-LABEL: @call_zero_result_func
 func.func @call_zero_result_func() {
   // CHECK: call @zero_result_func
   call @zero_result_func() : () -> ()
   return
 }
 func.func private @zero_result_func()
 
-// -----
-
 // CHECK-LABEL: func @fmaf(
 // CHECK-SAME: %[[ARG0:.*]]: f32
 // CHECK-SAME: %[[ARG1:.*]]: vector<4xf32>
 func.func @fmaf(%arg0: f32, %arg1: vector<4xf32>) {
   // CHECK: %[[S:.*]] = llvm.intr.fma(%[[ARG0]], %[[ARG0]], %[[ARG0]]) : (f32, f32, f32) -> f32
   %0 = math.fma %arg0, %arg0, %arg0 : f32
   // CHECK: %[[V:.*]] = llvm.intr.fma(%[[ARG1]], %[[ARG1]], %[[ARG1]]) : (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32>
   %1 = math.fma %arg1, %arg1, %arg1 : vector<4xf32>
   func.return
 }
 
-// -----
-
 // CHECK-LABEL: func @switchi8(
 func.func @switchi8(%arg0 : i8) -> i32 {
   cf.switch %arg0 : i8, [
     default: ^bb1,
     42: ^bb1,
     43: ^bb3
   ]
 ^bb1:

 // CHECK-NEXT:     ]
 // CHECK:   ^bb1:  // 2 preds: ^bb0, ^bb0
 // CHECK-NEXT:     %[[E0:.+]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK-NEXT:     llvm.return %[[E0]] : i32
 // CHECK:   ^bb2:  // pred: ^bb0
 // CHECK-NEXT:     %[[E1:.+]] = llvm.mlir.constant(42 : i32) : i32
 // CHECK-NEXT:     llvm.return %[[E1]] : i32
 // CHECK-NEXT:   }
+
+transform.sequence failures(propagate) {
+^bb1(%toplevel_module: !transform.any_op):
+  %func = transform.structured.match ops{["func.func"]} in %toplevel_module
+    : (!transform.any_op) -> !transform.any_op
+  transform.apply_conversion_patterns to %func {
+    transform.apply_conversion_patterns.dialect_to_llvm "math"
+    transform.apply_conversion_patterns.dialect_to_llvm "arith"
+    transform.apply_conversion_patterns.dialect_to_llvm "cf"
+    transform.apply_conversion_patterns.func.func_to_llvm
+  } with type_converter {
+    transform.apply_conversion_patterns.memref.memref_to_llvm_type_converter
+      {index_bitwidth = 32, use_opaque_pointers = true}
+  } {
+    legal_dialects = ["llvm"], 
+    partial_conversion
+  } : !transform.any_op
+}

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

cc_library(
     deps = [
         ":ControlFlowDialect",
         ":FuncDialect",
         ":IR",
         ":InferTypeOpInterface",
     ],
 )
 
+td_library(
+    name = "FuncTransformOpsTdFiles",
+    srcs = [
+        "include/mlir/Dialect/Func/TransformOps/FuncTransformOps.td",
+    ],
+    includes = ["include"],
+    deps = [
+        ":TransformDialectTdFiles",
+    ],
+)
+
+gentbl_cc_library(
+    name = "FuncTransformOpsIncGen",
+    strip_include_prefix = "include",
+    tbl_outs = [
+        (
+            ["-gen-op-decls"],
+            "include/mlir/Dialect/Func/TransformOps/FuncTransformOps.h.inc",
+        ),
+        (
+            ["-gen-op-defs"],
+            "include/mlir/Dialect/Func/TransformOps/FuncTransformOps.cpp.inc",
+        ),
+    ],
+    tblgen = ":mlir-tblgen",
+    td_file = "include/mlir/Dialect/Func/TransformOps/FuncTransformOps.td",
+    deps = [
+        ":FuncTransformOpsTdFiles",
+    ],
+)
+
+cc_library(
+    name = "FuncTransformOps",
+    srcs = [
+        "lib/Dialect/Func/TransformOps/FuncTransformOps.cpp",
+    ],
+    hdrs = [
+        "include/mlir/Dialect/Func/TransformOps/FuncTransformOps.h",
+    ],
+    includes = ["include"],
+    deps = [
+        ":FuncDialect",
+        ":FuncToLLVM",
+        ":FuncTransformOpsIncGen",
+        ":IR",
+        ":LLVMCommonConversion",
+        ":LLVMDialect",
+        ":TransformDialect",
+    ],
+)
+
 cc_library(
     name = "AllExtensions",
     hdrs = ["include/mlir/InitAllExtensions.h"],
     deps = [
         ":ArithToLLVM",
         ":ComplexToLLVM",
         ":ControlFlowToLLVM",
         ":FuncExtensions",