[mlir][vector] Add more tests for ConvertVectorToLLVM (7/n)#111895
Merged
banach-space merged 2 commits intollvm:mainfrom Oct 11, 2024
Merged
[mlir][vector] Add more tests for ConvertVectorToLLVM (7/n)#111895banach-space merged 2 commits intollvm:mainfrom
banach-space merged 2 commits intollvm:mainfrom
Conversation
Adds tests with scalable vectors for the Vector-To-LLVM conversion pass. Covers the following Ops: * vector.fma * vector.reduce
banach-space
requested review from
dcaballe and
nicolasvasilache
as code owners
Member
|
@llvm/pr-subscribers-mlir Author: Andrzej Warzyński (banach-space) ChangesAdds tests with scalable vectors for the Vector-To-LLVM conversion pass.
Patch is 22.21 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/111895.diff 1 Files Affected:
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
index ae1d6fe8bd1672..c7e76ea9a5bbc9 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
@@ -2001,6 +2001,37 @@ func.func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>, %c: vector<1x1x1xf
return %0, %1, %2, %3: vector<8xf32>, vector<2x4xf32>, vector<1x1x1xf32>, vector<f32>
}
+func.func @vector_fma_scalable(%a: vector<[8]xf32>, %b: vector<2x[4]xf32>, %c: vector<1x1x[1]xf32>, %d: vector<f32>) -> (vector<[8]xf32>, vector<2x[4]xf32>, vector<1x1x[1]xf32>) {
+ // CHECK-LABEL: @vector_fma
+ // CHECK-SAME: %[[A:.*]]: vector<[8]xf32>
+ // CHECK-SAME: %[[B:.*]]: vector<2x[4]xf32>
+ // CHECK-SAME: %[[C:.*]]: vector<1x1x[1]xf32>
+ // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x[4]xf32> to !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: llvm.intr.fmuladd
+ // CHECK-SAME: (vector<[8]xf32>, vector<[8]xf32>, vector<[8]xf32>) -> vector<[8]xf32>
+ %0 = vector.fma %a, %a, %a : vector<[8]xf32>
+
+ // CHECK: %[[b00:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b01:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b02:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[B0:.*]] = llvm.intr.fmuladd(%[[b00]], %[[b01]], %[[b02]]) :
+ // CHECK-SAME: (vector<[4]xf32>, vector<[4]xf32>, vector<[4]xf32>) -> vector<[4]xf32>
+ // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b10:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b11:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b12:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[B1:.*]] = llvm.intr.fmuladd(%[[b10]], %[[b11]], %[[b12]]) :
+ // CHECK-SAME: (vector<[4]xf32>, vector<[4]xf32>, vector<[4]xf32>) -> vector<[4]xf32>
+ // CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm.array<2 x vector<[4]xf32>>
+ %1 = vector.fma %b, %b, %b : vector<2x[4]xf32>
+
+ // CHECK: %[[C0:.*]] = llvm.intr.fmuladd
+ // CHECK-SAME: (vector<[1]xf32>, vector<[1]xf32>, vector<[1]xf32>) -> vector<[1]xf32>
+ %2 = vector.fma %c, %c, %c : vector<1x1x[1]xf32>
+
+ return %0, %1, %2: vector<[8]xf32>, vector<2x[4]xf32>, vector<1x1x[1]xf32>
+}
+
// -----
func.func @reduce_0d_f32(%arg0: vector<f32>) -> f32 {
@@ -2028,6 +2059,17 @@ func.func @reduce_f16(%arg0: vector<16xf16>) -> f16 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<16xf16>) -> f16
// CHECK: return %[[V]] : f16
+func.func @reduce_f16_scalable(%arg0: vector<[16]xf16>) -> f16 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf16> into f16
+ return %0 : f16
+}
+// CHECK-LABEL: @reduce_f16_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf16>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<[16]xf16>) -> f16
+// CHECK: return %[[V]] : f16
+
// -----
func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
@@ -2041,6 +2083,17 @@ func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
+func.func @reduce_f32_scalable(%arg0: vector<[16]xf32>) -> f32 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<[16]xf32>) -> f32
+// CHECK: return %[[V]] : f32
+
// -----
func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
@@ -2054,6 +2107,17 @@ func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<16xf64>) -> f64
// CHECK: return %[[V]] : f64
+func.func @reduce_f64_scalable(%arg0: vector<[16]xf64>) -> f64 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf64> into f64
+ return %0 : f64
+}
+// CHECK-LABEL: @reduce_f64_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf64>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<[16]xf64>) -> f64
+// CHECK: return %[[V]] : f64
+
// -----
func.func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
@@ -2065,6 +2129,15 @@ func.func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: return %[[V]] : i8
+func.func @reduce_i8_scalable(%arg0: vector<[16]xi8>) -> i8 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xi8> into i8
+ return %0 : i8
+}
+// CHECK-LABEL: @reduce_i8_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi8>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: return %[[V]] : i8
+
// -----
func.func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2076,6 +2149,15 @@ func.func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2088,6 +2170,16 @@ func.func @reduce_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <add>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_mul_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2099,6 +2191,15 @@ func.func @reduce_mul_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_mul_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <mul>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_mul_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2111,6 +2212,16 @@ func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_mul_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <mul>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_mul_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2123,6 +2234,16 @@ func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmaximum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <maximumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmaximum_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmaximum(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2135,6 +2256,16 @@ func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fminimum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <minimumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fminimum_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fminimum(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2147,6 +2278,16 @@ func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmax_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <maxnumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmax_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmax(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2159,6 +2300,16 @@ func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmin_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <minnumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmin_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmin(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_minui_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2170,6 +2321,15 @@ func.func @reduce_minui_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_minui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <minui>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minui_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2183,6 +2343,17 @@ func.func @reduce_minui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_minui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <minui>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minui_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "ule" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxui_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2194,6 +2365,15 @@ func.func @reduce_maxui_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_maxui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <maxui>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxui_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2207,6 +2387,17 @@ func.func @reduce_maxui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_maxui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <maxui>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxui_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "uge" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minsi_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2218,6 +2409,15 @@ func.func @reduce_minsi_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_minsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <minsi>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minsi_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2231,6 +2431,17 @@ func.func @reduce_minsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_minsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <minsi>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minsi_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "sle" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxsi_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2242,6 +2453,15 @@ func.func @reduce_maxsi_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_maxsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <maxsi>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxsi_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2255,6 +2475,17 @@ func.func @reduce_maxsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_maxsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <maxsi>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxsi_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "sge" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_and_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2266,6 +2497,15 @@ func.func @reduce_and_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_and_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <and>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_and_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_and_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2278,6 +2518,16 @@ func.func @reduce_and_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_and_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <and>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_and_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_or_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2289,6 +2539,15 @@ func.func @reduce_or_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_or_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <or>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_or_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_or_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2301,6 +2560,16 @@ func.func @reduce_or_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_or_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <or>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_or_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_xor_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2312,6 +2581,15 @@ func.func @reduce_xor_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_xor_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <xor>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_xor_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])
+// CHECK: return %[[V]...
[truncated]
|
nujaa
reviewed
Oct 11, 2024
Contributor
nujaa
left a comment
nujaa
left a comment
There was a problem hiding this comment.
Hello, LGTM notwithstanding this minor oversight.
| } | ||
|
|
||
| func.func @vector_fma_scalable(%a: vector<[8]xf32>, %b: vector<2x[4]xf32>, %c: vector<1x1x[1]xf32>, %d: vector<f32>) -> (vector<[8]xf32>, vector<2x[4]xf32>, vector<1x1x[1]xf32>) { | ||
| // CHECK-LABEL: @vector_fma |
Contributor
There was a problem hiding this comment.
Suggested change
| // CHECK-LABEL: @vector_fma | |
| // CHECK-LABEL: @vector_fma_scalable |
Contributor
Author
There was a problem hiding this comment.
Great catch, thanks! That's now fixed.
ichaer
added a commit
to splunk/ichaer-llvm-project
that referenced
this pull request
Oct 11, 2024
…ent-indentonly * llvm-trunk/main: (6379 commits) [gn build] Port 1c94388 [RISCV] Introduce VLOptimizer pass (llvm#108640) [mlir][vector] Add more tests for ConvertVectorToLLVM (7/n) (llvm#111895) [libc++] Add output groups to run-buildbot (llvm#111739) [libc++abi] Remove unused LIBCXXABI_LIBCXX_INCLUDES CMake option (llvm#111824) [clang] Ignore inline namespace for `hasName` (llvm#109147) [AArch64] Disable consecutive store merging when Neon is unavailable (llvm#111519) [lldb] Fix finding make tool for tests (llvm#111980) Turn `-Wdeprecated-literal-operator` on by default (llvm#111027) [AMDGPU] Rewrite RegSeqNames using !foreach. NFC. (llvm#111994) Revert "Reland: [clang] Finish implementation of P0522 (llvm#111711)" Revert "[clang] CWG2398: improve overload resolution backwards compat (llvm#107350)" Revert "[clang] Implement TTP P0522 pack matching for deduced function template calls. (llvm#111457)" [Clang] Replace Intrinsic::getDeclaration with getOrInsertDeclaration (llvm#111990) Revert "[NVPTX] Prefer prmt.b32 over bfi.b32 (llvm#110766)" [RISCV] Add DAG combine to turn (sub (shl X, 8-Y), (shr X, Y)) into orc.b (llvm#111828) [libc] Fix compilation of new trig functions (llvm#111987) [NFC] Rename `Intrinsic::getDeclaration` to `getOrInsertDeclaration` (llvm#111752) [NFC][CodingStandard] Add additional example for if-else brace rule (llvm#111733) CodeGen: Remove redundant REQUIRES registered-target from tests (llvm#111982) ...
DanielCChen
pushed a commit
to DanielCChen/llvm-project
that referenced
this pull request
Oct 16, 2024
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Adds tests with scalable vectors for the Vector-To-LLVM conversion pass.
Covers the following Ops: