[MLIR][SPIRVToLLVM] Conversion for bitrverse and bitcount ops

[georgemitenkov]

Summary

Implemented conversion for spv.BitReverse and spv.BitCount. Since ODS generates builders in a different way for LLVM dialect intrinsics, I added attributes to build method in DirectConversionPattern class. The tests for these ops are in bitwise-ops-to-llvm.mlir.

[ftynse]

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

76

Should we rather preserve the attributes of the original operation, operation.getAttrs() ? I think it is good practice in general.

[georgemitenkov]

• [MLIR][SPIRVToLLVM] Preserved op attributes in Direct Conversion pattern

Included operation.getAttrs() instead of ArrayRef<NamedAttribute>() in order to preserve the attributes of ops.

[georgemitenkov]

• [MLIR][SPIRVToLLVM] Conversion for bitrverse and bitcount ops
• [MLIR][SPIRVToLLVM] Preserved op attributes in Direct Conversion pattern

Rebased against master to pick up other changes.

[antiagainst]

Hey @georgemitenkov, could you rebase this against master branch so I can land this? Thanks!

[georgemitenkov]

• [MLIR][SPIRVToLLVM] Conversion for bitrverse and bitcount ops
• [MLIR][SPIRVToLLVM] Preserved op attributes in Direct Conversion pattern

Rebased against master to add new changes.

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
-    rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType, operands);
+    rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType, operands,
+                                                 operation.getAttrs());
     return success();
   }
 };
 
 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {
patterns.insert<
       DirectConversionPattern<spirv::FRemOp, LLVM::FRemOp>,
       DirectConversionPattern<spirv::FSubOp, LLVM::FSubOp>,
       DirectConversionPattern<spirv::SDivOp, LLVM::SDivOp>,
       DirectConversionPattern<spirv::SRemOp, LLVM::SRemOp>,
       DirectConversionPattern<spirv::UDivOp, LLVM::UDivOp>,
       DirectConversionPattern<spirv::UModOp, LLVM::URemOp>,
 
       // Bitwise ops
+      DirectConversionPattern<spirv::BitCountOp, LLVM::CtPopOp>,
+      DirectConversionPattern<spirv::BitReverseOp, LLVM::BitReverseOp>,
       DirectConversionPattern<spirv::BitwiseAndOp, LLVM::AndOp>,
       DirectConversionPattern<spirv::BitwiseOrOp, LLVM::OrOp>,
       DirectConversionPattern<spirv::BitwiseXorOp, LLVM::XOrOp>,
 
       // Cast ops
       DirectConversionPattern<spirv::ConvertFToSOp, LLVM::FPToSIOp>,
       DirectConversionPattern<spirv::ConvertFToUOp, LLVM::FPToUIOp>,
       DirectConversionPattern<spirv::ConvertSToFOp, LLVM::SIToFPOp>,

mlir/test/Conversion/SPIRVToLLVM/bitwise-ops-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
+// spv.BitCount
+//===----------------------------------------------------------------------===//
+
+func @bitcount_scalar(%arg0: i16) {
+  // CHECK: %{{.*}} = "llvm.intr.ctpop"(%{{.*}}) : (!llvm.i16) -> !llvm.i16
+  %0 = spv.BitCount %arg0: i16
+  return
+}
+
+func @bitcount_vector(%arg0: vector<3xi32>) {
+  // CHECK: %{{.*}} = "llvm.intr.ctpop"(%{{.*}}) : (!llvm<"<3 x i32>">) -> !llvm<"<3 x i32>">
+  %0 = spv.BitCount %arg0: vector<3xi32>
+  return
+}
+
+//===----------------------------------------------------------------------===//
+// spv.BitReverse
+//===----------------------------------------------------------------------===//
+
+func @bitreverse_scalar(%arg0: i64) {
+  // CHECK: %{{.*}} = "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.i64) -> !llvm.i64
+  %0 = spv.BitReverse %arg0: i64
+  return
+}
+
+func @bitreverse_vector(%arg0: vector<4xi32>) {
+  // CHECK: %{{.*}} = "llvm.intr.bitreverse"(%{{.*}}) : (!llvm<"<4 x i32>">) -> !llvm<"<4 x i32>">
+  %0 = spv.BitReverse %arg0: vector<4xi32>
+  return
+}
+
+//===----------------------------------------------------------------------===//
 // spv.BitwiseAnd
 //===----------------------------------------------------------------------===//
 
 func @bitwise_and_scalar(%arg0: i32, %arg1: i32) {
   // CHECK: %{{.*}} = llvm.and %{{.*}}, %{{.*}} : !llvm.i32
   %0 = spv.BitwiseAnd %arg0, %arg1 : i32
   return
 }