[clang] [llvm] [RISCV][P-ext] Add scalar comparison intrinsics (PR #239245)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 11 23:53:50 PST 2026
https://github.com/sihuan updated https://github.com/llvm/llvm-project/pull/239245
>From e859fed8a76b4401f985b2d39c243911f4e5b5dd Mon Sep 17 00:00:00 2001
From: SiHuaN <liyongtai at iscas.ac.cn>
Date: Thu, 5 Nov 2026 13:54:34 +0000
Subject: [PATCH 1/2] [RISCV][P-ext] Add scalar comparison intrinsics
Add the scalar Comparison intrinsics from the P-extension intrinsic spec:
https://github.com/riscv/riscv-p-spec/blob/master/P-ext-intrinsics.adoc#comparison
RV32 selects mseq/mslt/msltu directly. RV64 uses pmseq.w/pmslt.w/pmsltu.w
on the low word. msgt/msne/msge/... are composed with an operand swap or
a bitwise not.
---
clang/include/clang/Basic/BuiltinsRISCV.td | 5 +
clang/lib/CodeGen/TargetBuiltins/RISCV.cpp | 11 +
clang/lib/Headers/riscv_packed_simd.h | 61 ++++++
clang/test/CodeGen/RISCV/rvp-intrinsics.c | 206 ++++++++++++++++++
.../riscv_packed_simd.c | 97 +++++++++
llvm/include/llvm/IR/IntrinsicsRISCV.td | 9 +
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 24 ++
llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 15 ++
llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll | 34 +++
llvm/test/CodeGen/RISCV/rvp-scalar.ll | 190 ++++++++++++++++
10 files changed, 652 insertions(+)
diff --git a/clang/include/clang/Basic/BuiltinsRISCV.td b/clang/include/clang/Basic/BuiltinsRISCV.td
index 19438ec8d6b0bb..5d0061fa8956bb 100644
--- a/clang/include/clang/Basic/BuiltinsRISCV.td
+++ b/clang/include/clang/Basic/BuiltinsRISCV.td
@@ -271,6 +271,11 @@ def aaddu_u32 : RISCVBuiltin<"uint32_t(uint32_t, uint32_t)">;
def asub_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t)">;
def asubu_u32 : RISCVBuiltin<"uint32_t(uint32_t, uint32_t)">;
+// Scalar Comparison
+def mseq : RISCVBuiltin<"uint32_t(uint32_t, uint32_t)">;
+def mslt : RISCVBuiltin<"uint32_t(int32_t, int32_t)">;
+def msltu : RISCVBuiltin<"uint32_t(uint32_t, uint32_t)">;
+
// Scalar Saturation
def sati_i32 : RISCVBuiltin<"int32_t(int32_t, _Constant unsigned int)">;
def usati_u32 : RISCVBuiltin<"uint32_t(int32_t, _Constant unsigned int)">;
diff --git a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
index 19885655bfba0d..b34e7c4bbd39ac 100644
--- a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
+++ b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
@@ -1700,6 +1700,17 @@ Value *CodeGenFunction::EmitRISCVBuiltinExpr(unsigned BuiltinID,
ID = Intrinsic::riscv_asubu_u32;
break;
+ // Scalar Comparison
+ case RISCV::BI__builtin_riscv_mseq:
+ ID = Intrinsic::riscv_mseq;
+ break;
+ case RISCV::BI__builtin_riscv_mslt:
+ ID = Intrinsic::riscv_mslt;
+ break;
+ case RISCV::BI__builtin_riscv_msltu:
+ ID = Intrinsic::riscv_msltu;
+ break;
+
// Scalar Multiply High
case RISCV::BI__builtin_riscv_mulhr_i32:
case RISCV::BI__builtin_riscv_mulhru_u32:
diff --git a/clang/lib/Headers/riscv_packed_simd.h b/clang/lib/Headers/riscv_packed_simd.h
index 4459bd7e715fc0..0fa0e584c682ba 100644
--- a/clang/lib/Headers/riscv_packed_simd.h
+++ b/clang/lib/Headers/riscv_packed_simd.h
@@ -470,6 +470,67 @@ __packed_binary_builtin(aaddu_u32, uint32_t, __builtin_riscv_aaddu_u32)
__packed_binary_builtin(asub_i32, int32_t, __builtin_riscv_asub_i32)
__packed_binary_builtin(asubu_u32, uint32_t, __builtin_riscv_asubu_u32)
+/* Scalar Comparison */
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_mseq_i32_u32(int32_t __rs1, int32_t __rs2) {
+ return __builtin_riscv_mseq((uint32_t)__rs1, (uint32_t)__rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_mseq_u32_u32(uint32_t __rs1, uint32_t __rs2) {
+ return __builtin_riscv_mseq(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_mslt_u32(int32_t __rs1, int32_t __rs2) {
+ return __builtin_riscv_mslt(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msgt_u32(int32_t __rs1, int32_t __rs2) {
+ return __builtin_riscv_mslt(__rs2, __rs1);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msltu_u32(uint32_t __rs1, uint32_t __rs2) {
+ return __builtin_riscv_msltu(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msgtu_u32(uint32_t __rs1, uint32_t __rs2) {
+ return __builtin_riscv_msltu(__rs2, __rs1);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msne_i32_u32(int32_t __rs1, int32_t __rs2) {
+ return ~__builtin_riscv_mseq((uint32_t)__rs1, (uint32_t)__rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msne_u32_u32(uint32_t __rs1, uint32_t __rs2) {
+ return ~__builtin_riscv_mseq(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msge_u32(int32_t __rs1, int32_t __rs2) {
+ return ~__builtin_riscv_mslt(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msle_u32(int32_t __rs1, int32_t __rs2) {
+ return ~__builtin_riscv_mslt(__rs2, __rs1);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msgeu_u32(uint32_t __rs1, uint32_t __rs2) {
+ return ~__builtin_riscv_msltu(__rs1, __rs2);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_msleu_u32(uint32_t __rs1, uint32_t __rs2) {
+ return ~__builtin_riscv_msltu(__rs2, __rs1);
+}
+
/* Scalar Saturating Addition and Subtraction */
__packed_binary_builtin(sadd_i32, int32_t, __builtin_elementwise_add_sat)
__packed_binary_builtin(saddu_u32, uint32_t, __builtin_elementwise_add_sat)
diff --git a/clang/test/CodeGen/RISCV/rvp-intrinsics.c b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
index 409c4999edd233..7954ad5afee51b 100644
--- a/clang/test/CodeGen/RISCV/rvp-intrinsics.c
+++ b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
@@ -204,6 +204,212 @@ uint32_t test_asubu_u32(uint32_t a, uint32_t b) {
return __riscv_asubu_u32(a, b);
}
+/* Scalar Comparison */
+
+// RV32-LABEL: define dso_local i32 @test_mseq_i32_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mseq_i32_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_mseq_i32_u32(int32_t a, int32_t b) {
+ return __riscv_mseq_i32_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_mseq_u32_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mseq_u32_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_mseq_u32_u32(uint32_t a, uint32_t b) {
+ return __riscv_mseq_u32_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_mslt_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[A]], i32 [[B]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mslt_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[A]], i32 [[B]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_mslt_u32(int32_t a, int32_t b) {
+ return __riscv_mslt_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msgt_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[B]], i32 [[A]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msgt_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[B]], i32 [[A]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_msgt_u32(int32_t a, int32_t b) {
+ return __riscv_msgt_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msltu_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[A]], i32 [[B]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msltu_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[A]], i32 [[B]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_msltu_u32(uint32_t a, uint32_t b) {
+ return __riscv_msltu_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msgtu_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[B]], i32 [[A]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msgtu_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[B]], i32 [[A]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_msgtu_u32(uint32_t a, uint32_t b) {
+ return __riscv_msgtu_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msne_i32_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msne_i32_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msne_i32_u32(int32_t a, int32_t b) {
+ return __riscv_msne_i32_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msne_u32_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msne_u32_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mseq(i32 [[A]], i32 [[B]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msne_u32_u32(uint32_t a, uint32_t b) {
+ return __riscv_msne_u32_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msge_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[A]], i32 [[B]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msge_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[A]], i32 [[B]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msge_u32(int32_t a, int32_t b) {
+ return __riscv_msge_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msle_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[B]], i32 [[A]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msle_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.mslt(i32 [[B]], i32 [[A]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msle_u32(int32_t a, int32_t b) {
+ return __riscv_msle_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msgeu_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[A]], i32 [[B]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msgeu_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[A]], i32 [[B]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msgeu_u32(uint32_t a, uint32_t b) {
+ return __riscv_msgeu_u32(a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_msleu_u32(
+// RV32-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[B]], i32 [[A]])
+// RV32-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV32-NEXT: ret i32 [[NOT_I]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_msleu_u32(
+// RV64-SAME: i32 noundef signext [[A:%.*]], i32 noundef signext [[B:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.msltu(i32 [[B]], i32 [[A]])
+// RV64-NEXT: [[NOT_I:%.*]] = xor i32 [[TMP0]], -1
+// RV64-NEXT: ret i32 [[NOT_I]]
+//
+uint32_t test_msleu_u32(uint32_t a, uint32_t b) {
+ return __riscv_msleu_u32(a, b);
+}
+
/* Scalar Widening Zip */
// CHECK-LABEL: define dso_local i64 @test_wzip8p_64(
diff --git a/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c b/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
index cab908c4662c9b..3ba48a7c6c82d4 100644
--- a/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
+++ b/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
@@ -6567,3 +6567,100 @@ int32x2_t test_pslidedownx_i32x2(int32x2_t rd, int32x2_t rs1, unsigned rs2) {
uint32x2_t test_pslidedownx_u32x2(uint32x2_t rd, uint32x2_t rs1, unsigned rs2) {
return __riscv_pslidedownx_u32x2(rd, rs1, rs2);
}
+
+// Scalar Comparison
+// CHECK-LABEL: test_mseq_i32_u32:
+// RV32: mseq{{[[:space:]]+a0, a0, a1}}
+// RV64: pmseq.w{{[[:space:]]+a0, a0, a1}}
+uint32_t test_mseq_i32_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_mseq_i32_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_mseq_u32_u32:
+// RV32: mseq{{[[:space:]]+a0, a0, a1}}
+// RV64: pmseq.w{{[[:space:]]+a0, a0, a1}}
+uint32_t test_mseq_u32_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_mseq_u32_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_mslt_u32:
+// RV32: mslt{{[[:space:]]+a0, a0, a1}}
+// RV64: pmslt.w{{[[:space:]]+a0, a0, a1}}
+uint32_t test_mslt_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_mslt_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msgt_u32:
+// RV32: mslt{{[[:space:]]+a0, a1, a0}}
+// RV64: pmslt.w{{[[:space:]]+a0, a1, a0}}
+uint32_t test_msgt_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_msgt_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msltu_u32:
+// RV32: msltu{{[[:space:]]+a0, a0, a1}}
+// RV64: pmsltu.w{{[[:space:]]+a0, a0, a1}}
+uint32_t test_msltu_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_msltu_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msgtu_u32:
+// RV32: msltu{{[[:space:]]+a0, a1, a0}}
+// RV64: pmsltu.w{{[[:space:]]+a0, a1, a0}}
+uint32_t test_msgtu_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_msgtu_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msne_i32_u32:
+// RV32: mseq{{[[:space:]]+a0, a0, a1}}
+// RV32-NEXT: not
+// RV64: pmseq.w{{[[:space:]]+a0, a0, a1}}
+// RV64-NEXT: not
+uint32_t test_msne_i32_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_msne_i32_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msne_u32_u32:
+// RV32: mseq{{[[:space:]]+a0, a0, a1}}
+// RV32-NEXT: not
+// RV64: pmseq.w{{[[:space:]]+a0, a0, a1}}
+// RV64-NEXT: not
+uint32_t test_msne_u32_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_msne_u32_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msge_u32:
+// RV32: mslt{{[[:space:]]+a0, a0, a1}}
+// RV32-NEXT: not
+// RV64: pmslt.w{{[[:space:]]+a0, a0, a1}}
+// RV64-NEXT: not
+uint32_t test_msge_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_msge_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msle_u32:
+// RV32: mslt{{[[:space:]]+a0, a1, a0}}
+// RV32-NEXT: not
+// RV64: pmslt.w{{[[:space:]]+a0, a1, a0}}
+// RV64-NEXT: not
+uint32_t test_msle_u32(int32_t rs1, int32_t rs2) {
+ return __riscv_msle_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msgeu_u32:
+// RV32: msltu{{[[:space:]]+a0, a0, a1}}
+// RV32-NEXT: not
+// RV64: pmsltu.w{{[[:space:]]+a0, a0, a1}}
+// RV64-NEXT: not
+uint32_t test_msgeu_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_msgeu_u32(rs1, rs2);
+}
+
+// CHECK-LABEL: test_msleu_u32:
+// RV32: msltu{{[[:space:]]+a0, a1, a0}}
+// RV32-NEXT: not
+// RV64: pmsltu.w{{[[:space:]]+a0, a1, a0}}
+// RV64-NEXT: not
+uint32_t test_msleu_u32(uint32_t rs1, uint32_t rs2) {
+ return __riscv_msleu_u32(rs1, rs2);
+}
diff --git a/llvm/include/llvm/IR/IntrinsicsRISCV.td b/llvm/include/llvm/IR/IntrinsicsRISCV.td
index c5a5d4b4a61c11..5ca4a868b3bb5c 100644
--- a/llvm/include/llvm/IR/IntrinsicsRISCV.td
+++ b/llvm/include/llvm/IR/IntrinsicsRISCV.td
@@ -2184,6 +2184,15 @@ class RVPBinaryIntrinsic
def int_riscv_asub_i32 : RVPScalarBinaryIntrinsic;
def int_riscv_asubu_u32 : RVPScalarBinaryIntrinsic;
+ // Scalar Comparison. The result is a 0/-1 mask; the derived forms
+ // (msne/msgt/msge/...) are composed in the header.
+ class RVPScalarCmpIntrinsic
+ : DefaultAttrsIntrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
+ [IntrNoMem, IntrSpeculatable]>;
+ def int_riscv_mseq : RVPScalarCmpIntrinsic;
+ def int_riscv_mslt : RVPScalarCmpIntrinsic;
+ def int_riscv_msltu : RVPScalarCmpIntrinsic;
+
// Scalar Multiply High. On RV32 these map to the M-extension mulh
// instructions and the P-extension mulhr instructions.
class RVPScalarMulHighIntrinsic
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 0669ac9d4ba555..6ba075ca43c30d 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -12476,6 +12476,12 @@ static unsigned getRVPScalarOpcode(unsigned IntNo) {
return ISD::AVGSUBFLOORS;
case Intrinsic::riscv_asubu_u32:
return ISD::AVGSUBFLOORU;
+ case Intrinsic::riscv_mseq:
+ return RISCVISD::MSEQ;
+ case Intrinsic::riscv_mslt:
+ return RISCVISD::MSLT;
+ case Intrinsic::riscv_msltu:
+ return RISCVISD::MSLTU;
case Intrinsic::riscv_mulhr_i32:
return RISCVISD::MULHR;
case Intrinsic::riscv_mulhru_u32:
@@ -13463,6 +13469,9 @@ SDValue RISCVTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
case Intrinsic::riscv_aaddu_u32:
case Intrinsic::riscv_asub_i32:
case Intrinsic::riscv_asubu_u32:
+ case Intrinsic::riscv_mseq:
+ case Intrinsic::riscv_mslt:
+ case Intrinsic::riscv_msltu:
case Intrinsic::riscv_mulhr_i32:
case Intrinsic::riscv_mulhru_u32:
case Intrinsic::riscv_mulhsu_i32:
@@ -18518,6 +18527,21 @@ void RISCVTargetLowering::ReplaceNodeResults(SDNode *N,
Results.push_back(DAG.getExtractSubvector(DL, VT, Res, 0));
return;
}
+ case Intrinsic::riscv_mseq:
+ case Intrinsic::riscv_mslt:
+ case Intrinsic::riscv_msltu: {
+ // RV64 uses the packed .w instruction on the low word.
+ if (!Subtarget.is64Bit() || N->getValueType(0) != MVT::i32)
+ return;
+ unsigned Opc = getRVPScalarOpcode(IntNo);
+ SDValue LHS =
+ DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(1));
+ SDValue RHS =
+ DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(2));
+ SDValue Res = DAG.getNode(Opc, DL, MVT::i64, LHS, RHS);
+ Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Res));
+ return;
+ }
case Intrinsic::riscv_aadd_i32:
case Intrinsic::riscv_aaddu_u32:
case Intrinsic::riscv_asub_i32:
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
index a2a3a34dcb252c..6381cca6c2040c 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
@@ -2035,6 +2035,11 @@ def riscv_mulhr : RVSDNode<"MULHR", SDTIntBinOp, [SDNPCommutative]>;
def riscv_mulhru : RVSDNode<"MULHRU", SDTIntBinOp, [SDNPCommutative]>;
def riscv_mulhrsu : RVSDNode<"MULHRSU", SDTIntBinOp>;
+// Scalar comparison. The result is a 0/-1 mask.
+def riscv_mseq : RVSDNode<"MSEQ", SDTIntBinOp, [SDNPCommutative]>;
+def riscv_mslt : RVSDNode<"MSLT", SDTIntBinOp>;
+def riscv_msltu : RVSDNode<"MSLTU", SDTIntBinOp>;
+
def SDT_RISCVSameTernary : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>,
SDTCisSameAs<0, 2>,
SDTCisSameAs<0, 3>]>;
@@ -2617,6 +2622,11 @@ let append Predicates = [IsRV32] in {
def : PatGprGpr<avgsubfloors, ASUB, i32>;
def : PatGprGpr<avgsubflooru, ASUBU, i32>;
+ // 32-bit comparison patterns
+ def : PatGprGpr<riscv_mseq, MSEQ, i32>;
+ def : PatGprGpr<riscv_mslt, MSLT, i32>;
+ def : PatGprGpr<riscv_msltu, MSLTU, i32>;
+
// 32-bit multiply high rounding patterns
def : PatGprGpr<riscv_mulhr, MULHR, i32>;
def : PatGprGpr<riscv_mulhru, MULHRU, i32>;
@@ -3343,6 +3353,11 @@ let append Predicates = [IsRV64] in {
def : PatGpr<bitreverse, REV_RV64>;
+ // 32-bit comparison patterns
+ def : PatGprGpr<riscv_mseq, PMSEQ_W>;
+ def : PatGprGpr<riscv_mslt, PMSLT_W>;
+ def : PatGprGpr<riscv_msltu, PMSLTU_W>;
+
// Packed narrowing clip pair.
def : Pat<(v8i8 (riscv_pnclipp (v4i16 GPR:$rs1), GPR:$rs2)),
(PNCLIPP_B GPR:$rs1, GPR:$rs2)>;
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
index 5b4ab64b8a86eb..941f6aa945230e 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
@@ -1644,3 +1644,37 @@ define i64 @test_usati_u64_w63(i64 %a) {
%res = call i64 @llvm.riscv.usati.i64(i64 %a, i32 63)
ret i64 %res
}
+
+declare i32 @llvm.riscv.mseq(i32, i32)
+declare i32 @llvm.riscv.mslt(i32, i32)
+declare i32 @llvm.riscv.msltu(i32, i32)
+
+define signext i32 @mseq_i32_sext(i32 signext %a, i32 signext %b) nounwind {
+; CHECK-LABEL: mseq_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmseq.w a0, a0, a1
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mseq(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define signext i32 @mslt_i32_sext(i32 signext %a, i32 signext %b) nounwind {
+; CHECK-LABEL: mslt_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmslt.w a0, a0, a1
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mslt(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define signext i32 @msltu_i32_sext(i32 signext %a, i32 signext %b) nounwind {
+; CHECK-LABEL: msltu_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmsltu.w a0, a0, a1
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.msltu(i32 %a, i32 %b)
+ ret i32 %r
+}
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar.ll b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
index 73d31ce1a95514..dae45f8736b57f 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
@@ -4638,3 +4638,193 @@ define i64 @srxi_i64_103(i64 %a, i64 %b) {
%1 = tail call i64 @llvm.fshr.i64(i64 %a, i64 %b, i64 103)
ret i64 %1
}
+
+declare i32 @llvm.riscv.mseq(i32, i32)
+declare i32 @llvm.riscv.mslt(i32, i32)
+declare i32 @llvm.riscv.msltu(i32, i32)
+
+define i32 @mseq_i32_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: mseq_i32_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mseq a0, a0, a1
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mseq_i32_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmseq.w a0, a0, a1
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mseq(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define i32 @mseq_u32_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: mseq_u32_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mseq a0, a0, a1
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mseq_u32_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmseq.w a0, a0, a1
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mseq(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define i32 @mslt_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: mslt_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mslt a0, a0, a1
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mslt_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmslt.w a0, a0, a1
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mslt(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define i32 @msgt_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msgt_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mslt a0, a1, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msgt_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmslt.w a0, a1, a0
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mslt(i32 %b, i32 %a)
+ ret i32 %r
+}
+
+define i32 @msltu_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msltu_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: msltu a0, a0, a1
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msltu_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmsltu.w a0, a0, a1
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.msltu(i32 %a, i32 %b)
+ ret i32 %r
+}
+
+define i32 @msgtu_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msgtu_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: msltu a0, a1, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msgtu_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmsltu.w a0, a1, a0
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.msltu(i32 %b, i32 %a)
+ ret i32 %r
+}
+
+define i32 @msne_i32_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msne_i32_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mseq a0, a0, a1
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msne_i32_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmseq.w a0, a0, a1
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.mseq(i32 %a, i32 %b)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
+
+define i32 @msne_u32_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msne_u32_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mseq a0, a0, a1
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msne_u32_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmseq.w a0, a0, a1
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.mseq(i32 %a, i32 %b)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
+
+define i32 @msge_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msge_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mslt a0, a0, a1
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msge_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmslt.w a0, a0, a1
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.mslt(i32 %a, i32 %b)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
+
+define i32 @msle_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msle_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: mslt a0, a1, a0
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msle_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmslt.w a0, a1, a0
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.mslt(i32 %b, i32 %a)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
+
+define i32 @msgeu_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msgeu_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: msltu a0, a0, a1
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msgeu_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmsltu.w a0, a0, a1
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.msltu(i32 %a, i32 %b)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
+
+define i32 @msleu_u32(i32 %a, i32 %b) nounwind {
+; RV32-LABEL: msleu_u32:
+; RV32: # %bb.0:
+; RV32-NEXT: msltu a0, a1, a0
+; RV32-NEXT: not a0, a0
+; RV32-NEXT: ret
+;
+; RV64-LABEL: msleu_u32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmsltu.w a0, a1, a0
+; RV64-NEXT: not a0, a0
+; RV64-NEXT: ret
+ %c = call i32 @llvm.riscv.msltu(i32 %b, i32 %a)
+ %r = xor i32 %c, -1
+ ret i32 %r
+}
>From 5591d81b2f5b0d67de5f16a6489ec1ded17a09a9 Mon Sep 17 00:00:00 2001
From: SiHuaN <liyongtai at iscas.ac.cn>
Date: Thu, 12 Nov 2026 07:39:45 +0000
Subject: [PATCH 2/2] [RISCV][P-ext] Use v2i32 setcc for RV64 scalar
comparisons
Use SCALAR_TO_VECTOR and a v2i32 SETCC on RV64, then extract the low
element, instead of extending the operands to i64.
---
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 24 +++++++++++++++------
llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 5 -----
2 files changed, 18 insertions(+), 11 deletions(-)
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 6ba075ca43c30d..4aa6e508dfa6b5 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -18530,16 +18530,28 @@ void RISCVTargetLowering::ReplaceNodeResults(SDNode *N,
case Intrinsic::riscv_mseq:
case Intrinsic::riscv_mslt:
case Intrinsic::riscv_msltu: {
- // RV64 uses the packed .w instruction on the low word.
if (!Subtarget.is64Bit() || N->getValueType(0) != MVT::i32)
return;
- unsigned Opc = getRVPScalarOpcode(IntNo);
+ ISD::CondCode CC;
+ switch (IntNo) {
+ case Intrinsic::riscv_mseq:
+ CC = ISD::SETEQ;
+ break;
+ case Intrinsic::riscv_mslt:
+ CC = ISD::SETLT;
+ break;
+ case Intrinsic::riscv_msltu:
+ CC = ISD::SETULT;
+ break;
+ default:
+ llvm_unreachable("Unexpected comparison intrinsic");
+ }
SDValue LHS =
- DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(1));
+ DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2i32, N->getOperand(1));
SDValue RHS =
- DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(2));
- SDValue Res = DAG.getNode(Opc, DL, MVT::i64, LHS, RHS);
- Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Res));
+ DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2i32, N->getOperand(2));
+ SDValue Cmp = DAG.getSetCC(DL, MVT::v2i32, LHS, RHS, CC);
+ Results.push_back(DAG.getExtractVectorElt(DL, MVT::i32, Cmp, 0));
return;
}
case Intrinsic::riscv_aadd_i32:
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
index 6381cca6c2040c..4aa2fec7167442 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
@@ -3353,11 +3353,6 @@ let append Predicates = [IsRV64] in {
def : PatGpr<bitreverse, REV_RV64>;
- // 32-bit comparison patterns
- def : PatGprGpr<riscv_mseq, PMSEQ_W>;
- def : PatGprGpr<riscv_mslt, PMSLT_W>;
- def : PatGprGpr<riscv_msltu, PMSLTU_W>;
-
// Packed narrowing clip pair.
def : Pat<(v8i8 (riscv_pnclipp (v4i16 GPR:$rs1), GPR:$rs2)),
(PNCLIPP_B GPR:$rs1, GPR:$rs2)>;
More information about the cfe-commits
mailing list