[mlir] Add std.bitcast -> llvm.bitcast conversion

[ftynse]

Summary

The conversion is a straightforward one-to-one mapping with optional unrolling
for nD vectors, similarly to other cast operations.

Depends On D107889

[akuegel]

Thanks :)

[silvas]

Thanks Alex!

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

struct BarePtrFuncOpConversion : public FuncOpConversionBase {
   }
 };
 
 // Straightforward lowerings.
 using AbsFOpLowering = VectorConvertToLLVMPattern<AbsFOp, LLVM::FAbsOp>;
 using AddFOpLowering = VectorConvertToLLVMPattern<AddFOp, LLVM::FAddOp>;
 using AddIOpLowering = VectorConvertToLLVMPattern<AddIOp, LLVM::AddOp>;
 using AndOpLowering = VectorConvertToLLVMPattern<AndOp, LLVM::AndOp>;
+using BitcastOpLowering =
+    VectorConvertToLLVMPattern<BitcastOp, LLVM::BitcastOp>;
 using CeilFOpLowering = VectorConvertToLLVMPattern<CeilFOp, LLVM::FCeilOp>;
 using CopySignOpLowering =
     VectorConvertToLLVMPattern<CopySignOp, LLVM::CopySignOp>;
 using DivFOpLowering = VectorConvertToLLVMPattern<DivFOp, LLVM::FDivOp>;
 using FPExtOpLowering = VectorConvertToLLVMPattern<FPExtOp, LLVM::FPExtOp>;
 using FPToSIOpLowering = VectorConvertToLLVMPattern<FPToSIOp, LLVM::FPToSIOp>;
 using FPToUIOpLowering = VectorConvertToLLVMPattern<FPToUIOp, LLVM::FPToUIOp>;
 using FPTruncOpLowering =
void mlir::populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter,
   // clang-format off
   patterns.add<
       AbsFOpLowering,
       AddFOpLowering,
       AddIOpLowering,
       AndOpLowering,
       AssertOpLowering,
       AtomicRMWOpLowering,
+      BitcastOpLowering,
       BranchOpLowering,
       CallIndirectOpLowering,
       CallOpLowering,
       CeilFOpLowering,
       CmpFOpLowering,
       CmpIOpLowering,
       CondBranchOpLowering,
       CopySignOpLowering,

mlir/test/Conversion/StandardToLLVM/convert-nd-vector-to-llvmir.mlir

func @shru_vector(%arg0 : vector<1x2x3xi64>) -> vector<1x2x3xi64> {
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 0] : !llvm.array<1 x array<2 x vector<3xi64>>>
   // CHECK: llvm.extractvalue %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
   // CHECK: llvm.lshr %{{.*}}, %{{.*}} : vector<3xi64>
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0, 1] : !llvm.array<1 x array<2 x vector<3xi64>>>
   %c1 = constant dense<1> : vector<1x2x3xi64>
   %0 = shift_right_unsigned %arg0, %c1 : vector<1x2x3xi64>
   return %0 : vector<1x2x3xi64>
 }
+
+// -----
+
+// CHECK-LABEL: @bitcast_2d
+func @bitcast_2d(%arg0: vector<2x4xf32>) {
+  // CHECK: llvm.mlir.undef
+  // CHECK: llvm.extractvalue %{{.*}}[0]
+  // CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32>
+  // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[0]
+  // CHECK: llvm.extractvalue %{{.*}}[1]
+  // CHECK: llvm.bitcast %{{.*}} : vector<4xf32> to vector<4xi32>
+  // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1]
+  std.bitcast %arg0 : vector<2x4xf32> to vector<2x4xi32>
+  return
+}

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

func @index_vector(%arg0: vector<4xindex>) {
   %0 = constant dense<[0, 1, 2, 3]> : vector<4xindex>
   // CHECK: %[[V:.*]] = llvm.add %[[ARG0]], %[[CST]] : vector<4xi64>
   %1 = addi %arg0, %0 : vector<4xindex>
   std.return
 }
 
 // -----
 
+// CHECK-LABEL: @bitcast_1d
+func @bitcast_1d(%arg0: vector<2xf32>) {
+  // CHECK: llvm.bitcast %{{.*}} : vector<2xf32> to vector<2xi32>
+  std.bitcast %arg0 : vector<2xf32> to vector<2xi32>
+  return
+}
+
+// -----
+
 // CHECK-LABEL: func @cmpf_2dvector(
 func @cmpf_2dvector(%arg0 : vector<4x3xf32>, %arg1 : vector<4x3xf32>) {
   // CHECK: %[[EXTRACT1:.*]] = llvm.extractvalue %arg0[0] : !llvm.array<4 x vector<3xf32>>
   // CHECK: %[[EXTRACT2:.*]] = llvm.extractvalue %arg1[0] : !llvm.array<4 x vector<3xf32>>
   // CHECK: %[[CMP:.*]] = llvm.fcmp "olt" %[[EXTRACT1]], %[[EXTRACT2]] : vector<3xf32>
   // CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[CMP]], %0[0] : !llvm.array<4 x vector<3xi1>>
   %0 = cmpf olt, %arg0, %arg1 : vector<4x3xf32>
   std.return