[mlir][vector][transform] Add vector_to_llvm conversion patterns

[springerm]

rebase

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

 #define MEMREF_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/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpBase.td"
 
+def MemrefToLLVMTypeConverterOp : Op<Transform_Dialect,
+    "apply_conversion_patterns.memref.memref_to_llvm_type_converter",
+    [DeclareOpInterfaceMethods<TypeConverterBuilderOpInterface,
+                               ["getTypeConverterType"]>]> {
+  let description = [{
+    This operation provides an "LLVMTypeConverter" that lowers memref types to
+    LLVM types.
+
+    The type converter can be customized as follows:
+    - `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.
+  }];
+
+  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);
+  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.
 
     - Converts `atomic_rmw` that cannot be lowered to a simple atomic op with
       AtomicRMWOpLowering pattern, e.g. with "minf" or "maxf" attributes, to

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td

InterfaceMethod<
       }],
       /*returnType=*/"void",
       /*name=*/"populatePatterns",
       /*arguments=*/(ins "::mlir::RewritePatternSet &":$patterns)
     >,
   ];
 }
 
+def TypeConverterBuilderOpInterface
+    : OpInterface<"TypeConverterBuilderOpInterface"> {
+  let description = [{
+    This interface should be implemented by ops that specify a type converter
+    for a dialect conversion. Such ops can be used with
+    "apply_conversion_patterns".
+  }];
+
+  let cppNamespace = "::mlir::transform";
+
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{
+        Return the type converter to be used with a dialect conversion.
+      }],
+      /*returnType=*/"std::unique_ptr<::mlir::TypeConverter>",
+      /*name=*/"getTypeConverter",
+      /*arguments=*/(ins)
+    >,
+    StaticInterfaceMethod<
+      /*desc=*/[{
+        Return the type of type converter that this `getTypeConverter` returns.
+        This function is used for op verification.
+      }],
+      /*returnType=*/"StringRef",
+      /*name=*/"getTypeConverterType",
+      /*arguments=*/(ins),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{ return "TypeConverter"; }]
+    >,
+  ];
+}
+
 def ConversionPatternDescriptorOpInterface
     : OpInterface<"ConversionPatternDescriptorOpInterface"> {
   let description = [{
     This interface should be implemented by ops that select conversion patterns
     of a `transform.apply_patterns` op. It provides a method to populate a
     rewrite pattern set with conversion patterns.
 
     Note: Non-conversion rewrite patterns should not be populated with
InterfaceMethod<
         "apply_conversion_patterns" op is used.
       }],
       /*returnType=*/"std::unique_ptr<::mlir::TypeConverter>",
       /*name=*/"getTypeConverter",
       /*arguments=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/"return nullptr;"
     >,
-  ];
-}
-
-def TypeConverterBuilderOpInterface
-    : OpInterface<"TypeConverterBuilderOpInterface"> {
-  let description = [{
-    This interface should be implemented by ops that specify a type converter
-    for a dialect conversion. Such ops can be used with
-    "apply_conversion_patterns".
-  }];
-
-  let cppNamespace = "::mlir::transform";
-
-  let methods = [
     InterfaceMethod<
       /*desc=*/[{
-        Return the type converter to be used with a dialect conversion.
+        Verify the default type converter that is provided by the enclosing
+        "apply_conversion_patterns" op.
       }],
-      /*returnType=*/"std::unique_ptr<::mlir::TypeConverter>",
-      /*name=*/"getTypeConverter",
-      /*arguments=*/(ins)
+      /*returnType=*/"::mlir::LogicalResult",
+      /*name=*/"verifyTypeConverter",
+      /*arguments=*/(ins "TypeConverterBuilderOpInterface":$builder),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/"return success();"
     >,
   ];
 }
 
 #endif // MLIR_DIALECT_TRANSFORM_IR_TRANSFORM_INTERFACES_TD

mlir/include/mlir/Dialect/Vector/TransformOps/VectorTransformOps.td

 #define VECTOR_TRANSFORM_OPS
 
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 include "mlir/Dialect/Vector/Transforms/VectorTransformsBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpBase.td"
 
+def ApplyVectorToLLVMConversionPatternsOp : Op<Transform_Dialect,
+    "apply_conversion_patterns.vector.vector_to_llvm",
+    [DeclareOpInterfaceMethods<ConversionPatternDescriptorOpInterface,
+                               ["verifyTypeConverter"]>]> {
+  let description = [{
+    Collects patterns that convert vector dialect ops to LLVM dialect ops. These
+    patterns require an "LLVMTypeConverter".
+
+    The patterns can be customized as follows:
+    - `reassociate_fp_reductions`: Allows LLVM to reassociate floating-point
+      reductions for speed.
+    - `force_32bit_vector_indices`: Allows the compiler to assume that vector
+      indices fit in 32-bit if that yields faster code.
+  }];
+
+  let arguments = (ins
+      DefaultValuedAttr<BoolAttr, "false">:$reassociate_fp_reductions,
+      DefaultValuedAttr<BoolAttr, "true">:$force_32bit_vector_indices);
+  let assemblyFormat = "attr-dict";
+}
+
+
 def ApplyCastAwayVectorLeadingOneDimPatternsOp : Op<Transform_Dialect,
     "apply_patterns.vector.cast_away_vector_leading_one_dim",
     [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
     Collect a set of leading one dimension removal patterns.
 
     These patterns insert vector.shape_cast to remove leading one dimensions
     to expose more canonical forms of read/write/insert/extract operations.

mlir/include/mlir/Transforms/DialectConversion.h

 //===----------------------------------------------------------------------===//
 // Type Conversion
 //===----------------------------------------------------------------------===//
 
 /// Type conversion class. Specific conversions and materializations can be
 /// registered using addConversion and addMaterialization, respectively.
 class TypeConverter {
 public:
+  virtual ~TypeConverter() = default;
+
   /// This class provides all of the information necessary to convert a type
   /// signature.
   class SignatureConversion {
   public:
     SignatureConversion(unsigned numOrigInputs)
         : remappedInputs(numOrigInputs) {}
 
     /// This struct represents a range of new types or a single value that

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

 add_mlir_dialect_library(MLIRMemRefTransformOps
   MemRefTransformOps.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/MemRef/TransformOps
 
   DEPENDS
   MLIRMemRefTransformOpsIncGen
 
   LINK_LIBS PUBLIC
   MLIRAffineDialect
   MLIRArithDialect
   MLIRIR
+  MLIRLLVMCommonConversion
+  MLIRLLVMDialect
   MLIRLoopLikeInterface
   MLIRMemRefDialect
   MLIRMemRefTransforms
   MLIRNVGPUDialect
   MLIRTransformDialect
   MLIRVectorDialect
 )

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

 //===- MemRefTransformOps.cpp - Implementation of Memref 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/MemRef/TransformOps/MemRefTransformOps.h"
+
+#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/MemRef/Transforms/Passes.h"
 #include "mlir/Dialect/MemRef/Transforms/Transforms.h"
 #include "mlir/Dialect/NVGPU/IR/NVGPUDialect.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "memref-transforms"
 #define DBGS() (llvm::dbgs() << '[' << DEBUG_TYPE << "] ")
 
 //===----------------------------------------------------------------------===//
+// Apply...ConversionPatternsOp
+//===----------------------------------------------------------------------===//
+
+std::unique_ptr<TypeConverter>
+transform::MemrefToLLVMTypeConverterOp::getTypeConverter() {
+  LowerToLLVMOptions options(getContext());
+  options.allocLowering =
+      (getUseAlignedAlloc() ? LowerToLLVMOptions::AllocLowering::AlignedAlloc
+                            : LowerToLLVMOptions::AllocLowering::Malloc);
+  options.useGenericFunctions = getUseGenericFunctions();
+  options.useOpaquePointers = getUseOpaquePointers();
+
+  if (getIndexBitwidth() != kDeriveIndexBitwidthFromDataLayout)
+    options.overrideIndexBitwidth(getIndexBitwidth());
+
+  return std::make_unique<LLVMTypeConverter>(getContext(), options);
+}
+
+StringRef transform::MemrefToLLVMTypeConverterOp::getTypeConverterType() {
+  return "LLVMTypeConverter";
+}
+
+//===----------------------------------------------------------------------===//
 // Apply...PatternsOp
 //===----------------------------------------------------------------------===//
 
 void transform::ApplyExpandOpsPatternsOp::populatePatterns(
     RewritePatternSet &patterns) {
   memref::populateExpandOpsPatterns(patterns);
 }
 

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

for (Operation &op : getPatterns().front()) {
       }
     }
   }
   if (getNumRegions() == 2) {
     Region &typeConverterRegion = getRegion(1);
     if (!llvm::hasSingleElement(typeConverterRegion.front()))
       return emitOpError()
              << "expected exactly one op in default type converter region";
-    Operation *typeConverterOp = &typeConverterRegion.front().front();
-    if (!isa<transform::TypeConverterBuilderOpInterface>(typeConverterOp)) {
+    auto typeConverterOp = dyn_cast<transform::TypeConverterBuilderOpInterface>(
+        &typeConverterRegion.front().front());
+    if (!typeConverterOp) {
       InFlightDiagnostic diag = emitOpError()
                                 << "expected default converter child op to "
                                    "implement TypeConverterBuilderOpInterface";
       diag.attachNote(typeConverterOp->getLoc()) << "op without interface";
       return diag;
     }
+    // Check default type converter type.
+    if (!getPatterns().empty()) {
+      for (Operation &op : getPatterns().front()) {
+        auto descriptor =
+            cast<transform::ConversionPatternDescriptorOpInterface>(&op);
+        if (failed(descriptor.verifyTypeConverter(typeConverterOp)))
+          return failure();
+      }
+    }
   }
   if (!getLegalOps() && !getIllegalOps() && !getLegalDialects() &&
       !getIllegalDialects())
     return emitOpError() << "conversion target is not specified";
   return success();
 }
 
 void transform::ApplyConversionPatternsOp::getEffects(

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

 add_mlir_dialect_library(MLIRVectorTransformOps
   VectorTransformOps.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/TransformOps
 
   DEPENDS
   MLIRVectorTransformOpsIncGen
 
   LINK_LIBS PUBLIC
   MLIRIR
+  MLIRLLVMCommonConversion
+  MLIRLLVMDialect
   MLIRVectorDialect
+  MLIRVectorToLLVM
   MLIRVectorTransforms
   MLIRSideEffectInterfaces
   MLIRTransformDialect
   MLIRVectorDialect
   MLIRVectorToSCF
   MLIRX86VectorTransforms
   )

mlir/lib/Dialect/Vector/TransformOps/VectorTransformOps.cpp

 //===- VectorTransformOps.cpp - Implementation of Vector 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/Vector/TransformOps/VectorTransformOps.h"
+
+#include "mlir/Conversion/LLVMCommon/TypeConverter.h"
+#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/VectorToSCF/VectorToSCF.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"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 #include "mlir/Dialect/Vector/Transforms/LoweringPatterns.h"
 #include "mlir/Dialect/Vector/Transforms/VectorRewritePatterns.h"
 #include "mlir/Dialect/Vector/Transforms/VectorTransforms.h"
 #include "mlir/Dialect/X86Vector/Transforms.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 using namespace mlir::vector;
 using namespace mlir::transform;
 
 //===----------------------------------------------------------------------===//
+// Apply...ConversionPatternsOp
+//===----------------------------------------------------------------------===//
+
+void transform::ApplyVectorToLLVMConversionPatternsOp::populatePatterns(
+    TypeConverter &typeConverter, RewritePatternSet &patterns) {
+  populateVectorToLLVMConversionPatterns(
+      static_cast<LLVMTypeConverter &>(typeConverter), patterns,
+      getReassociateFpReductions(), getForce_32bitVectorIndices());
+}
+
+LogicalResult
+transform::ApplyVectorToLLVMConversionPatternsOp::verifyTypeConverter(
+    transform::TypeConverterBuilderOpInterface builder) {
+  if (builder.getTypeConverterType() != "LLVMTypeConverter")
+    return emitOpError("expected LLVMTypeConverter");
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // Apply...PatternsOp
 //===----------------------------------------------------------------------===//
 
 void transform::ApplyCastAwayVectorLeadingOneDimPatternsOp::populatePatterns(
     RewritePatternSet &patterns) {
   vector::populateCastAwayVectorLeadingOneDimPatterns(patterns);
 }
 

mlir/test/Dialect/Vector/transform-op-vector-to-llvm.mlir

+// RUN: mlir-opt %s -test-transform-dialect-interpreter -verify-diagnostics -allow-unregistered-dialect -split-input-file | FileCheck %s
+
+// CHECK-LABEL: func @lower_to_llvm
+//   CHECK-NOT:   vector.bitcast
+//       CHECK:   llvm.bitcast
+func.func @lower_to_llvm(%input: vector<f32>) -> vector<i32> {
+  %0 = vector.bitcast %input : vector<f32> to vector<i32>
+  return %0 : vector<i32>
+}
+
+transform.sequence failures(propagate) {
+^bb1(%arg1: !transform.any_op):
+  %0 = transform.structured.match ops{["func.func"]} in %arg1 : (!transform.any_op) -> !transform.any_op
+  transform.apply_conversion_patterns to %0 {
+    transform.apply_conversion_patterns.vector.vector_to_llvm
+  } with type_converter {
+    transform.apply_conversion_patterns.memref.memref_to_llvm_type_converter
+  } {legal_dialects = ["func", "llvm"]} : !transform.any_op
+}

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

hdrs = [
         "include/mlir/Dialect/Vector/TransformOps/VectorTransformOps.h",
     ],
     includes = ["include"],
     deps = [
         ":AffineDialect",
         ":ArithDialect",
         ":AsmParser",
         ":IR",
+        ":LLVMCommonConversion",
         ":LLVMDialect",
         ":SideEffectInterfaces",
         ":TransformDialect",
         ":TransformUtils",
         ":VectorDialect",
         ":VectorEnumsIncGen",
+        ":VectorToLLVM",
         ":VectorToSCF",
         ":VectorTransformOpsIncGen",
         ":VectorTransforms",
         ":X86VectorTransforms",
         "//llvm:Support",
     ],
 )
 
cc_library(
     name = "MemRefTransformOps",
     srcs = glob(["lib/Dialect/MemRef/TransformOps/*.cpp"]),
     hdrs = glob(["include/mlir/Dialect/MemRef/TransformOps/*.h"]),
     includes = ["include"],
     deps = [
         ":AffineDialect",
         ":ArithDialect",
         ":IR",
+        ":LLVMCommonConversion",
         ":LoopLikeInterface",
         ":MemRefDialect",
         ":MemRefTransformOpsIncGen",
         ":MemRefTransforms",
         ":NVGPUDialect",
         ":SCFDialect",
         ":TransformDialect",
         ":TransformUtils",