[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