[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