[clang] [llvm] [RISCV][P-ext] Add scalar mhacc.h0/h1 intrinsics (PR #242195)
via cfe-commits
cfe-commits at lists.llvm.org
Thu Nov 12 22:46:38 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-codegen
@llvm/pr-subscribers-llvm-ir
Author: SiHuaN (sihuan)
<details>
<summary>Changes</summary>
Add the scalar Multiply High Accumulate h0/h1 intrinsics from the
P-extension intrinsic spec:
https://github.com/riscv/riscv-p-spec/blob/master/P-ext-intrinsics.adoc#packed-multiply-high-parts-accumulate
- `__riscv_mhacc_h0_i32`
- `__riscv_mhacc_h1_i32`
- `__riscv_mhaccsu_h0_i32`
- `__riscv_mhaccsu_h1_i32`
---
Full diff: https://github.com/llvm/llvm-project/pull/242195.diff
9 Files Affected:
- (modified) clang/include/clang/Basic/BuiltinsRISCV.td (+5)
- (modified) clang/lib/CodeGen/TargetBuiltins/RISCV.cpp (+23)
- (modified) clang/lib/Headers/riscv_packed_simd.h (+4)
- (modified) clang/test/CodeGen/RISCV/rvp-intrinsics.c (+72)
- (modified) cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c (+28)
- (modified) llvm/include/llvm/IR/IntrinsicsRISCV.td (+12)
- (modified) llvm/lib/Target/RISCV/RISCVISelLowering.cpp (+43-1)
- (modified) llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll (+45)
- (modified) llvm/test/CodeGen/RISCV/rvp-scalar.ll (+61)
``````````diff
diff --git a/clang/include/clang/Basic/BuiltinsRISCV.td b/clang/include/clang/Basic/BuiltinsRISCV.td
index fa4cb4808f7cf..a460b957b4c4f 100644
--- a/clang/include/clang/Basic/BuiltinsRISCV.td
+++ b/clang/include/clang/Basic/BuiltinsRISCV.td
@@ -298,6 +298,11 @@ def mhraccu_u32 : RISCVBuiltin<"uint32_t(uint32_t, uint32_t, uint32_t)">;
def mhaccsu_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, uint32_t)">;
def mhraccsu_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, uint32_t)">;
+def mhacc_h0_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, _Vector<2, short>)">;
+def mhacc_h1_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, _Vector<2, short>)">;
+def mhaccsu_h0_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, _Vector<2, unsigned short>)">;
+def mhaccsu_h1_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t, _Vector<2, unsigned short>)">;
+
// Scalar "Q-format" Multiplication
def mulq_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t)">;
def mulqr_i32 : RISCVBuiltin<"int32_t(int32_t, int32_t)">;
diff --git a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
index 423a15b516786..c2f7a13935107 100644
--- a/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
+++ b/clang/lib/CodeGen/TargetBuiltins/RISCV.cpp
@@ -1748,6 +1748,29 @@ Value *CodeGenFunction::EmitRISCVBuiltinExpr(unsigned BuiltinID,
case RISCV::BI__builtin_riscv_mhraccsu_i32:
ID = Intrinsic::riscv_mhraccsu_i32;
break;
+ case RISCV::BI__builtin_riscv_mhacc_h0_i32:
+ case RISCV::BI__builtin_riscv_mhacc_h1_i32:
+ case RISCV::BI__builtin_riscv_mhaccsu_h0_i32:
+ case RISCV::BI__builtin_riscv_mhaccsu_h1_i32: {
+ switch (BuiltinID) {
+ default:
+ llvm_unreachable("unexpected builtin ID");
+ case RISCV::BI__builtin_riscv_mhacc_h0_i32:
+ ID = Intrinsic::riscv_mhacc_h0;
+ break;
+ case RISCV::BI__builtin_riscv_mhacc_h1_i32:
+ ID = Intrinsic::riscv_mhacc_h1;
+ break;
+ case RISCV::BI__builtin_riscv_mhaccsu_h0_i32:
+ ID = Intrinsic::riscv_mhaccsu_h0;
+ break;
+ case RISCV::BI__builtin_riscv_mhaccsu_h1_i32:
+ ID = Intrinsic::riscv_mhaccsu_h1;
+ break;
+ }
+ IntrinsicTypes = {ResultType, Ops[2]->getType()};
+ break;
+ }
// Scalar "Q-format" Multiplication
case RISCV::BI__builtin_riscv_mulq_i32:
diff --git a/clang/lib/Headers/riscv_packed_simd.h b/clang/lib/Headers/riscv_packed_simd.h
index f3a5f5bc25aea..9d39bfe3b4679 100644
--- a/clang/lib/Headers/riscv_packed_simd.h
+++ b/clang/lib/Headers/riscv_packed_simd.h
@@ -514,6 +514,10 @@ __packed_ternary_builtin(mhaccu_u32, uint32_t, __builtin_riscv_mhaccu_u32)
__packed_ternary_builtin(mhraccu_u32, uint32_t, __builtin_riscv_mhraccu_u32)
__packed_ternary_builtin_mixed(mhaccsu_i32, int32_t, int32_t, uint32_t, __builtin_riscv_mhaccsu_i32)
__packed_ternary_builtin_mixed(mhraccsu_i32, int32_t, int32_t, uint32_t, __builtin_riscv_mhraccsu_i32)
+__packed_ternary_builtin_mixed(mhacc_h0_i32, int32_t, int32_t, int16x2_t, __builtin_riscv_mhacc_h0_i32)
+__packed_ternary_builtin_mixed(mhacc_h1_i32, int32_t, int32_t, int16x2_t, __builtin_riscv_mhacc_h1_i32)
+__packed_ternary_builtin_mixed(mhaccsu_h0_i32, int32_t, int32_t, uint16x2_t, __builtin_riscv_mhaccsu_h0_i32)
+__packed_ternary_builtin_mixed(mhaccsu_h1_i32, int32_t, int32_t, uint16x2_t, __builtin_riscv_mhaccsu_h1_i32)
/* Scalar "Q-format" Multiplication */
__packed_binary_builtin(mulq_i32, int32_t, __builtin_riscv_mulq_i32)
diff --git a/clang/test/CodeGen/RISCV/rvp-intrinsics.c b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
index f7cf8eccf99f7..485808004cb14 100644
--- a/clang/test/CodeGen/RISCV/rvp-intrinsics.c
+++ b/clang/test/CodeGen/RISCV/rvp-intrinsics.c
@@ -736,6 +736,78 @@ int32_t test_mhraccsu_i32(int32_t rd, int32_t a, uint32_t b) {
return __riscv_mhraccsu_i32(rd, a, b);
}
+// RV32-LABEL: define dso_local i32 @test_mhacc_h0_i32(
+// RV32-SAME: i32 noundef [[RD:%.*]], i32 noundef [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV32-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV32-NEXT: ret i32 [[TMP1]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mhacc_h0_i32(
+// RV64-SAME: i32 noundef signext [[RD:%.*]], i32 noundef signext [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV64-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV64-NEXT: ret i32 [[TMP1]]
+//
+int32_t test_mhacc_h0_i32(int32_t rd, int32_t a, int16x2_t b) {
+ return __riscv_mhacc_h0_i32(rd, a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_mhacc_h1_i32(
+// RV32-SAME: i32 noundef [[RD:%.*]], i32 noundef [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV32-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV32-NEXT: ret i32 [[TMP1]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mhacc_h1_i32(
+// RV64-SAME: i32 noundef signext [[RD:%.*]], i32 noundef signext [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV64-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV64-NEXT: ret i32 [[TMP1]]
+//
+int32_t test_mhacc_h1_i32(int32_t rd, int32_t a, int16x2_t b) {
+ return __riscv_mhacc_h1_i32(rd, a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_mhaccsu_h0_i32(
+// RV32-SAME: i32 noundef [[RD:%.*]], i32 noundef [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV32-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV32-NEXT: ret i32 [[TMP1]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mhaccsu_h0_i32(
+// RV64-SAME: i32 noundef signext [[RD:%.*]], i32 noundef signext [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV64-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV64-NEXT: ret i32 [[TMP1]]
+//
+int32_t test_mhaccsu_h0_i32(int32_t rd, int32_t a, uint16x2_t b) {
+ return __riscv_mhaccsu_h0_i32(rd, a, b);
+}
+
+// RV32-LABEL: define dso_local i32 @test_mhaccsu_h1_i32(
+// RV32-SAME: i32 noundef [[RD:%.*]], i32 noundef [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV32-NEXT: [[ENTRY:.*:]]
+// RV32-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV32-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV32-NEXT: ret i32 [[TMP1]]
+//
+// RV64-LABEL: define dso_local signext i32 @test_mhaccsu_h1_i32(
+// RV64-SAME: i32 noundef signext [[RD:%.*]], i32 noundef signext [[A:%.*]], i32 noundef [[B_COERCE:%.*]]) #[[ATTR0]] {
+// RV64-NEXT: [[ENTRY:.*:]]
+// RV64-NEXT: [[TMP0:%.*]] = bitcast i32 [[B_COERCE]] to <2 x i16>
+// RV64-NEXT: [[TMP1:%.*]] = call i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32 [[RD]], i32 [[A]], <2 x i16> [[TMP0]])
+// RV64-NEXT: ret i32 [[TMP1]]
+//
+int32_t test_mhaccsu_h1_i32(int32_t rd, int32_t a, uint16x2_t b) {
+ return __riscv_mhaccsu_h1_i32(rd, a, b);
+}
+
/* Scalar "Q-format" Multiplication */
// RV32-LABEL: define dso_local i32 @test_mulq_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 13491cbcf544e..551703b4b9a56 100644
--- a/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
+++ b/cross-project-tests/intrinsic-header-tests/riscv_packed_simd.c
@@ -3245,6 +3245,34 @@ int32_t test_mhraccsu_i32(int32_t rd, int32_t rs1, uint32_t rs2) {
return __riscv_mhraccsu_i32(rd, rs1, rs2);
}
+// CHECK-LABEL: test_mhacc_h0_i32:
+// RV32: mhacc.h0{{[[:space:]]}}
+// RV64: pmhacc.w.h0{{[[:space:]]}}
+int32_t test_mhacc_h0_i32(int32_t rd, int32_t rs1, int16x2_t rs2) {
+ return __riscv_mhacc_h0_i32(rd, rs1, rs2);
+}
+
+// CHECK-LABEL: test_mhacc_h1_i32:
+// RV32: mhacc.h1{{[[:space:]]}}
+// RV64: pmhacc.w.h1{{[[:space:]]}}
+int32_t test_mhacc_h1_i32(int32_t rd, int32_t rs1, int16x2_t rs2) {
+ return __riscv_mhacc_h1_i32(rd, rs1, rs2);
+}
+
+// CHECK-LABEL: test_mhaccsu_h0_i32:
+// RV32: mhaccsu.h0{{[[:space:]]}}
+// RV64: pmhaccsu.w.h0{{[[:space:]]}}
+int32_t test_mhaccsu_h0_i32(int32_t rd, int32_t rs1, uint16x2_t rs2) {
+ return __riscv_mhaccsu_h0_i32(rd, rs1, rs2);
+}
+
+// CHECK-LABEL: test_mhaccsu_h1_i32:
+// RV32: mhaccsu.h1{{[[:space:]]}}
+// RV64: pmhaccsu.w.h1{{[[:space:]]}}
+int32_t test_mhaccsu_h1_i32(int32_t rd, int32_t rs1, uint16x2_t rs2) {
+ return __riscv_mhaccsu_h1_i32(rd, rs1, rs2);
+}
+
// Scalar "Q-format" multiplication
// CHECK-LABEL: test_mulq_i32:
// RV32: mulq{{[[:space:]]}}
diff --git a/llvm/include/llvm/IR/IntrinsicsRISCV.td b/llvm/include/llvm/IR/IntrinsicsRISCV.td
index d077c8e124498..9ce11ff5cd9de 100644
--- a/llvm/include/llvm/IR/IntrinsicsRISCV.td
+++ b/llvm/include/llvm/IR/IntrinsicsRISCV.td
@@ -2209,6 +2209,18 @@ class RVPBinaryIntrinsic
def int_riscv_mhaccsu_i32 : RVPScalarTernaryIntrinsic;
def int_riscv_mhraccsu_i32 : RVPScalarTernaryIntrinsic;
+ // Scalar Multiply High Accumulate with a halfwidth third operand. The
+ // low (h0) or high (h1) halfword of each <2 x i16> element is used.
+ class RVPScalarMulHighAccHalfIntrinsic
+ : DefaultAttrsIntrinsic<[llvm_anyint_ty],
+ [LLVMMatchType<0>, LLVMMatchType<0>,
+ llvm_anyvector_ty],
+ [IntrNoMem, IntrSpeculatable]>;
+ def int_riscv_mhacc_h0 : RVPScalarMulHighAccHalfIntrinsic;
+ def int_riscv_mhacc_h1 : RVPScalarMulHighAccHalfIntrinsic;
+ def int_riscv_mhaccsu_h0 : RVPScalarMulHighAccHalfIntrinsic;
+ def int_riscv_mhaccsu_h1 : RVPScalarMulHighAccHalfIntrinsic;
+
// Scalar "Q-format" Multiplication. On RV64 these map to the packed
// pmulq.w family on the low words.
def int_riscv_mulq_i32 : RVPScalarBinaryIntrinsic;
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 8be82d596e884..20dc584edc9c0 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -12595,15 +12595,19 @@ static unsigned getRVPMulHighAccumulateOpcode(unsigned IntNo) {
static unsigned getRVPMulHighAccumulateHalfOpcode(unsigned IntNo) {
switch (IntNo) {
default:
- llvm_unreachable("Unexpected RISC-V packed multiply high accumulate half "
+ llvm_unreachable("Unexpected RISC-V multiply high accumulate half "
"intrinsic");
case Intrinsic::riscv_pmhacc_half_0:
+ case Intrinsic::riscv_mhacc_h0:
return RISCVISD::MHACC_HALF_0;
case Intrinsic::riscv_pmhacc_half_1:
+ case Intrinsic::riscv_mhacc_h1:
return RISCVISD::MHACC_HALF_1;
case Intrinsic::riscv_pmhaccsu_half_0:
+ case Intrinsic::riscv_mhaccsu_h0:
return RISCVISD::MHACCSU_HALF_0;
case Intrinsic::riscv_pmhaccsu_half_1:
+ case Intrinsic::riscv_mhaccsu_h1:
return RISCVISD::MHACCSU_HALF_1;
}
}
@@ -13599,6 +13603,20 @@ SDValue RISCVTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
return DAG.getNode(MulOpc, DL, VT, Rd, Rs1, Rs2);
}
+ case Intrinsic::riscv_mhacc_h0:
+ case Intrinsic::riscv_mhacc_h1:
+ case Intrinsic::riscv_mhaccsu_h0:
+ case Intrinsic::riscv_mhaccsu_h1: {
+ // The scalar mhacc.h0/h1 forms exist only on RV32; RV64 goes via
+ // ReplaceNodeResults using the packed pmhacc.w.h0/h1 form.
+ EVT VT = Op.getValueType();
+ if (VT != MVT::i32 || Subtarget.is64Bit())
+ return SDValue();
+
+ unsigned Opc = getRVPMulHighAccumulateHalfOpcode(IntNo);
+ return DAG.getNode(Opc, DL, VT, Op.getOperand(1), Op.getOperand(2),
+ Op.getOperand(3));
+ }
case Intrinsic::riscv_pmhacc_half_0:
case Intrinsic::riscv_pmhacc_half_1:
case Intrinsic::riscv_pmhaccsu_half_0:
@@ -18163,6 +18181,30 @@ void RISCVTargetLowering::ReplaceNodeResults(SDNode *N,
Results.push_back(DAG.getExtractSubvector(DL, VT, Res, 0));
return;
}
+ case Intrinsic::riscv_mhacc_h0:
+ case Intrinsic::riscv_mhacc_h1:
+ case Intrinsic::riscv_mhaccsu_h0:
+ case Intrinsic::riscv_mhaccsu_h1: {
+ // The scalar mhacc.h0/h1 forms exist only on RV32; RV64 has to build
+ // the packed word form here and extract the low word.
+ MVT VT = N->getSimpleValueType(0);
+ MVT SrcVT = N->getOperand(3).getSimpleValueType();
+ if (Subtarget.hasStdExtP() && Subtarget.is64Bit() && VT == MVT::i32 &&
+ SrcVT == MVT::v2i16) {
+ SDValue Rd = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2i32,
+ N->getOperand(1));
+ SDValue Rs1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2i32,
+ N->getOperand(2));
+ SDValue Rs2 = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4i16,
+ N->getOperand(3), DAG.getUNDEF(MVT::v2i16));
+ SDValue Res = DAG.getNode(getRVPMulHighAccumulateHalfOpcode(IntNo), DL,
+ MVT::v2i32, Rd, Rs1, Rs2);
+ Results.push_back(DAG.getExtractVectorElt(DL, MVT::i32, Res, 0));
+ return;
+ }
+ reportFatalUsageError(
+ "unsupported llvm.riscv multiply-high-accumulate-half intrinsic");
+ }
case Intrinsic::riscv_pm4add:
case Intrinsic::riscv_pm2add:
case Intrinsic::riscv_pm2add_x:
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
index bc36f912f7785..b5cb394cb472f 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar-rv64.ll
@@ -1688,3 +1688,48 @@ define signext i32 @ssh1sadd_intrinsic_i32(i32 signext %a, i32 signext %b) nounw
%res = call i32 @llvm.riscv.ssh1sadd.i32(i32 %a, i32 %b)
ret i32 %res
}
+
+declare i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32, i32, <2 x i16>)
+
+define signext i32 @mhacc_h0_i32_sext(i32 signext %rd, i32 signext %rs1, <2 x i16> %rs2) nounwind {
+; CHECK-LABEL: mhacc_h0_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmhacc.w.h0 a0, a1, a2
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define signext i32 @mhacc_h1_i32_sext(i32 signext %rd, i32 signext %rs1, <2 x i16> %rs2) nounwind {
+; CHECK-LABEL: mhacc_h1_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmhacc.w.h1 a0, a1, a2
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define signext i32 @mhaccsu_h0_i32_sext(i32 signext %rd, i32 signext %rs1, <2 x i16> %rs2) nounwind {
+; CHECK-LABEL: mhaccsu_h0_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmhaccsu.w.h0 a0, a1, a2
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define signext i32 @mhaccsu_h1_i32_sext(i32 signext %rd, i32 signext %rs1, <2 x i16> %rs2) nounwind {
+; CHECK-LABEL: mhaccsu_h1_i32_sext:
+; CHECK: # %bb.0:
+; CHECK-NEXT: pmhaccsu.w.h1 a0, a1, a2
+; CHECK-NEXT: sext.w a0, a0
+; CHECK-NEXT: ret
+ %r = call i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
diff --git a/llvm/test/CodeGen/RISCV/rvp-scalar.ll b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
index 13579bf2b9a11..f547e359a438a 100644
--- a/llvm/test/CodeGen/RISCV/rvp-scalar.ll
+++ b/llvm/test/CodeGen/RISCV/rvp-scalar.ll
@@ -4644,3 +4644,64 @@ define i32 @ssh1sadd_intrinsic_i32(i32 %a, i32 %b) nounwind {
%res = call i32 @llvm.riscv.ssh1sadd.i32(i32 %a, i32 %b)
ret i32 %res
}
+
+declare i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32, i32, <2 x i16>)
+declare i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32, i32, <2 x i16>)
+
+define i32 @mhacc_h0_i32(i32 %rd, i32 %rs1, <2 x i16> %rs2) nounwind {
+; RV32-LABEL: mhacc_h0_i32:
+; RV32: # %bb.0:
+; RV32-NEXT: mhacc.h0 a0, a1, a2
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mhacc_h0_i32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmhacc.w.h0 a0, a1, a2
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mhacc.h0.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define i32 @mhacc_h1_i32(i32 %rd, i32 %rs1, <2 x i16> %rs2) nounwind {
+; RV32-LABEL: mhacc_h1_i32:
+; RV32: # %bb.0:
+; RV32-NEXT: mhacc.h1 a0, a1, a2
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mhacc_h1_i32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmhacc.w.h1 a0, a1, a2
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mhacc.h1.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define i32 @mhaccsu_h0_i32(i32 %rd, i32 %rs1, <2 x i16> %rs2) nounwind {
+; RV32-LABEL: mhaccsu_h0_i32:
+; RV32: # %bb.0:
+; RV32-NEXT: mhaccsu.h0 a0, a1, a2
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mhaccsu_h0_i32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmhaccsu.w.h0 a0, a1, a2
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mhaccsu.h0.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
+
+define i32 @mhaccsu_h1_i32(i32 %rd, i32 %rs1, <2 x i16> %rs2) nounwind {
+; RV32-LABEL: mhaccsu_h1_i32:
+; RV32: # %bb.0:
+; RV32-NEXT: mhaccsu.h1 a0, a1, a2
+; RV32-NEXT: ret
+;
+; RV64-LABEL: mhaccsu_h1_i32:
+; RV64: # %bb.0:
+; RV64-NEXT: pmhaccsu.w.h1 a0, a1, a2
+; RV64-NEXT: ret
+ %r = call i32 @llvm.riscv.mhaccsu.h1.i32.v2i16(i32 %rd, i32 %rs1, <2 x i16> %rs2)
+ ret i32 %r
+}
``````````
</details>
https://github.com/llvm/llvm-project/pull/242195
More information about the cfe-commits
mailing list