[clang] [llvm] [RISCV][P-ext] Add scalar merge intrinsics (PR #239119)
Craig Topper via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 4 23:00:26 PST 2026
https://github.com/topperc created https://github.com/llvm/llvm-project/pull/239119
Assisted-by: Claude
>From 7c8309af2f9d01d54b9a286e7ea0be871c138a69 Mon Sep 17 00:00:00 2001
From: Craig Topper <craig.topper at sifive.com>
Date: Wed, 4 Nov 2026 22:59:31 -0800
Subject: [PATCH] [RISCV][P-ext] Add scalar merge intrinsics
Assisted-by: Claude
---
clang/include/clang/Basic/BuiltinsRISCV.td | 5 ++
clang/lib/CodeGen/TargetBuiltins/RISCV.cpp | 7 ++
clang/lib/Headers/riscv_packed_simd.h | 25 +++++++
clang/test/CodeGen/RISCV/rvp-intrinsics.c | 56 ++++++++++++++
.../riscv_packed_simd.c | 74 +++++++++++++++++++
llvm/include/llvm/IR/IntrinsicsRISCV.td | 7 ++
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 19 +++++
llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll | 29 ++++++++
llvm/test/CodeGen/RISCV/rvp-scalar.ll | 29 ++++++++
9 files changed, 251 insertions(+)
diff --git a/clang/include/clang/Basic/BuiltinsRISCV.td b/clang/include/clang/Basic/BuiltinsRISCV.td
index 704547a6830048..0aa5522bd18c1b 100644
--- a/clang/include/clang/Basic/BuiltinsRISCV.td
+++ b/clang/include/clang/Basic/BuiltinsRISCV.td
@@ -265,6 +265,11 @@ def pmerge_u32x2 : RISCVBuiltin<"_Vector<2, unsigned int>(_Vector<2, unsigned in
let Features = "experimental-p,64bit" in
def rev16_64 : RISCVBuiltin<"uint64_t(uint64_t)">;
+// Scalar Merge
+def merge_u32 : RISCVBuiltin<"uint32_t(uint32_t, uint32_t, uint32_t)">;
+let Features = "experimental-p,64bit" in
+def merge_u64 : RISCVBuiltin<"uint64_t(uint64_t, uint64_t, uint64_t)">;
+
// Scalar Averaging Addition and Subtraction
def aadd_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t)">;
def aaddu_u32 : RISCVBuiltin<"uint32_t(uint32_t, uint32_t)">;
diff --git a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
index d2a646f9e1bc65..500db019e1de11 100644
--- a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
+++ b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
@@ -1686,6 +1686,13 @@ Value *CodeGenFunction::EmitRISCVBuiltinExpr(unsigned BuiltinID,
break;
}
+ // Scalar Merge
+ case RISCV::BI__builtin_riscv_merge_u32:
+ case RISCV::BI__builtin_riscv_merge_u64:
+ ID = Intrinsic::riscv_merge;
+ IntrinsicTypes = {ResultType};
+ break;
+
// Scalar Averaging Addition and Subtraction
case RISCV::BI__builtin_riscv_aadd_i32:
ID = Intrinsic::riscv_aadd_i32;
diff --git a/clang/lib/Headers/riscv_packed_simd.h b/clang/lib/Headers/riscv_packed_simd.h
index 10c253741587a9..e94cecd63def77 100644
--- a/clang/lib/Headers/riscv_packed_simd.h
+++ b/clang/lib/Headers/riscv_packed_simd.h
@@ -983,6 +983,31 @@ __riscv_wzip16p_64(uint32_t __rs1, uint32_t __rs2) {
return (uint64_t)__riscv_pzip_u16x4((uint16x2_t)__rs1, (uint16x2_t)__rs2);
}
+/* Scalar Merge */
+static __inline__ int32_t __DEFAULT_FN_ATTRS
+__riscv_merge_i32(int32_t __rs1, int32_t __rs2, uint32_t __rd) {
+ return (int32_t)__builtin_riscv_merge_u32((uint32_t)__rs1, (uint32_t)__rs2,
+ __rd);
+}
+
+static __inline__ uint32_t __DEFAULT_FN_ATTRS
+__riscv_merge_u32(uint32_t __rs1, uint32_t __rs2, uint32_t __rd) {
+ return __builtin_riscv_merge_u32(__rs1, __rs2, __rd);
+}
+
+#if __riscv_xlen == 64
+static __inline__ int64_t __DEFAULT_FN_ATTRS
+__riscv_merge_i64(int64_t __rs1, int64_t __rs2, uint64_t __rd) {
+ return (int64_t)__builtin_riscv_merge_u64((uint64_t)__rs1, (uint64_t)__rs2,
+ __rd);
+}
+
+static __inline__ uint64_t __DEFAULT_FN_ATTRS
+__riscv_merge_u64(uint64_t __rs1, uint64_t __rs2, uint64_t __rd) {
+ return __builtin_riscv_merge_u64(__rs1, __rs2, __rd);
+}
+#endif
+
/* Packed Unzip */
__packed_unzipe4(punzipe_i8x4, int8x4_t, int8x8_t)
__packed_unzipo4(punzipo_i8x4, int8x4_t, int8x8_t)
diff --git a/clang/test/CodeGen/RISCV/rvp-intrinsics.c b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
index 0a64157fbd2ca4..1dd8c84b3e7764 100644
--- a/clang/test/CodeGen/RISCV/rvp-intrinsics.c
+++ b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
@@ -252,6 +252,62 @@ uint64_t test_wzip16p_64_constant(void) {
return __riscv_wzip16p_64(0x87654321, 0xfedcba98);
}
+/* Scalar Merge */
+
+// RV32-LABEL: define dso_local i32 @test_merge_i32(
+// RV32-SAME: i32 noundef [[RS1:%.*]], i32 noundef [[RS2:%.*]], i32 noundef [[RD:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.merge.i32(i32 [[RS1]], i32 [[RS2]], i32 [[RD]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_merge_i32(
+// RV64-SAME: i32 noundef signext [[RS1:%.*]], i32 noundef signext [[RS2:%.*]], i32 noundef signext [[RD:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.merge.i32(i32 [[RS1]], i32 [[RS2]], i32 [[RD]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+int32_t test_merge_i32(int32_t rs1, int32_t rs2, uint32_t rd) {
+ return __riscv_merge_i32(rs1, rs2, rd);
+}
+
+// RV32-LABEL: define dso_local i32 @test_merge_u32(
+// RV32-SAME: i32 noundef [[RS1:%.*]], i32 noundef [[RS2:%.*]], i32 noundef [[RD:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.merge.i32(i32 [[RS1]], i32 [[RS2]], i32 [[RD]])
+// RV32-NEXT: ret i32 [[TMP0]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_merge_u32(
+// RV64-SAME: i32 noundef signext [[RS1:%.*]], i32 noundef signext [[RS2:%.*]], i32 noundef signext [[RD:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i32 @llvm.riscv.merge.i32(i32 [[RS1]], i32 [[RS2]], i32 [[RD]])
+// RV64-NEXT: ret i32 [[TMP0]]
+//
+uint32_t test_merge_u32(uint32_t rs1, uint32_t rs2, uint32_t rd) {
+ return __riscv_merge_u32(rs1, rs2, rd);
+}
+
+#if __riscv_xlen == 64
+// RV64-LABEL: define dso_local i64 @test_merge_i64(
+// RV64-SAME: i64 noundef [[RS1:%.*]], i64 noundef [[RS2:%.*]], i64 noundef [[RD:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i64 @llvm.riscv.merge.i64(i64 [[RS1]], i64 [[RS2]], i64 [[RD]])
+// RV64-NEXT: ret i64 [[TMP0]]
+//
+int64_t test_merge_i64(int64_t rs1, int64_t rs2, uint64_t rd) {
+ return __riscv_merge_i64(rs1, rs2, rd);
+}
+
+// RV64-LABEL: define dso_local i64 @test_merge_u64(
+// RV64-SAME: i64 noundef [[RS1:%.*]], i64 noundef [[RS2:%.*]], i64 noundef [[RD:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = call i64 @llvm.riscv.merge.i64(i64 [[RS1]], i64 [[RS2]], i64 [[RD]])
+// RV64-NEXT: ret i64 [[TMP0]]
+//
+uint64_t test_merge_u64(uint64_t rs1, uint64_t rs2, uint64_t rd) {
+ return __riscv_merge_u64(rs1, rs2, rd);
+}
+#endif
+
/* Scalar Saturating Addition and Subtraction */
// RV32-LABEL: define dso_local i32 @test_sadd_i32(
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 24b640756a5f9b..663d89365a2353 100644
--- a/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
+++ b/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
@@ -6336,3 +6336,77 @@ 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);
}
+
+// CHECK-LABEL: test_merge_merge_u32:
+// CHECK: merge{{[[:space:]]}}
+uint32_t test_merge_merge_u32(uint32_t rd, uint32_t rs1, uint32_t rs2) {
+ return __riscv_merge_u32(rs1, rs2, rd);
+}
+
+// CHECK-LABEL: test_merge_mvm_u32:
+// CHECK: mvm{{[[:space:]]}}
+uint32_t test_merge_mvm_u32(uint32_t rs1, uint32_t rd, uint32_t rs2) {
+ return __riscv_merge_u32(rs1, rs2, rd);
+}
+
+// CHECK-LABEL: test_merge_mvmn_u32:
+// CHECK: mvmn{{[[:space:]]}}
+uint32_t test_merge_mvmn_u32(uint32_t rs2, uint32_t rs1, uint32_t rd) {
+ return __riscv_merge_u32(rs1, rs2, rd);
+}
+
+// CHECK-LABEL: test_merge_merge_i32:
+// CHECK: merge{{[[:space:]]}}
+int32_t test_merge_merge_i32(uint32_t rd, int32_t rs1, int32_t rs2) {
+ return __riscv_merge_i32(rs1, rs2, rd);
+}
+
+// CHECK-LABEL: test_merge_mvm_i32:
+// CHECK: mvm{{[[:space:]]}}
+int32_t test_merge_mvm_i32(int32_t rs1, uint32_t rd, int32_t rs2) {
+ return __riscv_merge_i32(rs1, rs2, rd);
+}
+
+// CHECK-LABEL: test_merge_mvmn_i32:
+// CHECK: mvmn{{[[:space:]]}}
+int32_t test_merge_mvmn_i32(int32_t rs2, int32_t rs1, uint32_t rd) {
+ return __riscv_merge_i32(rs1, rs2, rd);
+}
+
+#if __riscv_xlen == 64
+// RV64-LABEL: test_merge_merge_u64:
+// RV64: merge{{[[:space:]]}}
+uint64_t test_merge_merge_u64(uint64_t rd, uint64_t rs1, uint64_t rs2) {
+ return __riscv_merge_u64(rs1, rs2, rd);
+}
+
+// RV64-LABEL: test_merge_mvm_u64:
+// RV64: mvm{{[[:space:]]}}
+uint64_t test_merge_mvm_u64(uint64_t rs1, uint64_t rd, uint64_t rs2) {
+ return __riscv_merge_u64(rs1, rs2, rd);
+}
+
+// RV64-LABEL: test_merge_mvmn_u64:
+// RV64: mvmn{{[[:space:]]}}
+uint64_t test_merge_mvmn_u64(uint64_t rs2, uint64_t rs1, uint64_t rd) {
+ return __riscv_merge_u64(rs1, rs2, rd);
+}
+// RV64-LABEL: test_merge_merge_i64:
+// RV64: merge{{[[:space:]]}}
+int64_t test_merge_merge_i64(uint64_t rd, int64_t rs1, int64_t rs2) {
+ return __riscv_merge_i64(rs1, rs2, rd);
+}
+
+// RV64-LABEL: test_merge_mvm_i64:
+// RV64: mvm{{[[:space:]]}}
+int64_t test_merge_mvm_i64(int64_t rs1, uint64_t rd, int64_t rs2) {
+ return __riscv_merge_i64(rs1, rs2, rd);
+}
+
+// RV64-LABEL: test_merge_mvmn_i64:
+// RV64: mvmn{{[[:space:]]}}
+int64_t test_merge_mvmn_i64(int64_t rs2, int64_t rs1, uint64_t rd) {
+ return __riscv_merge_i64(rs1, rs2, rd);
+}
+
+#endif
diff --git a/llvm/include/llvm/IR/IntrinsicsRISCV.td b/llvm/include/llvm/IR/IntrinsicsRISCV.td
index 3da39e1255d5ad..f51df0c9d2c0df 100644
--- a/llvm/include/llvm/IR/IntrinsicsRISCV.td
+++ b/llvm/include/llvm/IR/IntrinsicsRISCV.td
@@ -2154,6 +2154,13 @@ class RVPBinaryIntrinsic
[IntrNoMem, IntrSpeculatable]>;
def int_riscv_pmerge : RVPTernaryIntrinsic;
+ // Scalar Merge. Operands are (rs1, rs2, rd).
+ def int_riscv_merge
+ : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+ [LLVMMatchType<0>, LLVMMatchType<0>,
+ LLVMMatchType<0>],
+ [IntrNoMem, IntrSpeculatable]>;
+
// Reverse the order of the 16-bit halfwords of a 64-bit value (RV64 only).
def int_riscv_rev16_64 : DefaultAttrsIntrinsic<[llvm_i64_ty], [llvm_i64_ty],
[IntrNoMem, IntrSpeculatable]>;
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index f67c7a3dd5b911..11723c81fbf41d 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -13781,6 +13781,10 @@ SDValue RISCVTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
: RISCVISD::PM4ADDA;
return DAG.getNode(AccOpc, DL, MVT::i64, Rd, A, B);
}
+ case Intrinsic::riscv_merge:
+ // Scalar merge: (rs1, rs2, rd) -> MERGE(mask=rd, rs1, rs2).
+ return DAG.getNode(RISCVISD::MERGE, DL, Op.getValueType(), Op.getOperand(3),
+ Op.getOperand(1), Op.getOperand(2));
case Intrinsic::riscv_pmerge: {
EVT VT = Op.getValueType();
// 64-bit packed types on RV32: split into two 32-bit halves.
@@ -18386,6 +18390,21 @@ void RISCVTargetLowering::ReplaceNodeResults(SDNode *N,
Acc.getValue(0), Acc.getValue(1)));
return;
}
+ case Intrinsic::riscv_merge: {
+ // Scalar merge on RV64 i32: the operands are already in GPRs, so
+ // any-extend to i64, merge, and truncate. Bitwise select is exact on the
+ // extended bits, so the low 32 bits of the result are correct. RV32 i64
+ // is not supported.
+ EVT VT = N->getValueType(0);
+ if (VT != MVT::i32 || !Subtarget.is64Bit())
+ return;
+ SDValue Rd = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(3));
+ SDValue Rs1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(1));
+ SDValue Rs2 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(2));
+ SDValue Res = DAG.getNode(RISCVISD::MERGE, DL, MVT::i64, Rd, Rs1, Rs2);
+ Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Res));
+ return;
+ }
case Intrinsic::riscv_pnclipp:
case Intrinsic::riscv_pnclipup: {
bool IsSigned = IntNo == Intrinsic::riscv_pnclipp;
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
index 5b4ab64b8a86eb..7cc88f5b82e30c 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
@@ -1644,3 +1644,32 @@ define i64 @test_usati_u64_w63(i64 %a) {
%res = call i64 @llvm.riscv.usati.i64(i64 %a, i32 63)
ret i64 %res
}
+
+declare i64 @llvm.riscv.merge.i64(i64, i64, i64)
+
+define i64 @merge_intrinsic_i64_merge(i64 %rd, i64 %rs1, i64 %rs2) nounwind {
+; CHECK-LABEL: merge_intrinsic_i64_merge:
+; CHECK: # %bb.0:
+; CHECK-NEXT: merge a0, a1, a2
+; CHECK-NEXT: ret
+ %res = call i64 @llvm.riscv.merge.i64(i64 %rs1, i64 %rs2, i64 %rd)
+ ret i64 %res
+}
+
+define i64 @merge_intrinsic_i64_mvm(i64 %rs1, i64 %rd, i64 %rs2) nounwind {
+; CHECK-LABEL: merge_intrinsic_i64_mvm:
+; CHECK: # %bb.0:
+; CHECK-NEXT: mvm a0, a2, a1
+; CHECK-NEXT: ret
+ %res = call i64 @llvm.riscv.merge.i64(i64 %rs1, i64 %rs2, i64 %rd)
+ ret i64 %res
+}
+
+define i64 @merge_intrinsic_i64_mvmn(i64 %rs2, i64 %rs1, i64 %rd) nounwind {
+; CHECK-LABEL: merge_intrinsic_i64_mvmn:
+; CHECK: # %bb.0:
+; CHECK-NEXT: mvmn a0, a1, a2
+; CHECK-NEXT: ret
+ %res = call i64 @llvm.riscv.merge.i64(i64 %rs1, i64 %rs2, i64 %rd)
+ ret i64 %res
+}
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar.ll b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
index 73d31ce1a95514..6d4b875f20f0d6 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
@@ -4638,3 +4638,32 @@ 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.merge.i32(i32, i32, i32)
+
+define i32 @merge_intrinsic_i32_merge(i32 %rd, i32 %rs1, i32 %rs2) nounwind {
+; CHECK-LABEL: merge_intrinsic_i32_merge:
+; CHECK: # %bb.0:
+; CHECK-NEXT: merge a0, a1, a2
+; CHECK-NEXT: ret
+ %res = call i32 @llvm.riscv.merge.i32(i32 %rs1, i32 %rs2, i32 %rd)
+ ret i32 %res
+}
+
+define i32 @merge_intrinsic_i32_mvm(i32 %rs1, i32 %rd, i32 %rs2) nounwind {
+; CHECK-LABEL: merge_intrinsic_i32_mvm:
+; CHECK: # %bb.0:
+; CHECK-NEXT: mvm a0, a2, a1
+; CHECK-NEXT: ret
+ %res = call i32 @llvm.riscv.merge.i32(i32 %rs1, i32 %rs2, i32 %rd)
+ ret i32 %res
+}
+
+define i32 @merge_intrinsic_i32_mvmn(i32 %rs2, i32 %rs1, i32 %rd) nounwind {
+; CHECK-LABEL: merge_intrinsic_i32_mvmn:
+; CHECK: # %bb.0:
+; CHECK-NEXT: mvmn a0, a1, a2
+; CHECK-NEXT: ret
+ %res = call i32 @llvm.riscv.merge.i32(i32 %rs1, i32 %rs2, i32 %rd)
+ ret i32 %res
+}
More information about the cfe-commits
mailing list