[flang-commits] [flang] [mlir] [mlir][arith] Canonicalize cmpi select to min/max (PR #201737)
Ming Yan via flang-commits
flang-commits at lists.llvm.org
Thu Jun 4 22:25:48 PDT 2026
https://github.com/NexMing updated https://github.com/llvm/llvm-project/pull/201737
>From ce93c26bc8ff30dafa289c586c1764523d72eb7b Mon Sep 17 00:00:00 2001
From: yanming <ming.yan at terapines.com>
Date: Fri, 5 Jun 2026 10:37:16 +0800
Subject: [PATCH 1/2] [mlir][arith] Canonicalize cmpi select to min/max
---
.../Dialect/Arith/IR/ArithCanonicalization.td | 36 ++++++++++
mlir/lib/Dialect/Arith/IR/ArithOps.cpp | 8 ++-
mlir/test/Dialect/Arith/canonicalize.mlir | 67 +++++++++++++++++++
3 files changed, 110 insertions(+), 1 deletion(-)
diff --git a/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td b/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td
index 01ad0beb7ee0d..86c9b6d3551d8 100644
--- a/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td
+++ b/mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td
@@ -319,6 +319,42 @@ def SelectI1ToNot :
(ConstantLikeMatcher ConstantAttr<I1Attr, "1">)),
(Arith_XOrIOp $pred, (Arith_ConstantOp ConstantAttr<I1Attr, "1">))>;
+class SelectCmpIToMinMaxBase<string pred, Op minMaxOp> :
+ Pat<(SelectOp
+ (Arith_CmpIOp
+ ConstantEnumCase<Arith_CmpIPredicateAttr, pred>,
+ $a, $b),
+ $a, $b),
+ (minMaxOp $a, $b)>;
+
+class SelectCmpIInverseToMinMaxBase<string pred, Op minMaxOp> :
+ Pat<(SelectOp
+ (Arith_CmpIOp
+ ConstantEnumCase<Arith_CmpIPredicateAttr, pred>,
+ $a, $b),
+ $b, $a),
+ (minMaxOp $a, $b)>;
+
+// select(cmpi pred, a, b), a, b => min/max(a, b)
+def SelectCmpISltToMinSI : SelectCmpIToMinMaxBase<"slt", Arith_MinSIOp>;
+def SelectCmpISleToMinSI : SelectCmpIToMinMaxBase<"sle", Arith_MinSIOp>;
+def SelectCmpISgtToMaxSI : SelectCmpIToMinMaxBase<"sgt", Arith_MaxSIOp>;
+def SelectCmpISgeToMaxSI : SelectCmpIToMinMaxBase<"sge", Arith_MaxSIOp>;
+def SelectCmpIUltToMinUI : SelectCmpIToMinMaxBase<"ult", Arith_MinUIOp>;
+def SelectCmpIUleToMinUI : SelectCmpIToMinMaxBase<"ule", Arith_MinUIOp>;
+def SelectCmpIUgtToMaxUI : SelectCmpIToMinMaxBase<"ugt", Arith_MaxUIOp>;
+def SelectCmpIUgeToMaxUI : SelectCmpIToMinMaxBase<"uge", Arith_MaxUIOp>;
+
+// select(cmpi pred, a, b), b, a => inverse min/max(a, b)
+def SelectCmpISltToMaxSI : SelectCmpIInverseToMinMaxBase<"slt", Arith_MaxSIOp>;
+def SelectCmpISleToMaxSI : SelectCmpIInverseToMinMaxBase<"sle", Arith_MaxSIOp>;
+def SelectCmpISgtToMinSI : SelectCmpIInverseToMinMaxBase<"sgt", Arith_MinSIOp>;
+def SelectCmpISgeToMinSI : SelectCmpIInverseToMinMaxBase<"sge", Arith_MinSIOp>;
+def SelectCmpIUltToMaxUI : SelectCmpIInverseToMinMaxBase<"ult", Arith_MaxUIOp>;
+def SelectCmpIUleToMaxUI : SelectCmpIInverseToMinMaxBase<"ule", Arith_MaxUIOp>;
+def SelectCmpIUgtToMinUI : SelectCmpIInverseToMinMaxBase<"ugt", Arith_MinUIOp>;
+def SelectCmpIUgeToMinUI : SelectCmpIInverseToMinMaxBase<"uge", Arith_MinUIOp>;
+
//===----------------------------------------------------------------------===//
// IndexCastOp
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
index 008242daeaf3c..dc3887c3e0b0e 100644
--- a/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
+++ b/mlir/lib/Dialect/Arith/IR/ArithOps.cpp
@@ -2724,7 +2724,13 @@ struct SelectToExtUI : public OpRewritePattern<arith::SelectOp> {
void arith::SelectOp::getCanonicalizationPatterns(RewritePatternSet &results,
MLIRContext *context) {
results.add<RedundantSelectFalse, RedundantSelectTrue, SelectNotCond,
- SelectI1ToNot, SelectToExtUI>(context);
+ SelectI1ToNot, SelectCmpISgeToMaxSI, SelectCmpISgeToMinSI,
+ SelectCmpISgtToMaxSI, SelectCmpISgtToMinSI, SelectCmpISleToMaxSI,
+ SelectCmpISleToMinSI, SelectCmpISltToMaxSI, SelectCmpISltToMinSI,
+ SelectCmpIUgeToMaxUI, SelectCmpIUgeToMinUI, SelectCmpIUgtToMaxUI,
+ SelectCmpIUgtToMinUI, SelectCmpIUleToMaxUI, SelectCmpIUleToMinUI,
+ SelectCmpIUltToMaxUI, SelectCmpIUltToMinUI, SelectToExtUI>(
+ context);
}
OpFoldResult arith::SelectOp::fold(FoldAdaptor adaptor) {
diff --git a/mlir/test/Dialect/Arith/canonicalize.mlir b/mlir/test/Dialect/Arith/canonicalize.mlir
index 88bf90af5be27..c12befc76675a 100644
--- a/mlir/test/Dialect/Arith/canonicalize.mlir
+++ b/mlir/test/Dialect/Arith/canonicalize.mlir
@@ -23,6 +23,73 @@ func.func @select_cmp_ne_select(%arg0: i64, %arg1: i64) -> i64 {
return %1 : i64
}
+// CHECK-LABEL: @select_cmp_signed_min_max
+// CHECK-SAME: (%[[ARG0:.+]]: i64, %[[ARG1:.+]]: i64)
+// CHECK-DAG: %[[MIN0:.+]] = arith.minsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN1:.+]] = arith.minsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN2:.+]] = arith.minsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN3:.+]] = arith.minsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX0:.+]] = arith.maxsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX1:.+]] = arith.maxsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX2:.+]] = arith.maxsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX3:.+]] = arith.maxsi %[[ARG0]], %[[ARG1]] : i64
+// CHECK: return %[[MIN0]], %[[MIN1]], %[[MIN2]], %[[MIN3]], %[[MAX0]], %[[MAX1]], %[[MAX2]], %[[MAX3]]
+func.func @select_cmp_signed_min_max(%arg0: i64, %arg1: i64) -> (i64, i64, i64, i64, i64, i64, i64, i64) {
+ %slt = arith.cmpi slt, %arg0, %arg1 : i64
+ %sle = arith.cmpi sle, %arg0, %arg1 : i64
+ %sgt = arith.cmpi sgt, %arg0, %arg1 : i64
+ %sge = arith.cmpi sge, %arg0, %arg1 : i64
+ %min0 = arith.select %slt, %arg0, %arg1 : i64
+ %min1 = arith.select %sle, %arg0, %arg1 : i64
+ %min2 = arith.select %sgt, %arg1, %arg0 : i64
+ %min3 = arith.select %sge, %arg1, %arg0 : i64
+ %max0 = arith.select %slt, %arg1, %arg0 : i64
+ %max1 = arith.select %sle, %arg1, %arg0 : i64
+ %max2 = arith.select %sgt, %arg0, %arg1 : i64
+ %max3 = arith.select %sge, %arg0, %arg1 : i64
+ return %min0, %min1, %min2, %min3, %max0, %max1, %max2, %max3 : i64, i64, i64, i64, i64, i64, i64, i64
+}
+
+// CHECK-LABEL: @select_cmp_unsigned_min_max
+// CHECK-SAME: (%[[ARG0:.+]]: i64, %[[ARG1:.+]]: i64)
+// CHECK-DAG: %[[MIN0:.+]] = arith.minui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN1:.+]] = arith.minui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN2:.+]] = arith.minui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MIN3:.+]] = arith.minui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX0:.+]] = arith.maxui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX1:.+]] = arith.maxui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX2:.+]] = arith.maxui %[[ARG0]], %[[ARG1]] : i64
+// CHECK-DAG: %[[MAX3:.+]] = arith.maxui %[[ARG0]], %[[ARG1]] : i64
+// CHECK: return %[[MIN0]], %[[MIN1]], %[[MIN2]], %[[MIN3]], %[[MAX0]], %[[MAX1]], %[[MAX2]], %[[MAX3]]
+func.func @select_cmp_unsigned_min_max(%arg0: i64, %arg1: i64) -> (i64, i64, i64, i64, i64, i64, i64, i64) {
+ %ult = arith.cmpi ult, %arg0, %arg1 : i64
+ %ule = arith.cmpi ule, %arg0, %arg1 : i64
+ %ugt = arith.cmpi ugt, %arg0, %arg1 : i64
+ %uge = arith.cmpi uge, %arg0, %arg1 : i64
+ %min0 = arith.select %ult, %arg0, %arg1 : i64
+ %min1 = arith.select %ule, %arg0, %arg1 : i64
+ %min2 = arith.select %ugt, %arg1, %arg0 : i64
+ %min3 = arith.select %uge, %arg1, %arg0 : i64
+ %max0 = arith.select %ult, %arg1, %arg0 : i64
+ %max1 = arith.select %ule, %arg1, %arg0 : i64
+ %max2 = arith.select %ugt, %arg0, %arg1 : i64
+ %max3 = arith.select %uge, %arg0, %arg1 : i64
+ return %min0, %min1, %min2, %min3, %max0, %max1, %max2, %max3 : i64, i64, i64, i64, i64, i64, i64, i64
+}
+
+// CHECK-LABEL: @select_cmp_min_max_index_vector
+// CHECK-SAME: (%[[IDX0:.+]]: index, %[[IDX1:.+]]: index, %[[VEC0:.+]]: vector<4xi32>, %[[VEC1:.+]]: vector<4xi32>)
+// CHECK-DAG: %[[IDX:.+]] = arith.minsi %[[IDX0]], %[[IDX1]] : index
+// CHECK-DAG: %[[VEC:.+]] = arith.maxui %[[VEC0]], %[[VEC1]] : vector<4xi32>
+// CHECK: return %[[IDX]], %[[VEC]]
+func.func @select_cmp_min_max_index_vector(%arg0: index, %arg1: index, %arg2: vector<4xi32>, %arg3: vector<4xi32>) -> (index, vector<4xi32>) {
+ %cmp0 = arith.cmpi sle, %arg0, %arg1 : index
+ %res0 = arith.select %cmp0, %arg0, %arg1 : index
+ %cmp1 = arith.cmpi ult, %arg2, %arg3 : vector<4xi32>
+ %res1 = arith.select %cmp1, %arg3, %arg2 : vector<4xi1>, vector<4xi32>
+ return %res0, %res1 : index, vector<4xi32>
+}
+
// CHECK-LABEL: @select_extui
// CHECK: %[[res:.+]] = arith.extui %arg0 : i1 to i64
// CHECK: return %[[res]]
>From 2e069256bc4f05d30e8185b4d4f0ff4c88f1e6b8 Mon Sep 17 00:00:00 2001
From: yanming <ming.yan at terapines.com>
Date: Fri, 5 Jun 2026 13:25:17 +0800
Subject: [PATCH 2/2] fix test: update CHECK lines for cmpi+select
canonicalization to min/max
The cmpi select to min/max canonicalization transforms:
- arith.cmpi ult + arith.select -> arith.minui
- arith.cmpi sgt + arith.select -> arith.maxsi
- arith.cmpi slt + arith.select -> arith.minsi (llvm.smin in LLVM IR)
Updated CHECK lines in:
- mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir
- mlir/test/Dialect/SparseTensor/sparse_kernels_to_iterator.mlir
- flang/test/Lower/volatile1.f90
- flang/test/Lower/Intrinsics/show_descriptor.f90
- flang/test/Lower/HLFIR/elemental-result-length.f90
- flang/test/Fir/boxproc.fir
Co-Authored-By: Claude Opus 4.8 <noreply at anthropic.com>
---
flang/test/Fir/boxproc.fir | 6 +-
.../Lower/HLFIR/elemental-result-length.f90 | 6 +-
.../test/Lower/Intrinsics/show_descriptor.f90 | 3 +-
flang/test/Lower/volatile1.f90 | 11 ++-
.../SparseTensor/sparse_fill_zero.mlir | 71 +++++++++---------
.../sparse_kernels_to_iterator.mlir | 73 +++++++++----------
6 files changed, 81 insertions(+), 89 deletions(-)
diff --git a/flang/test/Fir/boxproc.fir b/flang/test/Fir/boxproc.fir
index 97d9b38ed6f40..8c8bf6a4607b6 100644
--- a/flang/test/Fir/boxproc.fir
+++ b/flang/test/Fir/boxproc.fir
@@ -97,8 +97,7 @@ func.func @_QPtest_proc_dummy_other(%arg0: !fir.boxproc<() -> ()>) {
// CHECK: %[[VAL_4:.*]] = load { ptr, i64 }, ptr %[[VAL_3]], align 8
// CHECK: %[[VAL_5:.*]] = extractvalue { ptr, i64 } %[[VAL_4]], 0
// CHECK: %[[VAL_6:.*]] = extractvalue { ptr, i64 } %[[VAL_4]], 1
-// CHECK: %[[VAL_8:.*]] = icmp sgt i64 %[[VAL_6]], 10
-// CHECK: %[[VAL_9:.*]] = select i1 %[[VAL_8]], i64 10, i64 %[[VAL_6]]
+// CHECK: %[[VAL_9:.*]] = call i64 @llvm.smin.i64(i64 %[[VAL_6]], i64 10)
// CHECK: call void @llvm.memmove.p0.p0.i64(ptr %[[VAL_0]], ptr %[[VAL_5]], i64 %[[VAL_9]], i1 false)
// CHECK: %[[VAL_10:.*]] = sub i64 10, %[[VAL_9]]
// CHECK: br label %[[VAL_11:.*]]
@@ -133,8 +132,7 @@ func.func @_QPtest_proc_dummy_other(%arg0: !fir.boxproc<() -> ()>) {
// CHECK: %[[VAL_27:.*]] = load [1 x i8], ptr %[[VAL_26]], align 1
// CHECK: %[[VAL_29:.*]] = getelementptr [1 x i8], ptr %[[VAL_14]], i64 %[[VAL_18]]
// CHECK: store [1 x i8] %[[VAL_27]], ptr %[[VAL_29]], align 1
-// CHECK: %[[VAL_30:.*]] = icmp sgt i64 %[[VAL_13]], 40
-// CHECK: %[[VAL_31:.*]] = select i1 %[[VAL_30]], i64 40, i64 %[[VAL_13]]
+// CHECK: %[[VAL_31:.*]] = call i64 @llvm.smin.i64(i64 %[[VAL_13]], i64 40)
// CHECK: call void @llvm.memmove.p0.p0.i64(ptr %[[VAL_0]], ptr %[[VAL_14]], i64 %[[VAL_31]], i1 false)
// CHECK: %[[VAL_32:.*]] = sub i64 40, %[[VAL_31]]
// CHECK: %[[VAL_35:.*]] = phi i64
diff --git a/flang/test/Lower/HLFIR/elemental-result-length.f90 b/flang/test/Lower/HLFIR/elemental-result-length.f90
index 4cce2ce5e496e..95298ef2fc41f 100644
--- a/flang/test/Lower/HLFIR/elemental-result-length.f90
+++ b/flang/test/Lower/HLFIR/elemental-result-length.f90
@@ -31,8 +31,7 @@ subroutine sub2(a,b,c)
! CHECK: %[[LEN_B:.*]] = fir.convert %[[UNBOX_B]]#1 : (index) -> i64
! CHECK: %[[LEN_LEN:.*]] = arith.addi %[[LEN_A]], %[[LEN_B]] : i64
! CHECK: %[[LEN_LEN_IDX:.*]] = fir.convert %[[LEN_LEN]] : (i64) -> index
-! CHECK: %[[CMPI:.*]] = arith.cmpi sgt, %[[LEN_LEN_IDX]], %c0{{.*}} : index
-! CHECK: %[[RES_LENGTH:.*]] = arith.select %[[CMPI]], %[[LEN_LEN_IDX]], %c0{{.*}} : index
+! CHECK: %[[RES_LENGTH:.*]] = arith.maxsi %[[LEN_LEN_IDX]], %c0{{.*}} : index
! CHECK: %[[RES:.*]] = fir.alloca !fir.char<1,?>(%[[RES_LENGTH]] : index) {bindc_name = ".result"}
! CHECK: fir.call @_QMm1Pfct1
@@ -54,8 +53,7 @@ subroutine sub4(a,b,c)
! CHECK: %[[LEN_B_I32:.*]] = fir.convert %[[LEN_B]] : (index) -> i64
! CHECK: %[[LEN_LEN:.*]] = arith.addi %[[LEN_A_I32]], %[[LEN_B_I32]] : i64
! CHECK: %[[LEN_LEN_IDX:.*]] = fir.convert %[[LEN_LEN]] : (i64) -> index
-! CHECK: %[[CMPI:.*]] = arith.cmpi sgt, %[[LEN_LEN_IDX]], %c0{{.*}} : index
-! CHECK: %[[LENGTH:.*]] = arith.select %[[CMPI]], %[[LEN_LEN_IDX]], %c0{{.*}} : index
+! CHECK: %[[LENGTH:.*]] = arith.maxsi %[[LEN_LEN_IDX]], %c0{{.*}} : index
! CHECK: %{{.*}} = hlfir.elemental %{{.*}} typeparams %[[LENGTH]] unordered : (!fir.shape<1>, index) -> !hlfir.expr<?x!fir.char<1,?>>
end module
diff --git a/flang/test/Lower/Intrinsics/show_descriptor.f90 b/flang/test/Lower/Intrinsics/show_descriptor.f90
index ed330820e550b..e4e61efab11f2 100644
--- a/flang/test/Lower/Intrinsics/show_descriptor.f90
+++ b/flang/test/Lower/Intrinsics/show_descriptor.f90
@@ -25,8 +25,7 @@ subroutine test_int
! CHECK: fir.store %[[C5]] to %[[DECLARE_1]] : !fir.ref<i32>
! CHECK: %[[LOAD_0:.*]] = fir.load %[[DECLARE_1]] : !fir.ref<i32>
! CHECK: %[[CONVERT_0:.*]] = fir.convert %[[LOAD_0]] : (i32) -> index
-! CHECK: %[[CMPI_0:.*]] = arith.cmpi sgt, %[[CONVERT_0]], %[[C0]] : index
-! CHECK: %[[SELECT_0:.*]] = arith.select %[[CMPI_0]], %[[CONVERT_0]], %[[C0]] : index
+! CHECK: %[[SELECT_0:.*]] = arith.maxsi %[[CONVERT_0]], %[[C0]] : index
! CHECK: %[[ALLOCMEM_0:.*]] = fir.allocmem !fir.array<?xi32>, %[[SELECT_0]] {fir.must_be_heap = true, uniq_name = "_QMtest_show_descriptorFtest_intEa.alloc"}
call show_descriptor(a)
diff --git a/flang/test/Lower/volatile1.f90 b/flang/test/Lower/volatile1.f90
index 385b9fa3bd1ad..ec1c85eb8e981 100644
--- a/flang/test/Lower/volatile1.f90
+++ b/flang/test/Lower/volatile1.f90
@@ -83,11 +83,10 @@ subroutine declared_volatile_in_this_scope(v,n)
! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[VAL_1]] dummy_scope %[[VAL_4]] {{.+}} : (!fir.ref<i32>, !fir.dscope) -> (!fir.ref<i32>, !fir.ref<i32>)
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_5]]#0 : !fir.ref<i32>
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> index
-! CHECK: %[[VAL_8:.*]] = arith.cmpi sgt, %[[VAL_7]], %[[VAL_3]] : index
-! CHECK: %[[VAL_9:.*]] = arith.select %[[VAL_8]], %[[VAL_7]], %[[VAL_3]] : index
-! CHECK: %[[VAL_10:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_11:.*]] = fir.volatile_cast %[[VAL_0]] : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>, volatile>
-! CHECK: %[[VAL_12:.*]]:2 = hlfir.declare %[[VAL_11]](%[[VAL_10]]) dummy_scope %[[VAL_4]] {{.+}} : (!fir.ref<!fir.array<?xi32>, volatile>, !fir.shape<1>, !fir.dscope) -> (!fir.box<!fir.array<?xi32>, volatile>, !fir.ref<!fir.array<?xi32>, volatile>)
-! CHECK: hlfir.assign %[[VAL_2]] to %[[VAL_12]]#0 : i32, !fir.box<!fir.array<?xi32>, volatile>
+! CHECK: %[[VAL_8:.*]] = arith.maxsi %[[VAL_7]], %[[VAL_3]] : index
+! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1>
+! CHECK: %[[VAL_10:.*]] = fir.volatile_cast %[[VAL_0]] : (!fir.ref<!fir.array<?xi32>>) -> !fir.ref<!fir.array<?xi32>, volatile>
+! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_10]](%[[VAL_9]]) dummy_scope %[[VAL_4]] {{.+}} : (!fir.ref<!fir.array<?xi32>, volatile>, !fir.shape<1>, !fir.dscope) -> (!fir.box<!fir.array<?xi32>, volatile>, !fir.ref<!fir.array<?xi32>, volatile>)
+! CHECK: hlfir.assign %[[VAL_2]] to %[[VAL_11]]#0 : i32, !fir.box<!fir.array<?xi32>, volatile>
! CHECK: return
! CHECK: }
diff --git a/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir b/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir
index c26ba56347299..4b8a1a1ca3a9a 100644
--- a/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir
+++ b/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir
@@ -65,49 +65,48 @@
// CHECK: ^bb0(%[[VAL_52:.*]]: index, %[[VAL_53:.*]]: index, %[[VAL_54:.*]]: index):
// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_29]]{{\[}}%[[VAL_52]]] : memref<?xindex>
// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_32]]{{\[}}%[[VAL_53]]] : memref<?xindex>
-// CHECK: %[[VAL_57:.*]] = arith.cmpi ult, %[[VAL_56]], %[[VAL_55]] : index
-// CHECK: %[[VAL_58:.*]] = arith.select %[[VAL_57]], %[[VAL_56]], %[[VAL_55]] : index
-// CHECK: %[[VAL_59:.*]] = arith.cmpi eq, %[[VAL_55]], %[[VAL_58]] : index
-// CHECK: %[[VAL_60:.*]] = arith.cmpi eq, %[[VAL_56]], %[[VAL_58]] : index
-// CHECK: %[[VAL_61:.*]] = arith.andi %[[VAL_59]], %[[VAL_60]] : i1
-// CHECK: %[[VAL_62:.*]] = scf.if %[[VAL_61]] -> (index) {
-// CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_30]]{{\[}}%[[VAL_52]]] : memref<?xf64>
-// CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_53]]] : memref<?xindex>
-// CHECK: %[[VAL_65:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index
-// CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_65]]] : memref<?xindex>
-// CHECK: %[[VAL_67:.*]] = scf.for %[[VAL_68:.*]] = %[[VAL_64]] to %[[VAL_66]] step %[[VAL_6]] iter_args(%[[VAL_69:.*]] = %[[VAL_54]]) -> (index) {
-// CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_34]]{{\[}}%[[VAL_68]]] : memref<?xindex>
-// CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_70]]] : memref<300xf64>
-// CHECK: %[[VAL_72:.*]] = memref.load %[[VAL_35]]{{\[}}%[[VAL_68]]] : memref<?xf64>
-// CHECK: %[[VAL_73:.*]] = arith.mulf %[[VAL_63]], %[[VAL_72]] : f64
-// CHECK: %[[VAL_74:.*]] = arith.addf %[[VAL_71]], %[[VAL_73]] : f64
-// CHECK: %[[VAL_75:.*]] = memref.load %[[VAL_22]]{{\[}}%[[VAL_70]]] : memref<300xi1>
-// CHECK: %[[VAL_76:.*]] = arith.cmpi eq, %[[VAL_75]], %[[VAL_7]] : i1
-// CHECK: %[[VAL_77:.*]] = scf.if %[[VAL_76]] -> (index) {
-// CHECK: memref.store %[[VAL_8]], %[[VAL_22]]{{\[}}%[[VAL_70]]] : memref<300xi1>
-// CHECK: memref.store %[[VAL_70]], %[[VAL_24]]{{\[}}%[[VAL_69]]] : memref<300xindex>
-// CHECK: %[[VAL_78:.*]] = arith.addi %[[VAL_69]], %[[VAL_6]] : index
-// CHECK: scf.yield %[[VAL_78]] : index
+// CHECK: %[[VAL_57:.*]] = arith.minui %[[VAL_56]], %[[VAL_55]] : index
+// CHECK: %[[VAL_58:.*]] = arith.cmpi eq, %[[VAL_55]], %[[VAL_57]] : index
+// CHECK: %[[VAL_59:.*]] = arith.cmpi eq, %[[VAL_56]], %[[VAL_57]] : index
+// CHECK: %[[VAL_60:.*]] = arith.andi %[[VAL_58]], %[[VAL_59]] : i1
+// CHECK: %[[VAL_61:.*]] = scf.if %[[VAL_60]] -> (index) {
+// CHECK: %[[VAL_62:.*]] = memref.load %[[VAL_30]]{{\[}}%[[VAL_52]]] : memref<?xf64>
+// CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_53]]] : memref<?xindex>
+// CHECK: %[[VAL_64:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index
+// CHECK: %[[VAL_65:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_64]]] : memref<?xindex>
+// CHECK: %[[VAL_66:.*]] = scf.for %[[VAL_67:.*]] = %[[VAL_63]] to %[[VAL_65]] step %[[VAL_6]] iter_args(%[[VAL_68:.*]] = %[[VAL_54]]) -> (index) {
+// CHECK: %[[VAL_69:.*]] = memref.load %[[VAL_34]]{{\[}}%[[VAL_67]]] : memref<?xindex>
+// CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_69]]] : memref<300xf64>
+// CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_35]]{{\[}}%[[VAL_67]]] : memref<?xf64>
+// CHECK: %[[VAL_72:.*]] = arith.mulf %[[VAL_62]], %[[VAL_71]] : f64
+// CHECK: %[[VAL_73:.*]] = arith.addf %[[VAL_70]], %[[VAL_72]] : f64
+// CHECK: %[[VAL_74:.*]] = memref.load %[[VAL_22]]{{\[}}%[[VAL_69]]] : memref<300xi1>
+// CHECK: %[[VAL_75:.*]] = arith.cmpi eq, %[[VAL_74]], %[[VAL_7]] : i1
+// CHECK: %[[VAL_76:.*]] = scf.if %[[VAL_75]] -> (index) {
+// CHECK: memref.store %[[VAL_8]], %[[VAL_22]]{{\[}}%[[VAL_69]]] : memref<300xi1>
+// CHECK: memref.store %[[VAL_69]], %[[VAL_24]]{{\[}}%[[VAL_68]]] : memref<300xindex>
+// CHECK: %[[VAL_77:.*]] = arith.addi %[[VAL_68]], %[[VAL_6]] : index
+// CHECK: scf.yield %[[VAL_77]] : index
// CHECK: } else {
-// CHECK: scf.yield %[[VAL_69]] : index
+// CHECK: scf.yield %[[VAL_68]] : index
// CHECK: }
-// CHECK: memref.store %[[VAL_74]], %[[VAL_20]]{{\[}}%[[VAL_70]]] : memref<300xf64>
-// CHECK: scf.yield %[[VAL_77]] : index
+// CHECK: memref.store %[[VAL_73]], %[[VAL_20]]{{\[}}%[[VAL_69]]] : memref<300xf64>
+// CHECK: scf.yield %[[VAL_76]] : index
// CHECK: }
-// CHECK: scf.yield %[[VAL_67]] : index
+// CHECK: scf.yield %[[VAL_66]] : index
// CHECK: } else {
// CHECK: scf.yield %[[VAL_54]] : index
// CHECK: }
-// CHECK: %[[VAL_79:.*]] = arith.addi %[[VAL_52]], %[[VAL_6]] : index
-// CHECK: %[[VAL_80:.*]] = arith.select %[[VAL_59]], %[[VAL_79]], %[[VAL_52]] : index
-// CHECK: %[[VAL_81:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index
-// CHECK: %[[VAL_82:.*]] = arith.select %[[VAL_60]], %[[VAL_81]], %[[VAL_53]] : index
-// CHECK: scf.yield %[[VAL_80]], %[[VAL_82]], %[[VAL_62]] : index, index, index
+// CHECK: %[[VAL_78:.*]] = arith.addi %[[VAL_52]], %[[VAL_6]] : index
+// CHECK: %[[VAL_79:.*]] = arith.select %[[VAL_58]], %[[VAL_78]], %[[VAL_52]] : index
+// CHECK: %[[VAL_80:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index
+// CHECK: %[[VAL_81:.*]] = arith.select %[[VAL_59]], %[[VAL_80]], %[[VAL_53]] : index
+// CHECK: scf.yield %[[VAL_79]], %[[VAL_81]], %[[VAL_61]] : index, index, index
// CHECK: }
-// CHECK: %[[VAL_83:.*]] = memref.alloca() : memref<2xindex>
-// CHECK: %[[VAL_84:.*]] = memref.cast %[[VAL_83]] : memref<2xindex> to memref<?xindex>
-// CHECK: memref.store %[[VAL_39]], %[[VAL_83]]{{\[}}%[[VAL_5]]] : memref<2xindex>
-// CHECK: func.call @expInsertF64(%[[VAL_19]], %[[VAL_84]], %[[VAL_21]], %[[VAL_23]], %[[VAL_25]], %[[VAL_85:.*]]#2) : (!llvm.ptr, memref<?xindex>, memref<?xf64>, memref<?xi1>, memref<?xindex>, index) -> ()
+// CHECK: %[[VAL_82:.*]] = memref.alloca() : memref<2xindex>
+// CHECK: %[[VAL_83:.*]] = memref.cast %[[VAL_82]] : memref<2xindex> to memref<?xindex>
+// CHECK: memref.store %[[VAL_39]], %[[VAL_82]]{{\[}}%[[VAL_5]]] : memref<2xindex>
+// CHECK: func.call @expInsertF64(%[[VAL_19]], %[[VAL_83]], %[[VAL_21]], %[[VAL_23]], %[[VAL_25]], %[[VAL_84:.*]]#2) : (!llvm.ptr, memref<?xindex>, memref<?xf64>, memref<?xi1>, memref<?xindex>, index) -> ()
// CHECK: }
// CHECK: memref.dealloc %[[VAL_20]] : memref<300xf64>
// CHECK: memref.dealloc %[[VAL_22]] : memref<300xi1>
diff --git a/mlir/test/Dialect/SparseTensor/sparse_kernels_to_iterator.mlir b/mlir/test/Dialect/SparseTensor/sparse_kernels_to_iterator.mlir
index f6f7f396adab5..7d789ce00a4ee 100644
--- a/mlir/test/Dialect/SparseTensor/sparse_kernels_to_iterator.mlir
+++ b/mlir/test/Dialect/SparseTensor/sparse_kernels_to_iterator.mlir
@@ -104,51 +104,50 @@ func.func @sqsum(%arg0: tensor<?x?x?x?xi32, #COO>) -> tensor<i32> {
// CHECK: ^bb0(%[[VAL_21:.*]]: index, %[[VAL_22:.*]]: index):
// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_21]]] : memref<?xindex>
// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_22]]] : memref<?xindex>
-// CHECK: %[[VAL_25:.*]] = arith.cmpi ult, %[[VAL_24]], %[[VAL_23]] : index
-// CHECK: %[[VAL_26:.*]] = arith.select %[[VAL_25]], %[[VAL_24]], %[[VAL_23]] : index
-// CHECK: %[[VAL_27:.*]] = arith.cmpi eq, %[[VAL_23]], %[[VAL_26]] : index
-// CHECK: %[[VAL_28:.*]] = arith.cmpi eq, %[[VAL_24]], %[[VAL_26]] : index
-// CHECK: %[[VAL_29:.*]] = arith.andi %[[VAL_27]], %[[VAL_28]] : i1
-// CHECK: scf.if %[[VAL_29]] {
-// CHECK: %[[VAL_30:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_30]]{{\[}}%[[VAL_21]]] : memref<?xi32>
-// CHECK: %[[VAL_32:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_32]]{{\[}}%[[VAL_22]]] : memref<?xi32>
-// CHECK: %[[VAL_34:.*]] = arith.addi %[[VAL_31]], %[[VAL_33]] : i32
-// CHECK: memref.store %[[VAL_34]], %[[VAL_6]]{{\[}}%[[VAL_26]]] : memref<10xi32>
+// CHECK: %[[VAL_25:.*]] = arith.minui %[[VAL_24]], %[[VAL_23]] : index
+// CHECK: %[[VAL_26:.*]] = arith.cmpi eq, %[[VAL_23]], %[[VAL_25]] : index
+// CHECK: %[[VAL_27:.*]] = arith.cmpi eq, %[[VAL_24]], %[[VAL_25]] : index
+// CHECK: %[[VAL_28:.*]] = arith.andi %[[VAL_26]], %[[VAL_27]] : i1
+// CHECK: scf.if %[[VAL_28]] {
+// CHECK: %[[VAL_29:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_29]]{{\[}}%[[VAL_21]]] : memref<?xi32>
+// CHECK: %[[VAL_31:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_31]]{{\[}}%[[VAL_22]]] : memref<?xi32>
+// CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_30]], %[[VAL_32]] : i32
+// CHECK: memref.store %[[VAL_33]], %[[VAL_6]]{{\[}}%[[VAL_25]]] : memref<10xi32>
// CHECK: } else {
-// CHECK: scf.if %[[VAL_27]] {
-// CHECK: %[[VAL_35:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_35]]{{\[}}%[[VAL_21]]] : memref<?xi32>
-// CHECK: memref.store %[[VAL_36]], %[[VAL_6]]{{\[}}%[[VAL_26]]] : memref<10xi32>
+// CHECK: scf.if %[[VAL_26]] {
+// CHECK: %[[VAL_34:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_34]]{{\[}}%[[VAL_21]]] : memref<?xi32>
+// CHECK: memref.store %[[VAL_35]], %[[VAL_6]]{{\[}}%[[VAL_25]]] : memref<10xi32>
// CHECK: } else {
-// CHECK: scf.if %[[VAL_28]] {
-// CHECK: %[[VAL_37:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_37]]{{\[}}%[[VAL_22]]] : memref<?xi32>
-// CHECK: memref.store %[[VAL_38]], %[[VAL_6]]{{\[}}%[[VAL_26]]] : memref<10xi32>
+// CHECK: scf.if %[[VAL_27]] {
+// CHECK: %[[VAL_36:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_36]]{{\[}}%[[VAL_22]]] : memref<?xi32>
+// CHECK: memref.store %[[VAL_37]], %[[VAL_6]]{{\[}}%[[VAL_25]]] : memref<10xi32>
// CHECK: }
// CHECK: }
// CHECK: }
-// CHECK: %[[VAL_39:.*]] = arith.addi %[[VAL_21]], %[[VAL_2]] : index
-// CHECK: %[[VAL_40:.*]] = arith.select %[[VAL_27]], %[[VAL_39]], %[[VAL_21]] : index
-// CHECK: %[[VAL_41:.*]] = arith.addi %[[VAL_22]], %[[VAL_2]] : index
-// CHECK: %[[VAL_42:.*]] = arith.select %[[VAL_28]], %[[VAL_41]], %[[VAL_22]] : index
-// CHECK: scf.yield %[[VAL_40]], %[[VAL_42]] : index, index
+// CHECK: %[[VAL_38:.*]] = arith.addi %[[VAL_21]], %[[VAL_2]] : index
+// CHECK: %[[VAL_39:.*]] = arith.select %[[VAL_26]], %[[VAL_38]], %[[VAL_21]] : index
+// CHECK: %[[VAL_40:.*]] = arith.addi %[[VAL_22]], %[[VAL_2]] : index
+// CHECK: %[[VAL_41:.*]] = arith.select %[[VAL_27]], %[[VAL_40]], %[[VAL_22]] : index
+// CHECK: scf.yield %[[VAL_39]], %[[VAL_41]] : index, index
// CHECK: }
-// CHECK: %[[VAL_43:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: scf.for %[[VAL_44:.*]] = %[[VAL_45:.*]]#0 to %[[VAL_10]] step %[[VAL_2]] {
-// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_44]]] : memref<?xindex>
-// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_43]]{{\[}}%[[VAL_44]]] : memref<?xi32>
-// CHECK: memref.store %[[VAL_47]], %[[VAL_6]]{{\[}}%[[VAL_46]]] : memref<10xi32>
+// CHECK: %[[VAL_42:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: scf.for %[[VAL_43:.*]] = %[[VAL_44:.*]]#0 to %[[VAL_10]] step %[[VAL_2]] {
+// CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_43]]] : memref<?xindex>
+// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_42]]{{\[}}%[[VAL_43]]] : memref<?xi32>
+// CHECK: memref.store %[[VAL_46]], %[[VAL_6]]{{\[}}%[[VAL_45]]] : memref<10xi32>
// CHECK: }
-// CHECK: %[[VAL_48:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
-// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#1 to %[[VAL_14]] step %[[VAL_2]] {
-// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_49]]] : memref<?xindex>
-// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_48]]{{\[}}%[[VAL_49]]] : memref<?xi32>
-// CHECK: memref.store %[[VAL_52]], %[[VAL_6]]{{\[}}%[[VAL_51]]] : memref<10xi32>
+// CHECK: %[[VAL_47:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<10xi32, #sparse{{.*}}> to memref<?xi32>
+// CHECK: scf.for %[[VAL_48:.*]] = %[[VAL_49:.*]]#1 to %[[VAL_14]] step %[[VAL_2]] {
+// CHECK: %[[VAL_50:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_48]]] : memref<?xindex>
+// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_47]]{{\[}}%[[VAL_48]]] : memref<?xi32>
+// CHECK: memref.store %[[VAL_51]], %[[VAL_6]]{{\[}}%[[VAL_50]]] : memref<10xi32>
// CHECK: }
-// CHECK: %[[VAL_53:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<10xi32>
-// CHECK: return %[[VAL_53]] : tensor<10xi32>
+// CHECK: %[[VAL_52:.*]] = bufferization.to_tensor %[[VAL_6]] : memref<10xi32>
+// CHECK: return %[[VAL_52]] : tensor<10xi32>
// CHECK: }
func.func @add(%arg0: tensor<10xi32, #VEC>, %arg1: tensor<10xi32, #VEC>) -> tensor<10xi32> {
%cst = arith.constant dense<0> : tensor<10xi32>
More information about the flang-commits
mailing list