[llvm] [RISCV][MC] Implement MC for Base P extension (PR #123271)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 16 18:34:31 PST 2025
https://github.com/realqhc updated https://github.com/llvm/llvm-project/pull/123271
>From 87f3f8cf1bbd17ab54ee05acd16b4f4d74209bde Mon Sep 17 00:00:00 2001
From: Qihan Cai <caiqihan021 at hotmail.com>
Date: Thu, 31 Oct 2024 01:01:06 +1100
Subject: [PATCH] [RISCV][MC] Implement MC for Base P extension
This proposed extension adds Packed-SIMD instructions for RV32 and RV64.
Documentation:
https://jhauser.us/RISCV/ext-P/RVP-baseInstrs-012.pdf
https://jhauser.us/RISCV/ext-P/RVP-instrEncodings-012.pdf
This patch is MC-only.
---
llvm/docs/RISCVUsage.rst | 3 +
.../Target/RISCV/AsmParser/RISCVAsmParser.cpp | 13 +
.../Target/RISCV/MCTargetDesc/RISCVBaseInfo.h | 1 +
llvm/lib/Target/RISCV/RISCVFeatures.td | 32 +
llvm/lib/Target/RISCV/RISCVInstrInfo.td | 3 +
llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 1068 ++++++++++++
llvm/lib/Target/RISCV/RISCVInstrInfoZb.td | 26 +-
llvm/test/CodeGen/RISCV/attributes.ll | 3 +
llvm/test/MC/RISCV/attribute-arch.s | 6 +
.../MC/RISCV/invalid-instruction-spellcheck.s | 4 +-
llvm/test/MC/RISCV/rv32i-invalid.s | 4 +-
llvm/test/MC/RISCV/rv32p-invalid.s | 14 +
llvm/test/MC/RISCV/rv32p-valid.s | 1440 +++++++++++++++++
llvm/test/MC/RISCV/rv64p-invalid.s | 9 +
llvm/test/MC/RISCV/rv64p-valid.s | 911 +++++++++++
15 files changed, 3522 insertions(+), 15 deletions(-)
create mode 100644 llvm/lib/Target/RISCV/RISCVInstrInfoP.td
create mode 100644 llvm/test/MC/RISCV/rv32p-invalid.s
create mode 100644 llvm/test/MC/RISCV/rv32p-valid.s
create mode 100644 llvm/test/MC/RISCV/rv64p-invalid.s
create mode 100644 llvm/test/MC/RISCV/rv64p-valid.s
diff --git a/llvm/docs/RISCVUsage.rst b/llvm/docs/RISCVUsage.rst
index a1df0f7d686e62..89202a825fc643 100644
--- a/llvm/docs/RISCVUsage.rst
+++ b/llvm/docs/RISCVUsage.rst
@@ -335,6 +335,9 @@ The primary goal of experimental support is to assist in the process of ratifica
``experimental-svukte``
LLVM implements the `0.3 draft specification <https://github.com/riscv/riscv-isa-manual/pull/1564>`__.
+``experimental-p``, ``experimental-p``
+ LLVM implements the `012 specification <https://jhauser.us/RISCV/ext-P/RVP-baseInstrs-012.pdf>`__.
+
To use an experimental extension from `clang`, you must add `-menable-experimental-extensions` to the command line, and specify the exact version of the experimental extension you are using. To use an experimental extension with LLVM's internal developer tools (e.g. `llc`, `llvm-objdump`, `llvm-mc`), you must prefix the extension name with `experimental-`. Note that you don't need to specify the version with internal tools, and shouldn't include the `experimental-` prefix with `clang`.
Vendor Extensions
diff --git a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
index 8177280044bf44..b941c2b15a0cb1 100644
--- a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
+++ b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp
@@ -961,6 +961,16 @@ struct RISCVOperand final : public MCParsedAsmOperand {
bool isSImm13Lsb0() const { return isBareSimmNLsb0<13>(); }
+ bool isSImm10() const {
+ if (!isImm())
+ return false;
+ int64_t Imm;
+ RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None;
+ bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK);
+ return IsConstantImm && isInt<10>(fixImmediateForRV32(Imm, isRV64Imm())) &&
+ VK == RISCVMCExpr::VK_RISCV_None;
+ }
+
bool isSImm10Lsb0000NonZero() const {
if (!isImm())
return false;
@@ -1587,6 +1597,9 @@ bool RISCVAsmParser::matchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
return generateImmOutOfRangeError(
Operands, ErrorInfo, 4, (1 << 10) - 4,
"immediate must be a multiple of 4 bytes in the range");
+ case Match_InvalidSImm10:
+ return generateImmOutOfRangeError(Operands, ErrorInfo, -(1 << 9),
+ (1 << 9) - 1);
case Match_InvalidSImm10Lsb0000NonZero:
return generateImmOutOfRangeError(
Operands, ErrorInfo, -(1 << 9), (1 << 9) - 16,
diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
index ab04b09a7ad151..f4902099ddc3f7 100644
--- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
+++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVBaseInfo.h
@@ -314,6 +314,7 @@ enum OperandType : unsigned {
OPERAND_UIMM8_GE32,
OPERAND_UIMM9_LSB000,
OPERAND_UIMM10,
+ OPERAND_SIMM10,
OPERAND_UIMM10_LSB00_NONZERO,
OPERAND_UIMM11,
OPERAND_UIMM12,
diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td
index f721d7148526ba..b764d769640335 100644
--- a/llvm/lib/Target/RISCV/RISCVFeatures.td
+++ b/llvm/lib/Target/RISCV/RISCVFeatures.td
@@ -1016,6 +1016,38 @@ def HasStdExtSmctrOrSsctr : Predicate<"Subtarget->hasStdExtSmctrOrSsctr()">,
"'Smctr' (Control Transfer Records Machine Level) or "
"'Ssctr' (Control Transfer Records Supervisor Level)">;
+def FeatureStdExtP
+ : RISCVExperimentalExtension<1, 0,
+ "'Base P' (Packed SIMD)">;
+def HasStdExtP : Predicate<"Subtarget->hasStdExtP()">,
+ AssemblerPredicate<(all_of FeatureStdExtP),
+ "'Base P' (Packed SIMD)">;
+
+def HasStdExtZbaOrP
+ : Predicate<"Subtarget->hasStdExtZba() || Subtarget->hasStdExtP()">,
+ AssemblerPredicate<(any_of FeatureStdExtZba, FeatureStdExtP),
+ "'Zba' (Address Generation Instructions) or "
+ "'Base P' (Packed-SIMD)">;
+
+def HasStdExtZbbOrP
+ : Predicate<"Subtarget->hasStdExtZbb() || Subtarget->hasStdExtP()">,
+ AssemblerPredicate<(any_of FeatureStdExtZbb, FeatureStdExtP),
+ "'Zbb' (Basic Bit-Manipulation) or "
+ "'Base P' (Packed-SIMD)">;
+
+def HasStdExtZbkbOrP
+ : Predicate<"Subtarget->hasStdExtZbkb() || Subtarget->hasStdExtP()">,
+ AssemblerPredicate<(any_of FeatureStdExtZbkb, FeatureStdExtP),
+ "'Zbkb' (Bitmanip instructions for Cryptography) or "
+ "'Base P' (Packed-SIMD)">;
+
+def HasStdExtZbbOrZbkbOrP
+ : Predicate<"Subtarget->HasStdExtZbbOrZbkb()|| Subtarget->hasStdExtP()">,
+ AssemblerPredicate<(any_of FeatureStdExtZbb, FeatureStdExtZbkb, FeatureStdExtP),
+ "'Zbb' (Basic Bit-Manipulation) or "
+ "'Zbkb' (Bitmanip instructions for Cryptography) or "
+ "'Base P' (Packed-SIMD)">;
+
//===----------------------------------------------------------------------===//
// Vendor extensions
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfo.td b/llvm/lib/Target/RISCV/RISCVInstrInfo.td
index bb5bb6352c32a5..4b72fc54715314 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfo.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfo.td
@@ -2122,6 +2122,9 @@ include "RISCVInstrInfoZicbo.td"
include "RISCVInstrInfoZicond.td"
include "RISCVInstrInfoZicfiss.td"
+// Packed SIMD
+include "RISCVInstrInfoP.td"
+
//===----------------------------------------------------------------------===//
// Vendor extensions
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
new file mode 100644
index 00000000000000..fd32bc70a54d68
--- /dev/null
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td
@@ -0,0 +1,1068 @@
+//===-- RISCVInstrInfoP.td - RISC-V 'P' instructions -------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file describes the RISC-V instructions from the standard 'Base P'
+// Packed SIMD instruction set extension.
+///
+/// This version is still experimental as the 'P' extension hasn't been
+/// ratified yet.
+///
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+// Operand and SDNode transformation definitions.
+//===----------------------------------------------------------------------===//
+
+def simm10 : RISCVSImmLeafOp<10> {
+ let MCOperandPredicate = [{
+ int64_t Imm;
+ if (MCOp.evaluateAsConstantImm(Imm))
+ return isInt<10>(Imm);
+ return MCOp.isBareSymbolRef();
+ }];
+}
+
+//===----------------------------------------------------------------------===//
+// Instruction class templates
+//===----------------------------------------------------------------------===//
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnary<bits<5> funct5, bits<7> wuimm,
+ bits<3> funct3, RISCVOpcode opcode,
+ string opcodestr>
+ : RVInstIBase<funct3, opcode, (outs GPR:$rd), (ins GPR:$rs1),
+ opcodestr, "$rd, $rs1"> {
+ let Inst{31-27} = funct5;
+ let Inst{26-20} = wuimm;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnaryImm9<bits<7> funct7, RISCVOpcode opcode,
+ string opcodestr, DAGOperand TyRd = GPR>
+ : RVInstIBase<0b010, opcode, (outs TyRd:$rd), (ins simm10:$simm10),
+ opcodestr, "$rd, $simm10"> {
+ bits<10> simm10;
+
+ let Inst{31-25} = funct7;
+ let Inst{24-15} = simm10;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnaryImm8<bits<8> funct8, RISCVOpcode opcode,
+ string opcodestr, DAGOperand TyRd = GPR>
+ : RVInstIBase<0b010, opcode, (outs TyRd:$rd), (ins uimm8:$uimm8),
+ opcodestr, "$rd, $uimm8"> {
+ bits<8> uimm8;
+ let Inst{31-24} = funct8;
+ let Inst{23-16} = uimm8;
+ let Inst{15} = 0b0;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnaryWUF<bits<2> w, bits<5> uf,
+ string opcodestr>
+ : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins GPR:$rs1),
+ opcodestr, "$rd, $rs1"> {
+ let Inst{31-27} = 0b11100;
+ let Inst{26-25} = w;
+ let Inst{24-20} = uf;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnaryWUFRs1pRdp<bits<2> w, bits<5> uf, string opcodestr>
+ : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPRPairRV32:$rdp), (ins GPRPairRV32:$rs1p),
+ opcodestr, "$rdp, $rs1p"> {
+ bits<4> rs1p;
+ bits<4> rdp;
+
+ let Inst{31-27} = 0b01100;
+ let Inst{26-25} = w;
+ let Inst{24-20} = uf;
+ let Inst{19-16} = rs1p;
+ let Inst{15} = 0b0;
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPUnaryF<bit bfr, bits<3> f, bit aft, bits<7> wuimm,
+ string opcodestr, bits<3> funct3 = 0b100,
+ dag outs = (outs GPR:$rd), dag ins = (ins GPR:$rs1),
+ string argstr = "$rd, $rs1">
+ : RVInstIBase<funct3, OPC_OP_IMM_32, outs, ins, opcodestr, argstr> {
+ let Inst{31} = bfr;
+ let Inst{30-28} = f;
+ let Inst{27} = aft;
+ let Inst{26-20} = wuimm;
+}
+
+class RVPUnary1F0<bits<3> f, bits<7> wuimm, string opcodestr>
+ : RVPUnaryF<1, f, 0, wuimm, opcodestr>;
+
+class RVPUnary0F0Rdp<bits<3> f, bits<7> wuimm, string opcodestr>
+ : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp),
+ (ins GPR:$rs1), "$rdp, $rs1"> {
+ bits<4> rdp;
+
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+class RVPUnary0F0Rs1p<bits<3> f, bits<7> wuimm, string opcodestr>
+ : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd),
+ (ins GPRPairRV32:$rs1p), "$rd, $rs1p"> {
+ bits<4> rs1p;
+
+ let Inst{19-16} = rs1p;
+ let Inst{15} = 0b1;
+}
+
+class RVPUnary0F0Rs1pRdp<bits<3> f, bits<7> wuimm, string opcodestr,
+ bit aft = 0b0>
+ : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp),
+ (ins GPRPairRV32:$rs1p), "$rdp, $rs1p"> {
+ bits<4> rs1p;
+ bits<4> rdp;
+
+ let Inst{19-16} = rs1p;
+ let Inst{15} = aft;
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPBinaryFW<bit bfr, bits<3> f, bit aft, bits<2> w,
+ string opcodestr, bits<3> funct3, RISCVOpcode Opcode = OPC_OP_32,
+ dag outs = (outs GPR:$rd), dag ins = (ins GPR:$rs1, GPR:$rs2),
+ string argstr = "$rd, $rs1, $rs2">
+ : RVInstRBase<funct3, Opcode, outs, ins, opcodestr, argstr> {
+ let Inst{31} = bfr;
+ let Inst{30-28} = f;
+ let Inst{27} = aft;
+ let Inst{26-25} = w;
+}
+
+class RVPBinary1F1W<bits<3> f, bits<2> w, string opcodestr, bits<3> funct3,
+ RISCVOpcode Opcode = OPC_OP_32>
+ : RVPBinaryFW<1, f, 1, w, opcodestr, funct3, Opcode>;
+
+class RVPBinary1F0W<bits<3> f, bits<2> w, string opcodestr, bits<3> funct3,
+ RISCVOpcode Opcode = OPC_OP_32>
+ : RVPBinaryFW<1, f, 0, w, opcodestr, funct3, Opcode>;
+
+class RVPBinary0F1WRdp<bits<3> f, bits<2> w, string opcodestr,
+ RISCVOpcode Opcode = OPC_OP_IMM_32>
+ : RVPBinaryFW<0, f, 1, w, opcodestr, 0b010, Opcode, (outs GPRPairRV32:$rdp),
+ (ins GPR:$rs1, GPR:$rs2), "$rdp, $rs1, $rs2"> {
+ bits<4> rdp;
+
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+class RVPBinary0F1WRs1p<bits<3> f, bits<2> w, string opcodestr,
+ bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32>
+ : RVPBinaryFW<0, f, 1, w, opcodestr, 0b100, Opcode, (outs GPR:$rd),
+ (ins GPRPairRV32:$rs1p, GPR:$rs2), "$rd, $rs1p, $rs2"> {
+ bits<4> rs1p;
+
+ let Inst{19-16} = rs1p;
+ let Inst{15} = aft;
+}
+
+class RVPBinary0F1WRs1pRdp<bits<3> f, bits<2> w, string opcodestr,
+ bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32>
+ : RVPBinaryFW<0, f, 1, w, opcodestr, 0b110, Opcode, (outs GPRPairRV32:$rdp),
+ (ins GPRPairRV32:$rs1p, GPR:$rs2), "$rdp, $rs1p, $rs2"> {
+ bits<4> rs1p;
+ bits<4> rdp;
+
+ let Inst{19-16} = rs1p;
+ let Inst{15} = aft;
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPBinary1FWRs2pRs1pRdp<bits<4> f, bits<2> w, string opcodestr,
+ bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32>
+ : RVInstRBase<0b110, Opcode, (outs GPRPairRV32:$rdp), (ins GPRPairRV32:$rs1p, GPRPairRV32:$rs2p),
+ opcodestr, "$rdp, $rs1p, $rs2p"> {
+ bits<4> rs1p;
+ bits<4> rs2p;
+ bits<4> rdp;
+
+ let Inst{31} = 0b1;
+ let Inst{30-27} = f;
+ let Inst{26-25} = w;
+ let Inst{24-21} = rs2p;
+ let Inst{20} = aft;
+ let Inst{19-16} = rs1p;
+ let Inst{15} = aft;
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+class RVPBinary1F0WRs2pRs1pRdp<bits<3> f, bits<2> w, string opcodestr,
+ bit bfr = 0b1, bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32>
+ : RVPBinaryFW<1, f, 0, w, opcodestr, 0b110, Opcode, (outs GPRPairRV32:$rdp),
+ (ins GPRPairRV32:$rs1p, GPRPairRV32:$rs2p), "$rdp, $rs1p, $rs2p"> {
+ bits<4> rs1p;
+ bits<4> rs2p;
+ bits<4> rdp;
+
+ let Inst{24-21} = rs2p;
+ let Inst{20} = bfr;
+ let Inst{19-16} = rs1p;
+ let Inst{15} = aft;
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b0;
+}
+
+let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in
+class RVPBinaryLongFW<bit bfr, bits<4> f, bits<2> w,
+ string opcodestr, bits<3> funct3, dag outs = (outs GPR:$rd),
+ dag ins = (ins GPR:$rs1, GPR:$rs2),
+ string argstr = "$rd, $rs1, $rs2">
+ : RVInstRBase<funct3, OPC_OP_32, outs, ins,
+ opcodestr, argstr> {
+ let Inst{31} = bfr;
+ let Inst{30-27} = f;
+ let Inst{26-25} = w;
+}
+
+class RVPBinary1LongFW<bits<4> f, bits<2> w, string opcodestr, bits<3> funct3>
+ : RVPBinaryLongFW<1, f, w, opcodestr, funct3>;
+
+class RVPBinary0LongFW<bits<4> f, bits<2> w, string opcodestr>
+ : RVPBinaryLongFW<0, f, w, opcodestr, 0b010, (outs GPRPairRV32:$rdp),
+ (ins GPR:$rs1, GPRPairRV32:$rs2), "$rdp, $rs1, $rs2"> {
+ bits<4> rdp;
+
+ let Inst{11-8} = rdp;
+ let Inst{7} = 0b1;
+}
+
+multiclass RVPUnaryBH<bits<5> funct5, string opcodestr> {
+ def NAME # _B : RVPUnary<funct5, 0b0001000, 0b010, OPC_OP_IMM_32, opcodestr # ".b">;
+ def NAME # _H : RVPUnary<funct5, 0b0010000, 0b010, OPC_OP_IMM_32, opcodestr # ".h">;
+}
+
+multiclass RVPUnaryHNonPacked<bits<5> funct5, string opcodestr> {
+ def P # NAME # _H : RVPUnary<funct5, 0b0010000, 0b010, OPC_OP_IMM_32, "p" # opcodestr # ".h">;
+ def NAME: RVPUnary<funct5, 0b0100000, 0b010, OPC_OP_IMM_32, opcodestr>;
+}
+
+multiclass RVPUnaryBHW<bits<5> funct5, string opcodestr> {
+ defm NAME : RVPUnaryBH<funct5, opcodestr>;
+ def NAME # _W: RVPUnary<funct5, 0b0100000, 0b010, OPC_OP_IMM_32, opcodestr # ".w">;
+}
+
+multiclass RVPUnaryHW<bits<5> funct5, string opcodestr> {
+ def NAME # _H : RVPUnary<funct5, 0b0010000, 0b010, OPC_OP_IMM_32, opcodestr # ".h">;
+ def NAME # _W: RVPUnary<funct5, 0b0100000, 0b010, OPC_OP_IMM_32, opcodestr # ".w">;
+}
+
+//===----------------------------------------------------------------------===//
+// Instructions
+//===----------------------------------------------------------------------===//
+
+let Predicates = [HasStdExtP] in {
+def CLS : RVPUnary<0b01100, 0b0000011, 0b001, OPC_OP_IMM, "cls">;
+def ABS : RVPUnary<0b01100, 0b0000111, 0b001, OPC_OP_IMM, "abs">;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def REV_RV32 : RVPUnary<0b01101, 0b0011111, 0b101, OPC_OP_IMM, "rev">;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def REV16 : RVPUnary<0b01101, 0b0110000, 0b101, OPC_OP_IMM, "rev16">;
+def REV_RV64 : RVPUnary<0b01111, 0b0111111, 0b101, OPC_OP_IMM, "rev">;
+
+def CLSW : RVPUnary<0b01100, 0b0000011, 0b001, OPC_OP_IMM_32, "clsw">;
+def ABSW : RVPUnary<0b01100, 0b0000111, 0b001, OPC_OP_IMM_32, "absw">;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+ defm PSLLI_RV32 : RVPUnaryBH<0b10000, "pslli">;
+ defm SSLAI_RV32 : RVPUnaryHNonPacked<0b11010, "sslai">;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+ defm PSLLI_RV64 : RVPUnaryBHW<0b10000, "pslli">;
+ defm PSSLAI_RV64 : RVPUnaryHW<0b01010, "psslai">;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let Predicates = [HasStdExtP] in
+def PLI_H : RVPUnaryImm9<0b1011000, OPC_OP_IMM_32, "pli.h">;
+let Predicates = [HasStdExtP, IsRV64] in {
+def PLI_W : RVPUnaryImm9<0b1011001, OPC_OP_IMM_32, "pli.w">;
+} // Predicates = [HasStdExtP, IsRV64]
+let Predicates = [HasStdExtP] in
+def PLI_B : RVPUnaryImm8<0b10110100, OPC_OP_IMM_32, "pli.b">;
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def PSEXTB_H_RV32 : RVPUnaryWUF<0b00, 0b00100, "psextb.h">;
+def PSABS_H_RV32 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">;
+def PSABS_B_RV32 : RVPUnaryWUF<0b01, 0b00111, "psabs.b">;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PSEXTB_H_RV64 : RVPUnaryWUF<0b00, 0b00100, "psextb.h">;
+def PSEXTB_W : RVPUnaryWUF<0b01, 0b00100, "psextb.w">;
+def PSEXTH_W : RVPUnaryWUF<0b01, 0b00101, "psexth.w">;
+def PSABS_H_RV64 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">;
+def PSABS_B_RV64 : RVPUnaryWUF<0b10, 0b00111, "psabs.b">;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let Predicates = [HasStdExtP] in
+def PLUI_H : RVPUnaryImm9<0b1111000, OPC_OP_IMM_32, "plui.h">;
+let Predicates = [HasStdExtP, IsRV64] in
+def PLUI_W : RVPUnaryImm9<0b1111001, OPC_OP_IMM_32, "plui.w">;
+
+let Predicates = [HasStdExtP] in {
+def PSLL_H_H0 : RVPBinary1F1W<0b000, 0b00, "psll.h.h0", 0b010, OPC_OP_IMM_32>;
+def PSLL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psll.b.b0", 0b010, OPC_OP_IMM_32>;
+def PADD_H_H0 : RVPBinary1F1W<0b001, 0b00, "padd.h.h0", 0b010, OPC_OP_IMM_32>;
+def PADD_B_B0 : RVPBinary1F1W<0b001, 0b10, "padd.b.b0", 0b010, OPC_OP_IMM_32>;
+def PSSHA_H_H0 : RVPBinary1F1W<0b110, 0b00, "pssha.h.h0", 0b010, OPC_OP_IMM_32>;
+def PSSHAR_H_H0 : RVPBinary1F1W<0b111, 0b00, "psshar.h.h0", 0b010, OPC_OP_IMM_32>;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def SSHA : RVPBinary1F1W<0b110, 0b01, "ssha", 0b010, OPC_OP_IMM_32>;
+def SSHAR : RVPBinary1F1W<0b111, 0b01, "sshar", 0b010, OPC_OP_IMM_32>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PSLL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psll.w.w0", 0b010, OPC_OP_IMM_32>;
+def PADD_W_W0 : RVPBinary1F1W<0b001, 0b01, "padd.w.w0", 0b010, OPC_OP_IMM_32>;
+def PSSHA_W_W0 : RVPBinary1F1W<0b110, 0b01, "pssha.w.w0", 0b010, OPC_OP_IMM_32>;
+def PSSHAR_W_W0 : RVPBinary1F1W<0b111, 0b01, "psshar.w.w0", 0b010, OPC_OP_IMM_32>;
+def SHA : RVPBinary1F1W<0b110, 0b11, "sha", 0b010, OPC_OP_IMM_32>;
+def SHAR : RVPBinary1F1W<0b111, 0b11, "shar", 0b010, OPC_OP_IMM_32>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let Predicates = [HasStdExtP] in {
+def PSRLI_B : RVPUnary1F0<0b000, 0b0001000, "psrli.b">;
+def PSRLI_H : RVPUnary1F0<0b000, 0b0010000, "psrli.h">;
+def PUSATI_H : RVPUnary1F0<0b010, 0b0010000, "pusati.h">;
+def PSRAI_B : RVPUnary1F0<0b100, 0b0001000, "psrai.b">;
+def PSRAI_H : RVPUnary1F0<0b100, 0b0010000, "psrai.h">;
+def PSRARI_H : RVPUnary1F0<0b101, 0b0010000, "psrari.h">;
+def PSATI_H : RVPUnary1F0<0b110, 0b0010000, "psati.h">;
+} // Predicates = [HasStdExtP]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def USATI_RV32 : RVPUnary1F0<0b010, 0b0100000, "usati">;
+def SRARI : RVPUnary1F0<0b101, 0b0100000, "srari">;
+def SATI : RVPUnary1F0<0b110, 0b0100000, "sati">;
+} // Predicates = [HasStdExtP, IsRV32]
+let Predicates = [HasStdExtP, IsRV64] in {
+def PSRLI_W : RVPUnary1F0<0b000, 0b0100000, "psrli.w">;
+def PUSATI_W : RVPUnary1F0<0b010, 0b0100000, "pusati.w">;
+def USATI_RV64 : RVPUnary1F0<0b010, 0b1000000, "usati">;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let Predicates = [HasStdExtP] in {
+def PSRL_H_H0 : RVPBinary1F1W<0b000, 0b00, "psrl.h.h0", 0b100, OPC_OP_IMM_32>;
+def PSRL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psrl.b.b0", 0b100, OPC_OP_IMM_32>;
+def PREDSUM_H : RVPBinary1F1W<0b001, 0b00, "predsum.h", 0b100, OPC_OP_IMM_32>;
+def PREDSUM_B : RVPBinary1F1W<0b001, 0b10, "predsum.b", 0b100, OPC_OP_IMM_32>;
+def PREDSUMU_H : RVPBinary1F1W<0b011, 0b00, "predsumu.h", 0b100, OPC_OP_IMM_32>;
+def PREDSUMU_B : RVPBinary1F1W<0b011, 0b10, "predsumu.b", 0b100, OPC_OP_IMM_32>;
+def PSRA_H_H0 : RVPBinary1F1W<0b100, 0b00, "psra.h.h0", 0b100, OPC_OP_IMM_32>;
+def PSRA_B_B0 : RVPBinary1F1W<0b100, 0b10, "psra.b.b0", 0b100, OPC_OP_IMM_32>;
+} // Predicates = [HasStdExtP]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PSRL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psrl.w.w0", 0b100, OPC_OP_IMM_32>;
+def PREDSUM_W : RVPBinary1F1W<0b001, 0b01, "predsum.w", 0b100, OPC_OP_IMM_32>;
+def PREDSUMU_W : RVPBinary1F1W<0b011, 0b01, "predsumu.w", 0b100, OPC_OP_IMM_32>;
+def PSRA_W_W0 : RVPBinary1F1W<0b100, 0b01, "psra.w.w0", 0b100, OPC_OP_IMM_32>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PADD_H : RVPBinary1LongFW<0b0000, 0b00, "padd.h", 0b000>;
+def PADD_B : RVPBinary1LongFW<0b0000, 0b10, "padd.b", 0b000>;
+def PSADD_H : RVPBinary1LongFW<0b0010, 0b00, "psadd.h", 0b000>;
+def PSADD_B : RVPBinary1LongFW<0b0010, 0b10, "psadd.b", 0b000>;
+def PAADD_H : RVPBinary1LongFW<0b0011, 0b00, "paadd.h", 0b000>;
+def PAADD_B : RVPBinary1LongFW<0b0011, 0b10, "paadd.b", 0b000>;
+
+def PSADDU_H : RVPBinary1LongFW<0b0110, 0b00, "psaddu.h", 0b000>;
+def PSADDU_B : RVPBinary1LongFW<0b0110, 0b10, "psaddu.b", 0b000>;
+def PAADDU_H : RVPBinary1LongFW<0b0111, 0b00, "paaddu.h", 0b000>;
+def PAADDU_B : RVPBinary1LongFW<0b0111, 0b10, "paaddu.b", 0b000>;
+
+def PSUB_H : RVPBinary1LongFW<0b1000, 0b00, "psub.h", 0b000>;
+def PSUB_B : RVPBinary1LongFW<0b1000, 0b10, "psub.b", 0b000>;
+def PDIF_H : RVPBinary1LongFW<0b1001, 0b00, "pdif.h", 0b000>;
+def PDIF_B : RVPBinary1LongFW<0b1001, 0b10, "pdif.b", 0b000>;
+def PSSUB_H : RVPBinary1LongFW<0b1010, 0b00, "pssub.h", 0b000>;
+def PSSUB_B : RVPBinary1LongFW<0b1010, 0b10, "pssub.b", 0b000>;
+def PASUB_H : RVPBinary1LongFW<0b1011, 0b00, "pasub.h", 0b000>;
+def PASUB_B : RVPBinary1LongFW<0b1011, 0b10, "pasub.b", 0b000>;
+
+def PDIFU_H : RVPBinary1LongFW<0b1101, 0b00, "pdifu.h", 0b000>;
+def PDIFU_B : RVPBinary1LongFW<0b1101, 0b10, "pdifu.b", 0b000>;
+def PSSUBU_H : RVPBinary1LongFW<0b1110, 0b00, "pssubu.h", 0b000>;
+def PSSUBU_B : RVPBinary1LongFW<0b1110, 0b10, "pssubu.b", 0b000>;
+def PASUBU_H : RVPBinary1LongFW<0b1111, 0b00, "pasubu.h", 0b000>;
+def PASUBU_B : RVPBinary1LongFW<0b1111, 0b10, "pasubu.b", 0b000>;
+} // Predicates = [HasStdExtP]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def SADD : RVPBinary1LongFW<0b0010, 0b01, "sadd", 0b000>;
+def AADD : RVPBinary1LongFW<0b0011, 0b01, "aadd", 0b000>;
+
+def SADDU : RVPBinary1LongFW<0b0110, 0b01, "saddu", 0b000>;
+def AADDU : RVPBinary1LongFW<0b0111, 0b01, "aaddu", 0b000>;
+
+def SSUB : RVPBinary1LongFW<0b1010, 0b01, "ssub", 0b000>;
+def ASUB : RVPBinary1LongFW<0b1011, 0b01, "asub", 0b000>;
+
+def SSUBU : RVPBinary1LongFW<0b1110, 0b01, "ssubu", 0b000>;
+def ASUBU : RVPBinary1LongFW<0b1111, 0b01, "asubu", 0b000>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PADD_W : RVPBinary1LongFW<0b0000, 0b01, "padd.w", 0b000>;
+def PSADD_W : RVPBinary1LongFW<0b0010, 0b01, "psadd.w", 0b000>;
+def PAADD_W : RVPBinary1LongFW<0b0011, 0b01, "paadd.w", 0b000>;
+
+def PSADDU_W : RVPBinary1LongFW<0b0110, 0b01, "psaddu.w", 0b000>;
+def PAADDU_W : RVPBinary1LongFW<0b0111, 0b01, "paaddu.w", 0b000>;
+
+def PSUB_W : RVPBinary1LongFW<0b1000, 0b01, "psub.w", 0b000>;
+def PSSUB_W : RVPBinary1LongFW<0b1010, 0b01, "pssub.w", 0b000>;
+def PASUB_W : RVPBinary1LongFW<0b1011, 0b01, "pasub.w", 0b000>;
+
+def PSSUBU_W : RVPBinary1LongFW<0b1110, 0b01, "pssubu.w", 0b000>;
+def PASUBU_W : RVPBinary1LongFW<0b1111, 0b01, "pasubu.w", 0b000>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def SLX : RVPBinary1LongFW<0b0001, 0b11, "slx", 0b001>;
+def PMUL_H_BEO : RVPBinary1LongFW<0b0010, 0b00, "pmul.h.beo", 0b001>;
+
+def MVM : RVPBinary1LongFW<0b0101, 0b00, "mvm", 0b001>;
+def MVMN : RVPBinary1LongFW<0b0101, 0b01, "mvmn", 0b001>;
+def MERGE : RVPBinary1LongFW<0b0101, 0b10, "merge", 0b001>;
+def SRX : RVPBinary1LongFW<0b0101, 0b11, "srx", 0b001>;
+def PMULU_H_BEO : RVPBinary1LongFW<0b0110, 0b00, "pmulu.h.beo", 0b001>;
+def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, "pdifsumu.b", 0b001>;
+def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, "pdifsumau.b", 0b001>;
+} // Predicates = [HasStdExtP]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def MUL_H01 : RVPBinary1LongFW<0b0010, 0b01, "mul.h01", 0b001>;
+def MACC_H01 : RVPBinary1LongFW<0b0011, 0b01, "macc.h01", 0b001>;
+
+def MULU_H01 : RVPBinary1LongFW<0b0110, 0b01, "mulu.h01", 0b001>;
+def MACCU_H01 : RVPBinary1LongFW<0b0111, 0b01, "maccu.h01", 0b001>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PMUL_W_HEO : RVPBinary1LongFW<0b0010, 0b01, "pmul.w.heo", 0b001>;
+def MUL_W01 : RVPBinary1LongFW<0b0010, 0b11, "mul.w01", 0b001>;
+def PMACC_W_HEO : RVPBinary1LongFW<0b0011, 0b01, "pmacc.w.heo", 0b001>;
+def MACC_W01 : RVPBinary1LongFW<0b0011, 0b11, "macc.w01", 0b001>;
+
+def PMULU_W_HEO : RVPBinary1LongFW<0b0110, 0b01, "pmulu.w.heo", 0b001>;
+def MULU_W01 : RVPBinary1LongFW<0b0110, 0b11, "mulu.w01", 0b001>;
+def PMACCU_W_HEO : RVPBinary1LongFW<0b0111, 0b01, "pmaccu.w.heo", 0b001>;
+def MACCU_W01 : RVPBinary1LongFW<0b0111, 0b11, "maccu.w01", 0b001>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, "psh1add.h", 0b010>;
+def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, "pssh1sadd.h", 0b010>;
+} // Predicates = [HasStdExtP]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def SSH1SADD : RVPBinary1F0W<0b010, 0b01, "ssh1sadd", 0b010>;
+} // Predicates = [HasStdExtP, IsRV32]
+let Predicates = [HasStdExtP, IsRV64] in {
+def PSH1ADD_W : RVPBinary1F0W<0b010, 0b01, "psh1add.w", 0b010>;
+def PSSH1SADD_W : RVPBinary1F0W<0b011, 0b01, "pssh1sadd.w", 0b010>;
+
+def UNZIP8P : RVPBinary1F0W<0b110, 0b00, "unzip8p", 0b010>;
+def UNZIP16P : RVPBinary1F0W<0b110, 0b01, "unzip16p", 0b010>;
+def UNZIP8HP : RVPBinary1F0W<0b110, 0b10, "unzip8hp", 0b010>;
+def UNZIP16HP : RVPBinary1F0W<0b110, 0b11, "unzip16hp", 0b010>;
+def ZIP8P : RVPBinary1F0W<0b111, 0b00, "zip8p", 0b010>;
+def ZIP16P : RVPBinary1F0W<0b111, 0b01, "zip16p", 0b010>;
+def ZIP8HP : RVPBinary1F0W<0b111, 0b10, "zip8hp", 0b010>;
+def ZIP16HP : RVPBinary1F0W<0b111, 0b11, "zip16hp", 0b010>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PMUL_H_BEE : RVPBinary1LongFW<0b0000, 0b00, "pmul.h.bee", 0b011>;
+def PMUL_H_BOO : RVPBinary1LongFW<0b0010, 0b00, "pmul.h.boo", 0b011>;
+
+def PMULU_H_BEE : RVPBinary1LongFW<0b0100, 0b00, "pmulu.h.bee", 0b011>;
+def PMULU_H_BOO : RVPBinary1LongFW<0b0110, 0b00, "pmulu.h.boo", 0b011>;
+
+def PMULSU_H_BEE : RVPBinary1LongFW<0b1100, 0b00, "pmulsu.h.bee", 0b011>;
+def PMULSU_H_BOO : RVPBinary1LongFW<0b1110, 0b00, "pmulsu.h.boo", 0b011>;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def MUL_H00 : RVPBinary1LongFW<0b0000, 0b01, "mul.h00", 0b011>;
+def MACC_H00 : RVPBinary1LongFW<0b0001, 0b01, "macc.h00", 0b011>;
+def MUL_H11 : RVPBinary1LongFW<0b0010, 0b01, "mul.h11", 0b011>;
+def MACC_H11 : RVPBinary1LongFW<0b0011, 0b01, "macc.h11", 0b011>;
+
+def MULU_H00 : RVPBinary1LongFW<0b0100, 0b01, "mulu.h00", 0b011>;
+def MACCU_H00 : RVPBinary1LongFW<0b0101, 0b01, "maccu.h00", 0b011>;
+def MULU_H11 : RVPBinary1LongFW<0b0110, 0b01, "mulu.h11", 0b011>;
+def MACCU_H11 : RVPBinary1LongFW<0b0111, 0b01, "maccu.h11", 0b011>;
+
+def MULSU_H00 : RVPBinary1LongFW<0b1100, 0b01, "mulsu.h00", 0b011>;
+def MACCSU_H00 : RVPBinary1LongFW<0b1101, 0b01, "maccsu.h00", 0b011>;
+def MULSU_H11 : RVPBinary1LongFW<0b1110, 0b01, "mulsu.h11", 0b011>;
+def MACCSU_H11 : RVPBinary1LongFW<0b1111, 0b01, "maccsu.h11", 0b011>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PMUL_W_BEE : RVPBinary1LongFW<0b0000, 0b01, "pmul.w.bee", 0b011>;
+def MUL_W00 : RVPBinary1LongFW<0b0000, 0b11, "mul.w00", 0b011>;
+def PMACC_W_HEE : RVPBinary1LongFW<0b0001, 0b01, "pmacc.w.hee", 0b011>;
+def MACC_W00 : RVPBinary1LongFW<0b0001, 0b11, "macc.w00", 0b011>;
+def PMUL_W_HOO : RVPBinary1LongFW<0b0010, 0b01, "pmul.w.hoo", 0b011>;
+def MUL_W11 : RVPBinary1LongFW<0b0010, 0b11, "mul.w11", 0b011>;
+def PMACC_W_HOO : RVPBinary1LongFW<0b0011, 0b01, "pmacc.w.hoo", 0b011>;
+def MACC_W11 : RVPBinary1LongFW<0b0011, 0b11, "macc.w11", 0b011>;
+
+def PMULU_W_HEE : RVPBinary1LongFW<0b0100, 0b01, "pmulu.w.hee", 0b011>;
+def MULU_W00 : RVPBinary1LongFW<0b0100, 0b11, "mulu.w00", 0b011>;
+def PMACCU_W_HEE : RVPBinary1LongFW<0b0101, 0b01, "pmaccu.w.hee", 0b011>;
+def MACCU_W00 : RVPBinary1LongFW<0b0101, 0b11, "maccu.w00", 0b011>;
+def PMULU_W_HOO : RVPBinary1LongFW<0b0110, 0b01, "pmulu.w.hoo", 0b011>;
+def MULU_W11 : RVPBinary1LongFW<0b0110, 0b11, "mulu.w11", 0b011>;
+def PMACCU_W_HOO : RVPBinary1LongFW<0b0111, 0b01, "pmaccu.w.hoo", 0b011>;
+def MACCU_W11 : RVPBinary1LongFW<0b0111, 0b11, "maccu.w11", 0b011>;
+
+def PMULSU_W_HEE : RVPBinary1LongFW<0b1100, 0b01, "pmulsu.w.hee", 0b011>;
+def MULSU_W00 : RVPBinary1LongFW<0b1100, 0b11, "mulsu.w00", 0b011>;
+def PMACCSU_W_HEE : RVPBinary1LongFW<0b1101, 0b01, "pmaccsu.w.hee", 0b011>;
+def MACCSU_W00 : RVPBinary1LongFW<0b1101, 0b11, "maccsu.w00", 0b011>;
+def PMULSU_W_HOO : RVPBinary1LongFW<0b1110, 0b01, "pmulsu.w.hoo", 0b011>;
+def MULSU_W11 : RVPBinary1LongFW<0b1110, 0b11, "mulsu.w11", 0b011>;
+def PMACCSU_W_HOO : RVPBinary1LongFW<0b1111, 0b01, "pmaccsu.w.hoo", 0b011>;
+def MACCSU_W11 : RVPBinary1LongFW<0b1111, 0b11, "maccsu.w11", 0b011>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PPACK_H : RVPBinary1F0W<0b000, 0b00, "ppack.h", 0b100>;
+def PPACKBT_H : RVPBinary1F0W<0b001, 0b00, "ppackbt.h", 0b100>;
+def PPACKTB_H : RVPBinary1F0W<0b010, 0b00, "ppacktb.h", 0b100>;
+def PPACKT_H : RVPBinary1F0W<0b011, 0b00, "ppackt.h", 0b100>;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def PACKBT : RVPBinary1F0W<0b001, 0b01, "packbt", 0b100>;
+def PACKTB : RVPBinary1F0W<0b010, 0b01, "packtb", 0b100>;
+def PACKT : RVPBinary1F0W<0b011, 0b01, "packt", 0b100>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PPACK_W : RVPBinary1F0W<0b000, 0b01, "ppack.w", 0b100>;
+def PPACKBT_W : RVPBinary1F0W<0b001, 0b01, "ppackbt.w", 0b100>;
+def PPACKBT : RVPBinary1F0W<0b001, 0b11, "ppackbt", 0b100>;
+def PPACKTB_W : RVPBinary1F0W<0b010, 0b01, "ppacktb.w", 0b100>;
+def PPACKTB : RVPBinary1F0W<0b010, 0b11, "ppacktb", 0b100>;
+def PPACKT_W : RVPBinary1F0W<0b011, 0b01, "ppackt.w", 0b100>;
+def PPACKT : RVPBinary1F0W<0b011, 0b11, "ppackt", 0b100>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PM2ADD_H : RVPBinary1LongFW<0b0000, 0b00, "pm2add.h", 0b101>;
+def PM4ADD_B : RVPBinary1LongFW<0b0000, 0b10, "pm4add.b", 0b101>;
+def PM2ADDA_H : RVPBinary1LongFW<0b0001, 0b00, "pm2adda.h", 0b101>;
+def PM4ADDA_B : RVPBinary1LongFW<0b0001, 0b10, "pm4adda.b", 0b101>;
+def PM2ADD_HX : RVPBinary1LongFW<0b0010, 0b00, "pm2add.hx", 0b101>;
+def PM2ADDA_HX : RVPBinary1LongFW<0b0011, 0b00, "pm2adda.hx", 0b101>;
+
+def PM2ADDU_H : RVPBinary1LongFW<0b0100, 0b00, "pm2addu.h", 0b101>;
+def PM4ADDU_B : RVPBinary1LongFW<0b0100, 0b10, "pm4addu.b", 0b101>;
+def PM2ADDAU_H : RVPBinary1LongFW<0b0101, 0b00, "pm2addau.h", 0b101>;
+def PM4ADDAU_B : RVPBinary1LongFW<0b0101, 0b10, "pm4addau.b", 0b101>;
+def PMQ2ADD_H : RVPBinary1LongFW<0b0110, 0b00, "pmq2add.h", 0b101>;
+def PMQR2ADD_H : RVPBinary1LongFW<0b0110, 0b10, "pmqr2add.h", 0b101>;
+def PMQ2ADDA_H : RVPBinary1LongFW<0b0111, 0b00, "pmq2adda.h", 0b101>;
+def PMQR2ADDA_H : RVPBinary1LongFW<0b0111, 0b10, "pmqr2adda.h", 0b101>;
+
+def PM2SUB_H : RVPBinary1LongFW<0b1000, 0b00, "pm2sub.h", 0b101>;
+def PM2SADD_H : RVPBinary1LongFW<0b1000, 0b10, "pm2sadd.h", 0b101>;
+def PM2SUBA_H : RVPBinary1LongFW<0b1001, 0b00, "pm2suba.h", 0b101>;
+def PM2SUB_HX : RVPBinary1LongFW<0b1010, 0b00, "pm2sub.hx", 0b101>;
+def PM2SADD_HX : RVPBinary1LongFW<0b1010, 0b10, "pm2sadd.hx", 0b101>;
+def PM2SUBA_HX : RVPBinary1LongFW<0b1011, 0b00, "pm2suba.hx", 0b101>;
+
+def PM2ADDSU_H : RVPBinary1LongFW<0b1100, 0b00, "pm2addsu.h", 0b101>;
+def PM4ADDSU_B : RVPBinary1LongFW<0b1100, 0b10, "pm4addsu.b", 0b101>;
+def PM2ADDASU_H : RVPBinary1LongFW<0b1101, 0b00, "pm2addasu.h", 0b101>;
+def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, "pm4addasu.b", 0b101>;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def MQACC_H01 : RVPBinary1LongFW<0b0111, 0b00, "mqacc.h01", 0b101>;
+def MQRACC_H01 : RVPBinary1LongFW<0b0111, 0b10, "mqracc.h01", 0b101>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PM2ADD_W : RVPBinary1LongFW<0b0000, 0b01, "pm2add.w", 0b101>;
+def PM4ADD_H : RVPBinary1LongFW<0b0000, 0b11, "pm4add.h", 0b101>;
+def PM2ADDA_W : RVPBinary1LongFW<0b0001, 0b01, "pm2adda.w", 0b101>;
+def PM4ADDA_H : RVPBinary1LongFW<0b0001, 0b11, "pm4adda.h", 0b101>;
+def PM2ADD_WX : RVPBinary1LongFW<0b0010, 0b01, "pm2add.wx", 0b101>;
+def PM2ADDA_WX : RVPBinary1LongFW<0b0011, 0b01, "pm2adda.wx", 0b101>;
+
+def PM2ADDU_W : RVPBinary1LongFW<0b0100, 0b01, "pm2addu.w", 0b101>;
+def PM4ADDU_H : RVPBinary1LongFW<0b0100, 0b11, "pm4addu.h", 0b101>;
+def PM2ADDAU_W : RVPBinary1LongFW<0b0101, 0b01, "pm2addau.w", 0b101>;
+def PM4ADDAU_H : RVPBinary1LongFW<0b0101, 0b11, "pm4addau.h", 0b101>;
+def PMQ2ADD_W : RVPBinary1LongFW<0b0110, 0b01, "pmq2add.w", 0b101>;
+def PMQR2ADD_W : RVPBinary1LongFW<0b0110, 0b11, "pmqr2add.w", 0b101>;
+def PMQ2ADDA_W : RVPBinary1LongFW<0b0111, 0b01, "pmq2adda.w", 0b101>;
+def PMQR2ADDA_W : RVPBinary1LongFW<0b0111, 0b11, "pmqr2adda.w", 0b101>;
+
+def PM2SUB_W : RVPBinary1LongFW<0b1000, 0b01, "pm2sub.w", 0b101>;
+def PM2SUBA_W : RVPBinary1LongFW<0b1001, 0b01, "pm2suba.w", 0b101>;
+def PM2SUB_WX : RVPBinary1LongFW<0b1010, 0b01, "pm2sub.wx", 0b101>;
+def PM2SUBA_WX : RVPBinary1LongFW<0b1011, 0b01, "pm2suba.wx", 0b101>;
+
+def PM2ADDSU_W : RVPBinary1LongFW<0b1100, 0b01, "pm2addsu.w", 0b101>;
+def PM4ADDSU_H : RVPBinary1LongFW<0b1100, 0b11, "pm4addsu.h", 0b101>;
+def PM2ADDASU_W : RVPBinary1LongFW<0b1101, 0b01, "pm2addasu.w", 0b101>;
+def PM4ADDASU_H : RVPBinary1LongFW<0b1101, 0b11, "pm4addasu.h", 0b101>;
+
+def PMQACC_W_HEO : RVPBinary1LongFW<0b1111, 0b00, "pmqacc.w.heo", 0b101>;
+def MQACC_W01 : RVPBinary1LongFW<0b1111, 0b01, "mqacc.w01", 0b101>;
+def PMQRACC_W_HEO : RVPBinary1LongFW<0b1111, 0b10, "pmqracc.w.heo", 0b101>;
+def MQRACC_W01 : RVPBinary1LongFW<0b1111, 0b11, "mqracc.w01", 0b101>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+let Predicates = [HasStdExtP] in {
+def PAS_HX : RVPBinary1LongFW<0b0000, 0b00, "pas.hx", 0b110>;
+def PSA_HX : RVPBinary1LongFW<0b0000, 0b10, "psa.hx", 0b110>;
+def PSAS_HX : RVPBinary1LongFW<0b0010, 0b00, "psas.hx", 0b110>;
+def PSSA_HX : RVPBinary1LongFW<0b0010, 0b10, "pssa.hx", 0b110>;
+
+def PMSEQ_H : RVPBinary1LongFW<0b1000, 0b00, "pmseq.h", 0b110>;
+def PMSEQ_B : RVPBinary1LongFW<0b1000, 0b10, "pmseq.b", 0b110>;
+def PMSLT_H : RVPBinary1LongFW<0b1010, 0b00, "pmslt.h", 0b110>;
+def PMSLT_B : RVPBinary1LongFW<0b1010, 0b10, "pmslt.b", 0b110>;
+def PMSLTU_H : RVPBinary1LongFW<0b1011, 0b00, "pmsltu.h", 0b110>;
+def PMSLTU_B : RVPBinary1LongFW<0b1011, 0b10, "pmsltu.b", 0b110>;
+
+def PMIN_H : RVPBinary1LongFW<0b1100, 0b00, "pmin.h", 0b110>;
+def PMIN_B : RVPBinary1LongFW<0b1100, 0b10, "pmin.b", 0b110>;
+def PMINU_H : RVPBinary1LongFW<0b1101, 0b00, "pminu.h", 0b110>;
+def PMINU_B : RVPBinary1LongFW<0b1101, 0b10, "pminu.b", 0b110>;
+def PMAX_H : RVPBinary1LongFW<0b1110, 0b00, "pmax.h", 0b110>;
+def PMAX_B : RVPBinary1LongFW<0b1110, 0b10, "pmax.b", 0b110>;
+def PMAXU_H : RVPBinary1LongFW<0b1111, 0b00, "pmaxu.h", 0b110>;
+def PMAXU_B : RVPBinary1LongFW<0b1111, 0b10, "pmaxu.b", 0b110>;
+} // Predicates = [HasStdExtP]
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def MSEQ : RVPBinary1LongFW<0b1000, 0b01, "mseq", 0b110>;
+def MSLT : RVPBinary1LongFW<0b1010, 0b01, "mslt", 0b110>;
+def MSLTU : RVPBinary1LongFW<0b1011, 0b01, "msltu", 0b110>;
+} // Predicates = [HasStdExtP, IsRV32]
+let Predicates = [HasStdExtP, IsRV64] in {
+def PAS_WX : RVPBinary1LongFW<0b0000, 0b01, "pas.wx", 0b110>;
+def PSA_WX : RVPBinary1LongFW<0b0000, 0b11, "psa.wx", 0b110>;
+def PSAS_WX : RVPBinary1LongFW<0b0010, 0b01, "psas.wx", 0b110>;
+def PSSA_WX : RVPBinary1LongFW<0b0010, 0b11, "pssa.wx", 0b110>;
+def PAAS_WX : RVPBinary1LongFW<0b0011, 0b01, "paas.wx", 0b110>;
+def PASA_WX : RVPBinary1LongFW<0b0011, 0b11, "pasa.wx", 0b110>;
+
+def PMSEQ_W : RVPBinary1LongFW<0b1000, 0b01, "pmseq.w", 0b110>;
+def PMSLT_W : RVPBinary1LongFW<0b1010, 0b01, "pmslt.w", 0b110>;
+def PMSLTU_W : RVPBinary1LongFW<0b1011, 0b01, "pmsltu.w", 0b110>;
+
+def PMIN_W : RVPBinary1LongFW<0b1100, 0b01, "pmin.w", 0b110>;
+def PMINU_W : RVPBinary1LongFW<0b1101, 0b01, "pminu.w", 0b110>;
+def PMAX_W : RVPBinary1LongFW<0b1110, 0b01, "pmax.w", 0b110>;
+def PMAXU_W : RVPBinary1LongFW<0b1111, 0b01, "pmaxu.w", 0b110>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP] in {
+def PMULH_H : RVPBinary1LongFW<0b0000, 0b00, "pmulh.h", 0b111>;
+def PMULHR_H : RVPBinary1LongFW<0b0000, 0b10, "pmulhr.h", 0b111>;
+def PMHACC_H : RVPBinary1LongFW<0b0001, 0b00, "pmhacc.h", 0b111>;
+def PMHRACC_H : RVPBinary1LongFW<0b0001, 0b10, "pmhracc.h", 0b111>;
+def PMULHU_H : RVPBinary1LongFW<0b0010, 0b00, "pmulhu.h", 0b111>;
+def PMULHRU_H : RVPBinary1LongFW<0b0010, 0b10, "pmulhru.h", 0b111>;
+def PMHACCU_H : RVPBinary1LongFW<0b0011, 0b00, "pmhaccu.h", 0b111>;
+def PMHRACCU_H : RVPBinary1LongFW<0b0011, 0b10, "pmhraccu.h", 0b111>;
+
+def PMULH_H_BE : RVPBinary1LongFW<0b0100, 0b00, "pmulh.h.be", 0b111>;
+def PMULHSU_H_BE : RVPBinary1LongFW<0b0100, 0b10, "pmulhsu.h.be", 0b111>;
+def PMHACCU_H_BE : RVPBinary1LongFW<0b0101, 0b00, "pmhaccu.h.be", 0b111>;
+def PMHACCSU_H_BE : RVPBinary1LongFW<0b0101, 0b10, "pmhaccsu.h.be", 0b111>;
+def PMULH_H_BO : RVPBinary1LongFW<0b0110, 0b00, "pmulh.h.bo", 0b111>;
+def PMULHSU_H_BO : RVPBinary1LongFW<0b0110, 0b10, "pmulhsu.h.bo", 0b111>;
+def PMHACC_H_BO : RVPBinary1LongFW<0b0111, 0b00, "pmhacc.h.bo", 0b111>;
+def PMHACCSU_H_BO : RVPBinary1LongFW<0b0111, 0b10, "pmhaccsu.h.bo", 0b111>;
+
+def PMULHSU_H : RVPBinary1LongFW<0b1000, 0b00, "pmulhsu.h", 0b111>;
+def PMULHRSU_H : RVPBinary1LongFW<0b1000, 0b10, "pmulhrsu.h", 0b111>;
+def PMHACCSU_H : RVPBinary1LongFW<0b1001, 0b00, "pmhaccsu.h", 0b111>;
+def PMHRACCSU_H : RVPBinary1LongFW<0b1001, 0b10, "pmhraccsu.h", 0b111>;
+def PMULQ_H : RVPBinary1LongFW<0b1010, 0b00, "pmulq.h", 0b111>;
+def PMULQR_H : RVPBinary1LongFW<0b1010, 0b10, "pmulqr.h", 0b111>;
+} // Predicates = [HasStdExtP]
+
+let DecoderNamespace = "RISCV32Only_",
+ Predicates = [HasStdExtP, IsRV32] in {
+def MULHR : RVPBinary1LongFW<0b0000, 0b11, "mulhr", 0b111>;
+def MHACC : RVPBinary1LongFW<0b0001, 0b01, "mhacc", 0b111>;
+def MHRACC : RVPBinary1LongFW<0b0001, 0b11, "mhracc", 0b111>;
+def MULHRU : RVPBinary1LongFW<0b0010, 0b11, "mulhru", 0b111>;
+def MHACCU : RVPBinary1LongFW<0b0011, 0b01, "mhaccu", 0b111>;
+def MHRACCU : RVPBinary1LongFW<0b0011, 0b11, "mhraccu", 0b111>;
+
+def MULH_H0 : RVPBinary1LongFW<0b0100, 0b01, "mulh.h0", 0b111>;
+def MULHSU_H0 : RVPBinary1LongFW<0b0100, 0b11, "mulhsu.h0", 0b111>;
+def MHACC_H0 : RVPBinary1LongFW<0b0101, 0b01, "mhacc.h0", 0b111>;
+def MHACCSU_H0 : RVPBinary1LongFW<0b0101, 0b11, "mhaccsu.h0", 0b111>;
+def MULH_H1 : RVPBinary1LongFW<0b0110, 0b01, "mulh.h1", 0b111>;
+def MULHSU_H1 : RVPBinary1LongFW<0b0110, 0b11, "mulhsu.h1", 0b111>;
+def MHACC_H1 : RVPBinary1LongFW<0b0111, 0b01, "mhacc.h1", 0b111>;
+def MHACCSU_H1 : RVPBinary1LongFW<0b0111, 0b11, "mhaccsu.h1", 0b111>;
+
+def MULHRSU_H : RVPBinary1LongFW<0b1000, 0b11, "mulhrsu.h", 0b111>;
+def MHACCSU : RVPBinary1LongFW<0b1001, 0b01, "mhaccsu", 0b111>;
+def MHRACCSU : RVPBinary1LongFW<0b1001, 0b11, "mhraccsu", 0b111>;
+def MULQ : RVPBinary1LongFW<0b1010, 0b01, "mulq", 0b111>;
+def MULQR : RVPBinary1LongFW<0b1010, 0b11, "mulqr", 0b111>;
+
+def MQACC_H00 : RVPBinary1LongFW<0b1101, 0b00, "mqacc.h00", 0b111>;
+def MQRACC_H00 : RVPBinary1LongFW<0b1101, 0b10, "mqracc.h00", 0b111>;
+def MQACC_H11 : RVPBinary1LongFW<0b1111, 0b00, "mqacc.h11", 0b111>;
+def MQRACC_H11 : RVPBinary1LongFW<0b1111, 0b10, "mqracc.h11", 0b111>;
+} // Predicates = [HasStdExtP, IsRV32]
+
+let Predicates = [HasStdExtP, IsRV64] in {
+def PMULH_W : RVPBinary1LongFW<0b0000, 0b01, "pmulh.w", 0b111>;
+def PMULHR_W : RVPBinary1LongFW<0b0000, 0b11, "pmulhr.w", 0b111>;
+def PMHACC_W : RVPBinary1LongFW<0b0001, 0b01, "pmhacc.w", 0b111>;
+def PMHRACC_W : RVPBinary1LongFW<0b0001, 0b11, "pmhracc.w", 0b111>;
+def PMULHU_W : RVPBinary1LongFW<0b0010, 0b01, "pmulhu.w", 0b111>;
+def PMULHRU_W : RVPBinary1LongFW<0b0010, 0b11, "pmulhru.w", 0b111>;
+def PMHACCU_W : RVPBinary1LongFW<0b0011, 0b01, "pmhaccu.w", 0b111>;
+def PMHRACCU_W : RVPBinary1LongFW<0b0011, 0b11, "pmhraccu.w", 0b111>;
+
+def PMULH_W_HE : RVPBinary1LongFW<0b0100, 0b01, "pmulh.w.he", 0b111>;
+def PMULHSU_W_HE : RVPBinary1LongFW<0b0100, 0b11, "pmulhsu.w.he", 0b111>;
+def PMHACC_W_HE : RVPBinary1LongFW<0b0101, 0b01, "pmhacc.w.he", 0b111>;
+def PMHACCSU_W_HE : RVPBinary1LongFW<0b0101, 0b11, "pmhaccsu.w.he", 0b111>;
+def PMULH_W_HO : RVPBinary1LongFW<0b0110, 0b01, "pmulh.w.ho", 0b111>;
+def PMULHSU_W_HO : RVPBinary1LongFW<0b0110, 0b11, "pmulhsu.w.ho", 0b111>;
+def PMHACC_W_HO : RVPBinary1LongFW<0b0111, 0b01, "pmhacc.w.ho", 0b111>;
+def PMHACCSU_W_HO : RVPBinary1LongFW<0b0111, 0b11, "pmhaccsu.w.ho", 0b111>;
+
+def PMULHSU_W : RVPBinary1LongFW<0b1000, 0b01, "pmulhsu.w", 0b111>;
+def PMULHRSU_W : RVPBinary1LongFW<0b1000, 0b11, "pmulhrsu.w", 0b111>;
+def PMHACCSU_W : RVPBinary1LongFW<0b1001, 0b01, "pmhaccsu.w", 0b111>;
+def PMHRACCSU_W : RVPBinary1LongFW<0b1001, 0b11, "pmhraccsu.w", 0b111>;
+def PMULQ_W : RVPBinary1LongFW<0b1010, 0b01, "pmulq.w", 0b111>;
+def PMULQR_W : RVPBinary1LongFW<0b1010, 0b11, "pmulqr.w", 0b111>;
+
+def PMQACC_W_HEE : RVPBinary1LongFW<0b1101, 0b00, "pmqacc.w.hee", 0b111>;
+def MQACC_W00 : RVPBinary1LongFW<0b1101, 0b01, "mqacc.w00", 0b111>;
+def PMQRACC_W_HEE : RVPBinary1LongFW<0b1101, 0b10, "pmqracc.w.hee", 0b111>;
+def MQRACC_W00 : RVPBinary1LongFW<0b1101, 0b11, "mqracc.w00", 0b111>;
+def PMQACC_W_HOO : RVPBinary1LongFW<0b1111, 0b00, "pmqacc.w.hoo", 0b111>;
+def MQACC_W11 : RVPBinary1LongFW<0b1111, 0b01, "mqacc.w11", 0b111>;
+def PMQRACC_W_HOO : RVPBinary1LongFW<0b1111, 0b10, "pmqracc.w.hoo", 0b111>;
+def MQRACC_W11 : RVPBinary1LongFW<0b1111, 0b11, "mqracc.w11", 0b111>;
+} // Predicates = [HasStdExtP, IsRV64]
+
+
+let Predicates = [HasStdExtP, IsRV32] in {
+def PWSLLI_B : RVPUnary0F0Rdp<0b000, 0b0010000, "pwslli.b">;
+def PWSLLI_H : RVPUnary0F0Rdp<0b001, 0b0100000, "pwslli.h">;
+def WSLLI : RVPUnary0F0Rdp<0b010, 0b1000000, "wslli">;
+
+def PWSLAI_B : RVPUnary0F0Rdp<0b100, 0b0010000, "pwslai.b">;
+def PWSLAI_H : RVPUnary0F0Rdp<0b100, 0b0100000, "pwslai.h">;
+def WSLAI : RVPUnary0F0Rdp<0b100, 0b1000000, "wslai">;
+
+def PLI_DH : RVPUnaryImm9<0b0011000, OPC_OP_IMM_32, "pli.dh", GPRPairRV32>;
+def PLI_DB : RVPUnaryImm8<0b00110100, OPC_OP_IMM_32, "pli.db", GPRPairRV32>;
+def PLUI_DH : RVPUnaryImm9<0b0111000, OPC_OP_IMM_32, "plui.dh", GPRPairRV32>;
+
+
+def PWSLLI_B_B0 : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.b.b0">;
+def PWSLL_H_H0 : RVPBinary0F1WRdp<0b000, 0b01, "pwsll.h.h0">;
+def WSLL : RVPBinary0F1WRdp<0b000, 0b11, "wsll">;
+
+def PWSLA_B_B0 : RVPBinary0F1WRdp<0b100, 0b00, "pwsla.b.b0">;
+def PWSLA_H_H0 : RVPBinary0F1WRdp<0b100, 0b01, "pwsla.h.h0">;
+def WSLA : RVPBinary0F1WRdp<0b100, 0b11, "wsla">;
+def WZIP8P : RVPBinary0F1WRdp<0b111, 0b00, "wzip8p">;
+def WZIP16P : RVPBinary0F1WRdp<0b111, 0b01, "wzip16p">;
+
+def PWADD_H : RVPBinary0LongFW<0b0000, 0b00, "pwadd.h">;
+def WADD : RVPBinary0LongFW<0b0000, 0b01, "wadd">;
+def PWADD_B : RVPBinary0LongFW<0b0000, 0b10, "pwadd.b">;
+def PW2WADD_H : RVPBinary0LongFW<0b0000, 0b11, "pw2wadd.h">;
+def PWADDA_H : RVPBinary0LongFW<0b0001, 0b00, "pwadda.h">;
+def WADDA : RVPBinary0LongFW<0b0001, 0b01, "wadda">;
+def PWADDA_B : RVPBinary0LongFW<0b0001, 0b10, "pwadda.b">;
+def PW2WADDA_H : RVPBinary0LongFW<0b0001, 0b11, "pw2wadda.h">;
+def PWADDU_H : RVPBinary0LongFW<0b0010, 0b00, "pwaddu.h">;
+def WADDU : RVPBinary0LongFW<0b0010, 0b01, "waddu">;
+def PWADDU_B : RVPBinary0LongFW<0b0010, 0b10, "pwaddu.b">;
+def PW2WADD_HX : RVPBinary0LongFW<0b0010, 0b11, "pw2wadd.hx">;
+def PWADDAU_H : RVPBinary0LongFW<0b0011, 0b00, "pwaddau.h">;
+def WADDAU : RVPBinary0LongFW<0b0011, 0b01, "waddau">;
+def PWADDAU_B : RVPBinary0LongFW<0b0011, 0b10, "pwaddau.b">;
+def PW2WADDA_HX: RVPBinary0LongFW<0b0011, 0b11, "pw2wadda.hx">;
+
+def PWMUL_H : RVPBinary0LongFW<0b0100, 0b00, "pwmul.h">;
+def WMUL : RVPBinary0LongFW<0b0100, 0b01, "wmul">;
+def PWMUL_B : RVPBinary0LongFW<0b0100, 0b10, "pwmul.b">;
+def PW2WADDU_H : RVPBinary0LongFW<0b0100, 0b11, "pw2waddu.h">;
+def PWMACC_H : RVPBinary0LongFW<0b0101, 0b00, "pwmacc.h">;
+def WMACC : RVPBinary0LongFW<0b0101, 0b01, "wmacc">;
+def PM2WADDAU_H : RVPBinary0LongFW<0b0101, 0b11, "pm2waddau.h">;
+def PWMULU_H : RVPBinary0LongFW<0b0110, 0b00, "pwmulu.h">;
+def WMULU : RVPBinary0LongFW<0b0110, 0b01, "wmulu">;
+def PWMULU_B : RVPBinary0LongFW<0b0110, 0b10, "pwmulu.b">;
+def PWMACCU_H : RVPBinary0LongFW<0b0111, 0b00, "pwmaccu.h">;
+def WMACCU : RVPBinary0LongFW<0b0111, 0b01, "wmaccu">;
+
+def PWSUB_H : RVPBinary0LongFW<0b1000, 0b00, "pwsub.h">;
+def WSUB : RVPBinary0LongFW<0b1000, 0b01, "wsub">;
+def PWSUB_B : RVPBinary0LongFW<0b1000, 0b10, "pwsub.b">;
+def PW2WSUB_H : RVPBinary0LongFW<0b1000, 0b11, "pw2wsub.h">;
+def PWSUBA_H : RVPBinary0LongFW<0b1001, 0b00, "pwsuba.h">;
+def WSUBA : RVPBinary0LongFW<0b1001, 0b01, "wsuba">;
+def PWSUBA_B : RVPBinary0LongFW<0b1001, 0b10, "pwsuba.b">;
+def PW2WSUBA_H : RVPBinary0LongFW<0b1001, 0b11, "pw2wsuba.h">;
+def PWSUBU_H : RVPBinary0LongFW<0b1010, 0b00, "pwsubu.h">;
+def WSUBU : RVPBinary0LongFW<0b1010, 0b01, "wsubu">;
+def PWSUBU_B : RVPBinary0LongFW<0b1010, 0b10, "pwsubu.b">;
+def PW2WSUB_HX : RVPBinary0LongFW<0b1010, 0b11, "pw2wsub.hx">;
+def PWSUBAU_H : RVPBinary0LongFW<0b1011, 0b00, "pwsubau.h">;
+def WSUBAU : RVPBinary0LongFW<0b1011, 0b01, "wsubau">;
+def PWSUBAU_B : RVPBinary0LongFW<0b1011, 0b10, "pwsubau.b">;
+def PW2WSUBA_HX: RVPBinary0LongFW<0b1011, 0b11, "pw2wsuba.hx">;
+
+def PWMULSU_H : RVPBinary0LongFW<0b1100, 0b00, "pwmulsu.h">;
+def WMULSU : RVPBinary0LongFW<0b1100, 0b01, "wmulsu">;
+def PWMULSU_B : RVPBinary0LongFW<0b1100, 0b10, "pwmulsu.b">;
+def PM2WADDSU_H : RVPBinary0LongFW<0b1100, 0b11, "pm2waddsu.h">;
+def PWMACCSU_H : RVPBinary0LongFW<0b1101, 0b00, "pwmaccsu.h">;
+def WMACCSU : RVPBinary0LongFW<0b1101, 0b01, "wmaccsu">;
+def PM2WADDASU_H : RVPBinary0LongFW<0b1101, 0b11, "pm2waddasu.h">;
+def PMQWACC_H : RVPBinary0LongFW<0b1111, 0b00, "pmqwacc.h">;
+def PMQWACC : RVPBinary0LongFW<0b1111, 0b01, "pmqwacc">;
+def PMQRWACC_H : RVPBinary0LongFW<0b1111, 0b10, "pmqrwacc.h">;
+def PMQRWACC : RVPBinary0LongFW<0b1111, 0b11, "pmqrwacc">;
+
+def PREDSUM_DH : RVPBinary0F1WRs1p<0b000, 0b00, "predsum.dh">;
+def PREDSUM_DB : RVPBinary0F1WRs1p<0b000, 0b10, "predsum.db">;
+def PREDSUMU_DH : RVPBinary0F1WRs1p<0b011, 0b00, "predsumu.dh">;
+def PREDSUMU_DB : RVPBinary0F1WRs1p<0b011, 0b10, "predsumu.db">;
+
+def PNSRLI_B : RVPUnary0F0Rs1p<0b000, 0b0010000, "pnsrli.b">;
+def PNSRLI_H : RVPUnary0F0Rs1p<0b000, 0b0100000, "pnsrli.h">;
+def NSRLI : RVPUnary0F0Rs1p<0b000, 0b1000000, "nsrli">;
+def PNCLIPIU_B : RVPUnary0F0Rs1p<0b010, 0b0010000, "pnclipiu.b">;
+def PNCLIPIU_H : RVPUnary0F0Rs1p<0b010, 0b0100000, "pnclipiu.h">;
+def NCLIPIU : RVPUnary0F0Rs1p<0b010, 0b1000000, "nclipiu">;
+def PNCLIPRIU_B : RVPUnary0F0Rs1p<0b011, 0b0010000, "pnclipriu.b">;
+def PNCLIPRIU_H : RVPUnary0F0Rs1p<0b011, 0b0100000, "pnclipriu.h">;
+def NCLIPRIU : RVPUnary0F0Rs1p<0b011, 0b1000000, "nclipriu">;
+
+def PNSRAI_B : RVPUnary0F0Rs1p<0b100, 0b0010000, "pnsrai.b">;
+def PNSRAI_H : RVPUnary0F0Rs1p<0b100, 0b0100000, "pnsrai.h">;
+def NSRAI : RVPUnary0F0Rs1p<0b100, 0b1000000, "nsrai">;
+def PNSARI_B : RVPUnary0F0Rs1p<0b101, 0b0010000, "pnsari.b">;
+def PNSARI_H : RVPUnary0F0Rs1p<0b101, 0b0100000, "pnsari.h">;
+def NSARI : RVPUnary0F0Rs1p<0b101, 0b1000000, "nsari">;
+def PNCLIPI_B : RVPUnary0F0Rs1p<0b110, 0b0010000, "pnclipi.b">;
+def PNCLIPI_H : RVPUnary0F0Rs1p<0b110, 0b0100000, "pnclipi.h">;
+def NCLIPI : RVPUnary0F0Rs1p<0b110, 0b1000000, "nclipi">;
+def PNCLIPRI_B : RVPUnary0F0Rs1p<0b111, 0b0010000, "pnclipri.b">;
+def PNCLIPRI_H : RVPUnary0F0Rs1p<0b111, 0b0100000, "pnclipri.h">;
+def NCLIPRI : RVPUnary0F0Rs1p<0b111, 0b1000000, "nclipri">;
+
+def PNSRL_B_B0 : RVPBinary0F1WRs1p<0b000, 0b00, "pnsrl.b.b0", 0b1>;
+def PNSRL_H_H0 : RVPBinary0F1WRs1p<0b000, 0b01, "pnsrl.h.h0", 0b1>;
+def NSRL : RVPBinary0F1WRs1p<0b000, 0b11, "nsrl", 0b1>;
+def PNCLIPU_B_B0 : RVPBinary0F1WRs1p<0b010, 0b00, "pnclipu.b.b0", 0b1>;
+def PNCLIPU_H_H0 : RVPBinary0F1WRs1p<0b010, 0b01, "pnclipu.h.h0", 0b1>;
+def NCLIPU : RVPBinary0F1WRs1p<0b010, 0b11, "nclipu", 0b1>;
+def PNCLIPRU_B_B0 : RVPBinary0F1WRs1p<0b011, 0b00, "pnclipru.b.b0", 0b1>;
+def PNCLIPRU_H_H0 : RVPBinary0F1WRs1p<0b011, 0b01, "pnclipru.h.h0", 0b1>;
+def NCLIPRU : RVPBinary0F1WRs1p<0b011, 0b11, "nclipru", 0b1>;
+
+def PNSRA_B_B0 : RVPBinary0F1WRs1p<0b100, 0b00, "pnsra.b.b0", 0b1>;
+def PNSRA_H_H0 : RVPBinary0F1WRs1p<0b100, 0b01, "pnsra.h.h0", 0b1>;
+def NSRA : RVPBinary0F1WRs1p<0b100, 0b11, "nsra", 0b1>;
+def PNSRAR_B_B0 : RVPBinary0F1WRs1p<0b101, 0b00, "pnsrar.b.b0", 0b1>;
+def PNSRAR_H_H0 : RVPBinary0F1WRs1p<0b101, 0b01, "pnsrar.h.h0", 0b1>;
+def NSRAR : RVPBinary0F1WRs1p<0b101, 0b11, "nsrar", 0b1>;
+def PNCLIP_B_B0 : RVPBinary0F1WRs1p<0b110, 0b00, "pnclip.b.b0", 0b1>;
+def PNCLIP_H_H0 : RVPBinary0F1WRs1p<0b110, 0b01, "pnclip.h.h0", 0b1>;
+def NCLIP : RVPBinary0F1WRs1p<0b110, 0b11, "nclip", 0b1>;
+def PNCLIPR_B_B0 : RVPBinary0F1WRs1p<0b111, 0b00, "pnclipr.b.b0", 0b1>;
+def PNCLIPR_H_H0 : RVPBinary0F1WRs1p<0b111, 0b01, "pnclipr.h.h0", 0b1>;
+def NCLIPR : RVPBinary0F1WRs1p<0b111, 0b11, "nclipr", 0b1>;
+
+
+def PSLLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "pslli.db">;
+def PSLLI_DH : RVPUnary0F0Rs1pRdp<0b000, 0b0010000, "pslli.dh">;
+def PSLLI_DW : RVPUnary0F0Rs1pRdp<0b000, 0b0100000, "pslli.dw">;
+
+def PSSLAI_DH : RVPUnary0F0Rs1pRdp<0b101, 0b0010000, "psslai.dh">;
+def PSSLAI_DW : RVPUnary0F0Rs1pRdp<0b101, 0b0100000, "psslai.dw">;
+
+def PSEXTB_DH : RVPUnaryWUFRs1pRdp<0b00, 0b00100, "psextb.dh">;
+def PSEXTB_DW : RVPUnaryWUFRs1pRdp<0b01, 0b00100, "psextb.dw">;
+def PSEXTW_DW : RVPUnaryWUFRs1pRdp<0b01, 0b00101, "psextw.dw">;
+def PSABS_DH : RVPUnaryWUFRs1pRdp<0b00, 0b00111, "psabs.dh">;
+def PSABS_DB : RVPUnaryWUFRs1pRdp<0b10, 0b00111, "psabs.db">;
+
+def PSLL_DH_H0 : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psll.dh.h0">;
+def PSLL_DW_W : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psll.dw.w">;
+def PSLL_DB_B0 : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psll.db.b0">;
+def PADD_DH_H0 : RVPBinary0F1WRs1pRdp<0b001, 0b00, "padd.dh.h0">;
+def PADD_DW_W : RVPBinary0F1WRs1pRdp<0b001, 0b01, "padd.dw.w">;
+def PADD_DB_B0 : RVPBinary0F1WRs1pRdp<0b001, 0b10, "padd.db.b0">;
+
+def PSSHA_DH_H0 : RVPBinary0F1WRs1pRdp<0b110, 0b00, "pssha.dh.h0">;
+def PSSHA_DW_W : RVPBinary0F1WRs1pRdp<0b110, 0b01, "pssha.dw.w">;
+def PSSHAR_DH_H0 : RVPBinary0F1WRs1pRdp<0b111, 0b00, "psshar.dh.h0">;
+def PSSHAR_DW_W : RVPBinary0F1WRs1pRdp<0b111, 0b01, "psshar.dw.w">;
+
+def PSRLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "psrli.db", 0b1>;
+def PSRLI_DH : RVPUnary0F0Rs1pRdp<0b000, 0b0010000, "psrli.dh", 0b1>;
+def PSRLI_DW : RVPUnary0F0Rs1pRdp<0b000, 0b0100000, "psrli.dw", 0b1>;
+def PUSATI_DH : RVPUnary0F0Rs1pRdp<0b010, 0b0010000, "pusati.dh", 0b1>;
+def PUSATI_DW : RVPUnary0F0Rs1pRdp<0b010, 0b0100000, "pusati.dw", 0b1>;
+
+def PSRAI_DB : RVPUnary0F0Rs1pRdp<0b100, 0b0001000, "psrai.db", 0b1>;
+def PSRAI_DH : RVPUnary0F0Rs1pRdp<0b100, 0b0010000, "psrai.dh", 0b1>;
+def PSRAI_DW : RVPUnary0F0Rs1pRdp<0b100, 0b0100000, "psrai.dw", 0b1>;
+def PSRARI_DH : RVPUnary0F0Rs1pRdp<0b101, 0b0010000, "psrari.dh", 0b1>;
+def PSRARI_DW : RVPUnary0F0Rs1pRdp<0b101, 0b0100000, "psrari.dw", 0b1>;
+def PSATI_DH : RVPUnary0F0Rs1pRdp<0b110, 0b0010000, "psati.dh", 0b1>;
+def PSATI_DW : RVPUnary0F0Rs1pRdp<0b110, 0b0100000, "psati.dw", 0b1>;
+
+def PSRL_DH_H0 :RVPBinary0F1WRs1pRdp<0b000, 0b00, "psrl.dh.h0", 0b1>;
+def PSRL_DW_W :RVPBinary0F1WRs1pRdp<0b000, 0b01, "psrl.dw.w", 0b1>;
+def PSRL_DB_B0 :RVPBinary0F1WRs1pRdp<0b000, 0b10, "psrl.db.b0", 0b1>;
+
+def PSRA_DH_H0 :RVPBinary0F1WRs1pRdp<0b100, 0b00, "psra.dh.h0", 0b1>;
+def PSRA_DW_W :RVPBinary0F1WRs1pRdp<0b100, 0b01, "psra.dw.w", 0b1>;
+def PSRA_DB_B0 :RVPBinary0F1WRs1pRdp<0b100, 0b10, "psra.db.b0", 0b1>;
+
+def PADD_DH : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b00, "padd.dh">;
+def PADD_DW : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b01, "padd.dw">;
+def PADD_DB : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b10, "padd.db">;
+def ADDD : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b11, "addd">;
+def PSADD_DH : RVPBinary1FWRs2pRs1pRdp<0b0010, 0b00, "psadd.dh">;
+def PSADD_DW : RVPBinary1FWRs2pRs1pRdp<0b0010, 0b01, "psadd.dw">;
+def PSADD_DB : RVPBinary1FWRs2pRs1pRdp<0b0010, 0b10, "psadd.db">;
+def PAADD_DH : RVPBinary1FWRs2pRs1pRdp<0b0011, 0b00, "paadd.dh">;
+def PAADD_DW : RVPBinary1FWRs2pRs1pRdp<0b0011, 0b01, "paadd.dw">;
+def PAADD_DB : RVPBinary1FWRs2pRs1pRdp<0b0011, 0b10, "paadd.db">;
+
+def PSADDU_DH : RVPBinary1FWRs2pRs1pRdp<0b0110, 0b00, "psaddu.dh">;
+def PSADDU_DW : RVPBinary1FWRs2pRs1pRdp<0b0110, 0b01, "psaddu.dw">;
+def PSADDU_DB : RVPBinary1FWRs2pRs1pRdp<0b0110, 0b10, "psaddu.db">;
+def PAADDU_DH : RVPBinary1FWRs2pRs1pRdp<0b0111, 0b00, "paaddu.dh">;
+def PAADDU_DW : RVPBinary1FWRs2pRs1pRdp<0b0111, 0b01, "paaddu.dw">;
+def PAADDU_DB : RVPBinary1FWRs2pRs1pRdp<0b0111, 0b10, "paaddu.db">;
+
+def PSUB_DH : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b00, "psub.dh">;
+def PSUB_DW : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b01, "psub.dw">;
+def PSUB_DB : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b10, "psub.db">;
+def SUBD : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b11, "subd">;
+def PDIF_DH : RVPBinary1FWRs2pRs1pRdp<0b1001, 0b00, "pdif.dh">;
+def PDIF_DB : RVPBinary1FWRs2pRs1pRdp<0b1001, 0b10, "pdif.db">;
+def PSSUB_DH : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b00, "pssub.dh">;
+def PSSUB_DW : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b01, "pssub.dw">;
+def PSSUB_DB : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b10, "pssub.db">;
+def PASUB_DH : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b00, "pasub.dh">;
+def PASUB_DW : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b01, "pasub.dw">;
+def PASUB_DB : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b10, "pasub.db">;
+
+def PDIFU_DH : RVPBinary1FWRs2pRs1pRdp<0b1101, 0b00, "pdifu.dh">;
+def PDIFU_DB : RVPBinary1FWRs2pRs1pRdp<0b1101, 0b10, "pdifu.db">;
+def PSSUBU_DH : RVPBinary1FWRs2pRs1pRdp<0b1110, 0b00, "pssubu.dh">;
+def PSSUBU_DW : RVPBinary1FWRs2pRs1pRdp<0b1110, 0b01, "pssubu.dw">;
+def PSSUBU_DB : RVPBinary1FWRs2pRs1pRdp<0b1110, 0b10, "pssubu.db">;
+def PASUBU_DH : RVPBinary1FWRs2pRs1pRdp<0b1111, 0b00, "pasubu.dh">;
+def PASUBU_DW : RVPBinary1FWRs2pRs1pRdp<0b1111, 0b01, "pasubu.dw">;
+def PASUBU_DB : RVPBinary1FWRs2pRs1pRdp<0b1111, 0b10, "pasubu.db">;
+
+def PSH1ADD_DH : RVPBinary1F0WRs2pRs1pRdp<0b010, 0b00, "psh1add.dh">;
+def PSH1ADD_DW : RVPBinary1F0WRs2pRs1pRdp<0b010, 0b01, "psh1add.dw">;
+def PSSH1SADD_DH : RVPBinary1F0WRs2pRs1pRdp<0b011, 0b00, "pssh1sadd.dh">;
+def PSSH1SADD_DW : RVPBinary1F0WRs2pRs1pRdp<0b011, 0b01, "pssh1sadd.dw">;
+
+def PPACK_DH : RVPBinary1F0WRs2pRs1pRdp<0b000, 0b00, "ppack.dh", 0b0, 0b1>;
+def PPACK_DW : RVPBinary1F0WRs2pRs1pRdp<0b000, 0b01, "ppack.dw", 0b0, 0b1>;
+def PPACKBT_DH : RVPBinary1F0WRs2pRs1pRdp<0b001, 0b00, "ppackbt.dh", 0b0, 0b1>;
+def PPACKBT_DW : RVPBinary1F0WRs2pRs1pRdp<0b001, 0b01, "ppackbt.dw", 0b0, 0b1>;
+def PPACKTB_DH : RVPBinary1F0WRs2pRs1pRdp<0b010, 0b00, "ppacktb.dh", 0b0, 0b1>;
+def PPACKTB_DW : RVPBinary1F0WRs2pRs1pRdp<0b010, 0b01, "ppacktb.dw", 0b0, 0b1>;
+def PPACKT_DH : RVPBinary1F0WRs2pRs1pRdp<0b011, 0b00, "ppackt.dh", 0b0, 0b1>;
+def PPACKT_DW : RVPBinary1F0WRs2pRs1pRdp<0b011, 0b01, "ppackt.dw", 0b0, 0b1>;
+
+def PAS_DHX : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b00, "pas.dhx", 0b1>;
+def PSA_DHX : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b10, "psa.dhx", 0b1>;
+def PSAS_DHX : RVPBinary1FWRs2pRs1pRdp<0b0010, 0b00, "psas.dhx", 0b1>;
+def PSSA_DHX : RVPBinary1FWRs2pRs1pRdp<0b0010, 0b10, "pssa.dhx", 0b1>;
+def PAAX_DHX : RVPBinary1FWRs2pRs1pRdp<0b0011, 0b00, "paax.dhx", 0b1>;
+def PASA_DHX : RVPBinary1FWRs2pRs1pRdp<0b0011, 0b10, "pasa.dhx", 0b1>;
+
+def PMSEQ_DH : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b00, "pmseq.dh", 0b1>;
+def PMSEQ_DW : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b01, "pmseq.dw", 0b1>;
+def PMSEQ_DB : RVPBinary1FWRs2pRs1pRdp<0b1000, 0b10, "pmseq.db", 0b1>;
+def PMSLT_DH : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b00, "pmslt.dh", 0b1>;
+def PMSLT_DW : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b01, "pmslt.dw", 0b1>;
+def PMSLT_DB : RVPBinary1FWRs2pRs1pRdp<0b1010, 0b10, "pmslt.db", 0b1>;
+def PMSLTU_DH : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b00, "pmsltu.dh", 0b1>;
+def PMSLTU_DW : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b01, "pmsltu.dw", 0b1>;
+def PMSLTU_DB : RVPBinary1FWRs2pRs1pRdp<0b1011, 0b10, "pmsltu.db", 0b1>;
+
+def PMIN_DH : RVPBinary1FWRs2pRs1pRdp<0b1100, 0b00, "pmin.dh", 0b1>;
+def PMIN_DB : RVPBinary1FWRs2pRs1pRdp<0b1100, 0b10, "pmin.db", 0b1>;
+def PMINU_DH : RVPBinary1FWRs2pRs1pRdp<0b1101, 0b00, "pminu.dh", 0b1>;
+def PMINU_DB : RVPBinary1FWRs2pRs1pRdp<0b1101, 0b10, "pminu.db", 0b1>;
+def PMAX_DH : RVPBinary1FWRs2pRs1pRdp<0b1110, 0b00, "pmax.dh", 0b1>;
+def PMAX_DB : RVPBinary1FWRs2pRs1pRdp<0b1110, 0b10, "pmax.db", 0b1>;
+def PMAXU_DH : RVPBinary1FWRs2pRs1pRdp<0b1111, 0b00, "pmaxu.dh", 0b1>;
+def PMAXU_DB : RVPBinary1FWRs2pRs1pRdp<0b1111, 0b10, "pmaxu.db", 0b1>;
+} // Predicates = [HasStdExtP, IsRV32]
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoZb.td b/llvm/lib/Target/RISCV/RISCVInstrInfoZb.td
index 124caa3b69d31e..2ce909c5d0e21f 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoZb.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoZb.td
@@ -263,9 +263,10 @@ def XNOR : ALU_rr<0b0100000, 0b100, "xnor">,
Sched<[WriteIALU, ReadIALU, ReadIALU]>;
} // Predicates = [HasStdExtZbbOrZbkb]
-let Predicates = [HasStdExtZba] in {
+let Predicates = [HasStdExtZbaOrP] in
def SH1ADD : ALU_rr<0b0010000, 0b010, "sh1add">,
Sched<[WriteSHXADD, ReadSHXADD, ReadSHXADD]>;
+let Predicates = [HasStdExtZba] in {
def SH2ADD : ALU_rr<0b0010000, 0b100, "sh2add">,
Sched<[WriteSHXADD, ReadSHXADD, ReadSHXADD]>;
def SH3ADD : ALU_rr<0b0010000, 0b110, "sh3add">,
@@ -337,30 +338,32 @@ def XPERM8 : ALU_rr<0b0010100, 0b100, "xperm8">,
Sched<[WriteXPERM, ReadXPERM, ReadXPERM]>;
} // Predicates = [HasStdExtZbkx]
-let Predicates = [HasStdExtZbb], IsSignExtendingOpW = 1 in {
+let Predicates = [HasStdExtZbbOrP], IsSignExtendingOpW = 1 in
def CLZ : Unary_r<0b011000000000, 0b001, "clz">,
Sched<[WriteCLZ, ReadCLZ]>;
+let Predicates = [HasStdExtZbb], IsSignExtendingOpW = 1 in {
def CTZ : Unary_r<0b011000000001, 0b001, "ctz">,
Sched<[WriteCTZ, ReadCTZ]>;
def CPOP : Unary_r<0b011000000010, 0b001, "cpop">,
Sched<[WriteCPOP, ReadCPOP]>;
} // Predicates = [HasStdExtZbb]
-let Predicates = [HasStdExtZbb, IsRV64], IsSignExtendingOpW = 1 in {
+let Predicates = [HasStdExtZbbOrP, IsRV64], IsSignExtendingOpW = 1 in
def CLZW : UnaryW_r<0b011000000000, 0b001, "clzw">,
Sched<[WriteCLZ32, ReadCLZ32]>;
+let Predicates = [HasStdExtZbb, IsRV64], IsSignExtendingOpW = 1 in {
def CTZW : UnaryW_r<0b011000000001, 0b001, "ctzw">,
Sched<[WriteCTZ32, ReadCTZ32]>;
def CPOPW : UnaryW_r<0b011000000010, 0b001, "cpopw">,
Sched<[WriteCPOP32, ReadCPOP32]>;
} // Predicates = [HasStdExtZbb, IsRV64]
-let Predicates = [HasStdExtZbb], IsSignExtendingOpW = 1 in {
+let Predicates = [HasStdExtZbbOrP], IsSignExtendingOpW = 1 in {
def SEXT_B : Unary_r<0b011000000100, 0b001, "sext.b">,
Sched<[WriteIALU, ReadIALU]>;
def SEXT_H : Unary_r<0b011000000101, 0b001, "sext.h">,
Sched<[WriteIALU, ReadIALU]>;
-} // Predicates = [HasStdExtZbb]
+} // Predicates = [HasStdExtZbbOrP]
let Predicates = [HasStdExtZbc] in {
def CLMULR : ALU_rr<0b0000101, 0b010, "clmulr", Commutable=1>,
@@ -374,7 +377,7 @@ def CLMULH : ALU_rr<0b0000101, 0b011, "clmulh", Commutable=1>,
Sched<[WriteCLMUL, ReadCLMUL, ReadCLMUL]>;
} // Predicates = [HasStdExtZbcOrZbkc]
-let Predicates = [HasStdExtZbb] in {
+let Predicates = [HasStdExtZbbOrP] in {
def MIN : ALU_rr<0b0000101, 0b100, "min", Commutable=1>,
Sched<[WriteIMinMax, ReadIMinMax, ReadIMinMax]>;
def MINU : ALU_rr<0b0000101, 0b101, "minu", Commutable=1>,
@@ -385,9 +388,10 @@ def MAXU : ALU_rr<0b0000101, 0b111, "maxu", Commutable=1>,
Sched<[WriteIMinMax, ReadIMinMax, ReadIMinMax]>;
} // Predicates = [HasStdExtZbb]
-let Predicates = [HasStdExtZbkb] in {
+let Predicates = [HasStdExtZbkbOrP] in
def PACK : ALU_rr<0b0000100, 0b100, "pack">,
Sched<[WritePACK, ReadPACK, ReadPACK]>;
+let Predicates = [HasStdExtZbkb] in {
let IsSignExtendingOpW = 1 in
def PACKH : ALU_rr<0b0000100, 0b111, "packh">,
Sched<[WritePACK, ReadPACK, ReadPACK]>;
@@ -407,15 +411,15 @@ def ZEXT_H_RV64 : RVBUnaryR<0b0000100, 0b100, OPC_OP_32, "zext.h">,
Sched<[WriteIALU, ReadIALU]>;
} // Predicates = [HasStdExtZbb, IsRV64]
-let Predicates = [HasStdExtZbbOrZbkb, IsRV32] in {
+let Predicates = [HasStdExtZbbOrZbkbOrP, IsRV32] in {
def REV8_RV32 : Unary_r<0b011010011000, 0b101, "rev8">,
Sched<[WriteREV8, ReadREV8]>;
-} // Predicates = [HasStdExtZbbOrZbkb, IsRV32]
+} // Predicates = [HasStdExtZbbOrZbkbOrP, IsRV32]
-let Predicates = [HasStdExtZbbOrZbkb, IsRV64] in {
+let Predicates = [HasStdExtZbbOrZbkbOrP, IsRV64] in {
def REV8_RV64 : Unary_r<0b011010111000, 0b101, "rev8">,
Sched<[WriteREV8, ReadREV8]>;
-} // Predicates = [HasStdExtZbbOrZbkb, IsRV64]
+} // Predicates = [HasStdExtZbbOrZbkbOrP, IsRV64]
let Predicates = [HasStdExtZbb] in {
def ORC_B : Unary_r<0b001010000111, 0b101, "orc.b">,
diff --git a/llvm/test/CodeGen/RISCV/attributes.ll b/llvm/test/CodeGen/RISCV/attributes.ll
index a09261609d8441..072ff59f0dccf9 100644
--- a/llvm/test/CodeGen/RISCV/attributes.ll
+++ b/llvm/test/CodeGen/RISCV/attributes.ll
@@ -300,6 +300,7 @@
; RUN: llc -mtriple=riscv64 -mattr=+experimental-ssctr %s -o - | FileCheck --check-prefix=RV64SSCTR %s
; RUN: llc -mtriple=riscv64 -mattr=+experimental-sdext %s -o - | FileCheck --check-prefix=RV64SDEXT %s
; RUN: llc -mtriple=riscv64 -mattr=+experimental-sdtrig %s -o - | FileCheck --check-prefix=RV64SDTRIG %s
+; RUN: llc -mtriple=riscv64 -mattr=+experimental-p %s -o - | FileCheck --check-prefix=RV64P %s
; Tests for profile features.
; RUN: llc -mtriple=riscv32 -mattr=+rvi20u32 %s -o - | FileCheck --check-prefix=RVI20U32 %s
@@ -465,6 +466,7 @@
; RV32SUPM: .attribute 5, "rv32i2p1_supm1p0"
; RV32SMCTR: .attribute 5, "rv32i2p1_smctr1p0_sscsrind1p0"
; RV32SSCTR: .attribute 5, "rv32i2p1_sscsrind1p0_ssctr1p0"
+; RV32P: .attribute 5, "rv32i2p1_p1p0"
; RV64M: .attribute 5, "rv64i2p1_m2p0_zmmul1p0"
; RV64ZMMUL: .attribute 5, "rv64i2p1_zmmul1p0"
@@ -613,6 +615,7 @@
; RV64SSCTR: .attribute 5, "rv64i2p1_sscsrind1p0_ssctr1p0"
; RV64SDEXT: .attribute 5, "rv64i2p1_sdext1p0"
; RV64SDTRIG: .attribute 5, "rv64i2p1_sdtrig1p0"
+; RV64P: .attribute 5, "rv64i2p1_p1p0"
; RVI20U32: .attribute 5, "rv32i2p1"
; RVI20U64: .attribute 5, "rv64i2p1"
diff --git a/llvm/test/MC/RISCV/attribute-arch.s b/llvm/test/MC/RISCV/attribute-arch.s
index 4e77a53bd706c2..047f020047a63d 100644
--- a/llvm/test/MC/RISCV/attribute-arch.s
+++ b/llvm/test/MC/RISCV/attribute-arch.s
@@ -473,3 +473,9 @@
.attribute arch, "rv32i_sdtrig1p0"
# CHECK: attribute 5, "rv32i2p1_sdtrig1p0"
+
+.attribute arch, "rv32i_p1p0"
+# CHECK: attribute 5, "rv32i2p1_p1p0"
+
+.attribute arch, "rv64i_p1p0"
+# CHECK: attribute 5, "rv64i2p1_p1p0"
\ No newline at end of file
diff --git a/llvm/test/MC/RISCV/invalid-instruction-spellcheck.s b/llvm/test/MC/RISCV/invalid-instruction-spellcheck.s
index c5c0d2f3a0b12c..8e8c42e033b8a0 100644
--- a/llvm/test/MC/RISCV/invalid-instruction-spellcheck.s
+++ b/llvm/test/MC/RISCV/invalid-instruction-spellcheck.s
@@ -22,10 +22,10 @@ fl ft0, 0(sp)
# CHECK-RV64IF: did you mean: flw, la, lb, ld, lh, li, lw
# CHECK-NEXT: fl ft0, 0(sp)
-addd x1, x1, x1
+addc x1, x1, x1
# CHECK-RV32: did you mean: add, addi
# CHECK-RV64: did you mean: add, addi, addw
-# CHECK-NEXT: addd x1, x1, x1
+# CHECK-NEXT: addc x1, x1, x1
vm x0, x0
# CHECK: did you mean: mv
diff --git a/llvm/test/MC/RISCV/rv32i-invalid.s b/llvm/test/MC/RISCV/rv32i-invalid.s
index ac0e3c6c1bdbfe..1ffb10789bbbdf 100644
--- a/llvm/test/MC/RISCV/rv32i-invalid.s
+++ b/llvm/test/MC/RISCV/rv32i-invalid.s
@@ -191,8 +191,8 @@ fadd.s a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the followi
fadd.d a0, a2, a4 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zdinx' (Double in Integer){{$}}
fadd.h a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zhinx' (Half Float in Integer){{$}}
flh ft0, (a0) # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zfh' (Half-Precision Floating-Point) or 'Zfhmin' (Half-Precision Floating-Point Minimal){{$}}
-sh1add a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zba' (Address Generation Instructions){{$}}
-clz a0, a1 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zbb' (Basic Bit-Manipulation){{$}}
+sh1add a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zba' (Address Generation Instructions) or 'Base P' (Packed-SIMD){{$}}
+clz a0, a1 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zbb' (Basic Bit-Manipulation) or 'Base P' (Packed-SIMD){{$}}
clmul a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zbc' (Carry-Less Multiplication) or 'Zbkc' (Carry-less multiply instructions for Cryptography){{$}}
bset a0, a1, a2 # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zbs' (Single-Bit Instructions){{$}}
pause # CHECK: :[[@LINE]]:1: error: instruction requires the following: 'Zihintpause' (Pause Hint){{$}}
diff --git a/llvm/test/MC/RISCV/rv32p-invalid.s b/llvm/test/MC/RISCV/rv32p-invalid.s
new file mode 100644
index 00000000000000..4b705a8db48541
--- /dev/null
+++ b/llvm/test/MC/RISCV/rv32p-invalid.s
@@ -0,0 +1,14 @@
+# RUN: not llvm-mc -triple=riscv32 --mattr=+experimental-p %s 2>&1 \
+# RUN: | FileCheck %s --check-prefixes=CHECK-ERROR
+
+# Imm overflow
+pli.h a0, 0x400
+# CHECK-ERROR: immediate must be an integer in the range [-512, 511]
+pli.b a0, 0x200
+# CHECK-ERROR: immediate must be an integer in the range [0, 255]
+
+# Must be even register
+pwadd.b a1, a2, a3
+# CHECK-ERROR: register must be even
+pmqwacc.h a1, a1, a2
+# CHECK-ERROR: register must be even
diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s
new file mode 100644
index 00000000000000..57f96048898eed
--- /dev/null
+++ b/llvm/test/MC/RISCV/rv32p-valid.s
@@ -0,0 +1,1440 @@
+// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --llvm-mc-binary ./llvm-mc --tool ./llvm-objdump --version 5
+# RUN: llvm-mc %s -triple=riscv32 -mattr=+experimental-p -riscv-no-aliases -show-encoding \
+# RUN: | FileCheck -check-prefixes=CHECK-ASM %s
+
+clz a0, a1
+// CHECK-ASM: clz a0, a1 # encoding: [0x13,0x95,0x05,0x60]
+
+cls a1, a2
+// CHECK-ASM: cls a1, a2 # encoding: [0x93,0x15,0x36,0x60]
+
+sext.b a2, a3
+// CHECK-ASM: sext.b a2, a3 # encoding: [0x13,0x96,0x46,0x60]
+
+sext.h t0, t1
+// CHECK-ASM: sext.h t0, t1 # encoding: [0x93,0x12,0x53,0x60]
+
+abs a4, a5
+// CHECK-ASM: abs a4, a5 # encoding: [0x13,0x97,0x77,0x60]
+
+rev8 s0, s1
+// CHECK-ASM: rev8 s0, s1 # encoding: [0x13,0xd4,0x84,0x69]
+
+rev s2, s3
+// CHECK-ASM: rev s2, s3 # encoding: [0x13,0xd9,0xf9,0x69]
+
+sh1add a0, a1, a2
+// CHECK-ASM: sh1add a0, a1, a2 # encoding: [0x33,0xa5,0xc5,0x20]
+
+pack s0, s1, s2
+// CHECK-ASM: pack s0, s1, s2 # encoding: [0x33,0xc4,0x24,0x09]
+
+min t0, t1, t2
+// CHECK-ASM: min t0, t1, t2 # encoding: [0xb3,0x42,0x73,0x0a]
+
+minu x1, x2, x3
+// CHECK-ASM: minu ra, sp, gp # encoding: [0xb3,0x50,0x31,0x0a]
+
+max t3, t4, t5
+// CHECK-ASM: max t3, t4, t5 # encoding: [0x33,0xee,0xee,0x0b]
+
+maxu a4, a5, a6
+// CHECK-ASM: maxu a4, a5, a6 # encoding: [0x33,0xf7,0x07,0x0b]
+
+pslli.b a6, a7
+// CHECK-ASM: pslli.b a6, a7 # encoding: [0x1b,0xa8,0x88,0x80]
+
+pslli.h x1, x2
+// CHECK-ASM: pslli.h ra, sp # encoding: [0x9b,0x20,0x01,0x81]
+
+psslai.h t0, t1
+// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0xd1]
+
+sslai a4, a5
+// CHECK-ASM: sslai a4, a5 # encoding: [0x1b,0xa7,0x07,0xd2]
+
+pli.h a5, 0x5
+// CHECK-ASM: pli.h a5, 5 # encoding: [0x9b,0xa7,0x02,0xb0]
+
+pli.b a6, 0x6
+// CHECK-ASM: pli.b a6, 6 # encoding: [0x1b,0x28,0x06,0xb4]
+
+psextb.h a7, a0
+// CHECK-ASM: psextb.h a7, a0 # encoding: [0x9b,0x28,0x45,0xe0]
+
+psabs.h a1, a2
+// CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0]
+
+psabs.b t0, t1
+// CHECK-ASM: psabs.b t0, t1 # encoding: [0x9b,0x22,0x73,0xe2]
+
+plui.h x3, 0x3
+// CHECK-ASM: plui.h gp, 3 # encoding: [0x9b,0xa1,0x01,0xf0]
+
+psll.h.h0 a0, a1, a2
+// CHECK-ASM: psll.h.h0 a0, a1, a2 # encoding: [0x1b,0xa5,0xc5,0x88]
+
+psll.b.b0 a3, a4, a5
+// CHECK-ASM: psll.b.b0 a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0x8c]
+
+padd.h.h0 t0, t1, t2
+// CHECK-ASM: padd.h.h0 t0, t1, t2 # encoding: [0x9b,0x22,0x73,0x98]
+
+padd.b.b0 x1, a1, a2
+// CHECK-ASM: padd.b.b0 ra, a1, a2 # encoding: [0x9b,0xa0,0xc5,0x9c]
+
+pssha.h.h0 a3, a4, a5
+// CHECK-ASM: pssha.h.h0 a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0xe8]
+
+ssha x3, a4, a5
+// CHECK-ASM: ssha gp, a4, a5 # encoding: [0x9b,0x21,0xf7,0xea]
+
+psshar.h.h0 a6, a7, a0
+// CHECK-ASM: psshar.h.h0 a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8]
+
+sshar x6, a7, a0
+// CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa]
+
+psrli.b a1, a2
+// CHECK-ASM: psrli.b a1, a2 # encoding: [0x9b,0x45,0x86,0x80]
+
+psrli.h a0, a1
+// CHECK-ASM: psrli.h a0, a1 # encoding: [0x1b,0xc5,0x05,0x81]
+
+pusati.h a2, t1
+// CHECK-ASM: pusati.h a2, t1 # encoding: [0x1b,0x46,0x03,0xa1]
+
+usati a3, t2
+// CHECK-ASM: usati a3, t2 # encoding: [0x9b,0xc6,0x03,0xa2]
+
+psrai.b a4, a5
+// CHECK-ASM: psrai.b a4, a5 # encoding: [0x1b,0xc7,0x87,0xc0]
+
+psrai.h a6, a7
+// CHECK-ASM: psrai.h a6, a7 # encoding: [0x1b,0xc8,0x08,0xc1]
+
+psrari.h a0, a1
+// CHECK-ASM: psrari.h a0, a1 # encoding: [0x1b,0xc5,0x05,0xd1]
+
+srari a2, a3
+// CHECK-ASM: srari a2, a3 # encoding: [0x1b,0xc6,0x06,0xd2]
+
+psati.h a4, t0
+// CHECK-ASM: psati.h a4, t0 # encoding: [0x1b,0xc7,0x02,0xe1]
+
+sati a5, t1
+// CHECK-ASM: sati a5, t1 # encoding: [0x9b,0x47,0x03,0xe2]
+
+psrl.h.h0 a6, a7, a1
+// CHECK-ASM: psrl.h.h0 a6, a7, a1 # encoding: [0x1b,0xc8,0xb8,0x88]
+
+psrl.b.b0 a1, a2, a3
+// CHECK-ASM: psrl.b.b0 a1, a2, a3 # encoding: [0x9b,0x45,0xd6,0x8c]
+
+predsum.h a4, a5, a6
+// CHECK-ASM: predsum.h a4, a5, a6 # encoding: [0x1b,0xc7,0x07,0x99]
+
+predsum.b a7, a1, a1
+// CHECK-ASM: predsum.b a7, a1, a1 # encoding: [0x9b,0xc8,0xb5,0x9c]
+
+predsumu.h t0, t1, t2
+// CHECK-ASM: predsumu.h t0, t1, t2 # encoding: [0x9b,0x42,0x73,0xb8]
+
+predsumu.b t3, t4, t5
+// CHECK-ASM: predsumu.b t3, t4, t5 # encoding: [0x1b,0xce,0xee,0xbd]
+
+psra.h.h0 x1, a1, a2
+// CHECK-ASM: psra.h.h0 ra, a1, a2 # encoding: [0x9b,0xc0,0xc5,0xc8]
+
+psra.b.b0 x2, a2, a3
+// CHECK-ASM: psra.b.b0 sp, a2, a3 # encoding: [0x1b,0x41,0xd6,0xcc]
+
+psslai.h t0, t1
+// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0xd1]
+
+sslai a4, a5
+// CHECK-ASM: sslai a4, a5 # encoding: [0x1b,0xa7,0x07,0xd2]
+
+pli.h a5, 0x5
+// CHECK-ASM: pli.h a5, 5 # encoding: [0x9b,0xa7,0x02,0xb0]
+
+pli.b a6, 0x6
+// CHECK-ASM: pli.b a6, 6 # encoding: [0x1b,0x28,0x06,0xb4]
+
+psextb.h a7, a0
+// CHECK-ASM: psextb.h a7, a0 # encoding: [0x9b,0x28,0x45,0xe0]
+
+psabs.h a1, a2
+// CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0]
+
+psabs.b t0, t1
+// CHECK-ASM: psabs.b t0, t1 # encoding: [0x9b,0x22,0x73,0xe2]
+
+plui.h x3, 0x3
+// CHECK-ASM: plui.h gp, 3 # encoding: [0x9b,0xa1,0x01,0xf0]
+
+psll.h.h0 a0, a1, a2
+// CHECK-ASM: psll.h.h0 a0, a1, a2 # encoding: [0x1b,0xa5,0xc5,0x88]
+
+psll.b.b0 a3, a4, a5
+// CHECK-ASM: psll.b.b0 a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0x8c]
+
+padd.h.h0 t0, t1, t2
+// CHECK-ASM: padd.h.h0 t0, t1, t2 # encoding: [0x9b,0x22,0x73,0x98]
+
+padd.b.b0 x1, a1, a2
+// CHECK-ASM: padd.b.b0 ra, a1, a2 # encoding: [0x9b,0xa0,0xc5,0x9c]
+
+pssha.h.h0 a3, a4, a5
+// CHECK-ASM: pssha.h.h0 a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0xe8]
+
+ssha x3, a4, a5
+// CHECK-ASM: ssha gp, a4, a5 # encoding: [0x9b,0x21,0xf7,0xea]
+
+psshar.h.h0 a6, a7, a0
+// CHECK-ASM: psshar.h.h0 a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8]
+
+sshar x6, a7, a0
+// CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa]
+
+psrli.b a1, a2
+// CHECK-ASM: psrli.b a1, a2 # encoding: [0x9b,0x45,0x86,0x80]
+
+psrli.h a0, a1
+// CHECK-ASM: psrli.h a0, a1 # encoding: [0x1b,0xc5,0x05,0x81]
+
+pusati.h a2, t1
+// CHECK-ASM: pusati.h a2, t1 # encoding: [0x1b,0x46,0x03,0xa1]
+
+usati a3, t2
+// CHECK-ASM: usati a3, t2 # encoding: [0x9b,0xc6,0x03,0xa2]
+
+psrai.b a4, a5
+// CHECK-ASM: psrai.b a4, a5 # encoding: [0x1b,0xc7,0x87,0xc0]
+
+psrai.h a6, a7
+// CHECK-ASM: psrai.h a6, a7 # encoding: [0x1b,0xc8,0x08,0xc1]
+
+psrari.h a0, a1
+// CHECK-ASM: psrari.h a0, a1 # encoding: [0x1b,0xc5,0x05,0xd1]
+
+srari a2, a3
+// CHECK-ASM: srari a2, a3 # encoding: [0x1b,0xc6,0x06,0xd2]
+
+psati.h a4, t0
+// CHECK-ASM: psati.h a4, t0 # encoding: [0x1b,0xc7,0x02,0xe1]
+
+sati a5, t1
+// CHECK-ASM: sati a5, t1 # encoding: [0x9b,0x47,0x03,0xe2]
+
+psrl.h.h0 a6, a7, a1
+// CHECK-ASM: psrl.h.h0 a6, a7, a1 # encoding: [0x1b,0xc8,0xb8,0x88]
+
+psrl.b.b0 a1, a2, a3
+// CHECK-ASM: psrl.b.b0 a1, a2, a3 # encoding: [0x9b,0x45,0xd6,0x8c]
+
+predsum.h a4, a5, a6
+// CHECK-ASM: predsum.h a4, a5, a6 # encoding: [0x1b,0xc7,0x07,0x99]
+
+predsum.b a7, a1, a1
+// CHECK-ASM: predsum.b a7, a1, a1 # encoding: [0x9b,0xc8,0xb5,0x9c]
+
+predsumu.h t0, t1, t2
+// CHECK-ASM: predsumu.h t0, t1, t2 # encoding: [0x9b,0x42,0x73,0xb8]
+
+predsumu.b t3, t4, t5
+// CHECK-ASM: predsumu.b t3, t4, t5 # encoding: [0x1b,0xce,0xee,0xbd]
+
+psra.h.h0 x1, a1, a2
+// CHECK-ASM: psra.h.h0 ra, a1, a2 # encoding: [0x9b,0xc0,0xc5,0xc8]
+
+psra.b.b0 x2, a2, a3
+// CHECK-ASM: psra.b.b0 sp, a2, a3 # encoding: [0x1b,0x41,0xd6,0xcc]
+
+padd.h t0, t1, t2
+// CHECK-ASM: padd.h t0, t1, t2 # encoding: [0xbb,0x02,0x73,0x80]
+
+padd.b x1, a1, a2
+// CHECK-ASM: padd.b ra, a1, a2 # encoding: [0xbb,0x80,0xc5,0x84]
+
+psadd.h t3, t4, t5
+// CHECK-ASM: psadd.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0x91]
+
+sadd x6, a7, a0
+// CHECK-ASM: sadd t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0x92]
+
+psadd.b t0, t1, t2
+// CHECK-ASM: psadd.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0x94]
+
+paadd.h t3, t4, t5
+// CHECK-ASM: paadd.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0x99]
+
+aadd x6, a7, a0
+// CHECK-ASM: aadd t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0x9a]
+
+paadd.b t0, t1, t2
+// CHECK-ASM: paadd.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0x9c]
+
+psaddu.h t3, t4, t5
+// CHECK-ASM: psaddu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xb1]
+
+saddu x6, a7, a0
+// CHECK-ASM: saddu t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xb2]
+
+psaddu.b t0, t1, t2
+// CHECK-ASM: psaddu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xb4]
+
+paaddu.h t3, t4, t5
+// CHECK-ASM: paaddu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xb9]
+
+aaddu x6, a7, a0
+// CHECK-ASM: aaddu t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xba]
+
+paaddu.b t0, t1, t2
+// CHECK-ASM: paaddu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xbc]
+
+psub.h t3, t4, t5
+// CHECK-ASM: psub.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xc1]
+
+psub.b t0, t1, t2
+// CHECK-ASM: psub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xc4]
+
+pdif.h t3, t4, t5
+// CHECK-ASM: pdif.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xc9]
+
+pdif.b t0, t1, t2
+// CHECK-ASM: pdif.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xcc]
+
+pssub.h t3, t4, t5
+// CHECK-ASM: pssub.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xd1]
+
+ssub x6, a7, a0
+// CHECK-ASM: ssub t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xd2]
+
+pssub.b t0, t1, t2
+// CHECK-ASM: pssub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xd4]
+
+pasub.h t3, t4, t5
+// CHECK-ASM: pasub.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xd9]
+
+asub x6, a7, a0
+// CHECK-ASM: asub t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xda]
+
+pasub.b t0, t1, t2
+// CHECK-ASM: pasub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xdc]
+
+pdifu.h t3, t4, t5
+// CHECK-ASM: pdifu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xe9]
+
+pdifu.b t0, t1, t2
+// CHECK-ASM: pdifu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xec]
+
+pssubu.h t3, t4, t5
+// CHECK-ASM: pssubu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xf1]
+
+ssubu x6, a7, a0
+// CHECK-ASM: ssubu t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xf2]
+
+pssubu.b t0, t1, t2
+// CHECK-ASM: pssubu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xf4]
+
+pasubu.h t3, t4, t5
+// CHECK-ASM: pasubu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xf9]
+
+asubu x6, a7, a0
+// CHECK-ASM: asubu t1, a7, a0 # encoding: [0x3b,0x83,0xa8,0xfa]
+
+pasubu.b t0, t1, t2
+// CHECK-ASM: pasubu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xfc]
+
+slx x3, a4, a5
+// CHECK-ASM: slx gp, a4, a5 # encoding: [0xbb,0x11,0xf7,0x8e]
+
+pmul.h.beo t3, t4, t5
+// CHECK-ASM: pmul.h.beo t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x91]
+
+mul.h01 t0, t1, t2
+// CHECK-ASM: mul.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0x92]
+
+macc.h01 t3, t4, t5
+// CHECK-ASM: macc.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x9b]
+
+mvm a0, a1, a2
+// CHECK-ASM: mvm a0, a1, a2 # encoding: [0x3b,0x95,0xc5,0xa8]
+
+mvmn x3, a4, a5
+// CHECK-ASM: mvmn gp, a4, a5 # encoding: [0xbb,0x11,0xf7,0xaa]
+
+merge t0, t1, t2
+// CHECK-ASM: merge t0, t1, t2 # encoding: [0xbb,0x12,0x73,0xac]
+
+srx x3, a4, a5
+// CHECK-ASM: srx gp, a4, a5 # encoding: [0xbb,0x11,0xf7,0xae]
+
+pmulu.h.beo t3, t4, t5
+// CHECK-ASM: pmulu.h.beo t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xb1]
+
+mulu.h01 t0, t1, t2
+// CHECK-ASM: mulu.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0xb2]
+
+pdifsumu.b t3, t4, t5
+// CHECK-ASM: pdifsumu.b t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xb5]
+
+maccu.h01 t3, t4, t5
+// CHECK-ASM: maccu.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xbb]
+
+pdifsumau.b t3, t4, t5
+// CHECK-ASM: pdifsumau.b t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xbd]
+
+mul.h01 t0, t1, t2
+// CHECK-ASM: mul.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0x92]
+
+macc.h01 t3, t4, t5
+// CHECK-ASM: macc.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x9b]
+
+mulu.h01 a0, a1, a2
+// CHECK-ASM: mulu.h01 a0, a1, a2 # encoding: [0x3b,0x95,0xc5,0xb2]
+
+maccu.h01 a3, a4, a5
+// CHECK-ASM: maccu.h01 a3, a4, a5 # encoding: [0xbb,0x16,0xf7,0xba]
+
+psh1add.h a0, a1, a2
+// CHECK-ASM: psh1add.h a0, a1, a2 # encoding: [0x3b,0xa5,0xc5,0xa0]
+
+pssh1sadd.h a3, a4, a5
+// CHECK-ASM: pssh1sadd.h a3, a4, a5 # encoding: [0xbb,0x26,0xf7,0xb0]
+
+ssh1sadd t0, t1, t2
+// CHECK-ASM: ssh1sadd t0, t1, t2 # encoding: [0xbb,0x22,0x73,0xa2]
+
+pmul.h.bee s6, t4, s8
+// CHECK-ASM: pmul.h.bee s6, t4, s8 # encoding: [0x3b,0xbb,0x8e,0x81]
+
+pmul.h.boo t0, t4, s4
+// CHECK-ASM: pmul.h.boo t0, t4, s4 # encoding: [0xbb,0xb2,0x4e,0x91]
+
+pmulu.h.bee t2, s6, s8
+// CHECK-ASM: pmulu.h.bee t2, s6, s8 # encoding: [0xbb,0x33,0x8b,0xa1]
+
+pmulu.h.boo t2, s6, a0
+// CHECK-ASM: pmulu.h.boo t2, s6, a0 # encoding: [0xbb,0x33,0xab,0xb0]
+
+pmulsu.h.bee s4, a4, s8
+// CHECK-ASM: pmulsu.h.bee s4, a4, s8 # encoding: [0x3b,0x3a,0x87,0xe1]
+
+pmulsu.h.boo s6, a2, s4
+// CHECK-ASM: pmulsu.h.boo s6, a2, s4 # encoding: [0x3b,0x3b,0x46,0xf1]
+
+mul.h00 a4, t4, s2
+// CHECK-ASM: mul.h00 a4, t4, s2 # encoding: [0x3b,0xb7,0x2e,0x83]
+
+macc.h00 a4, a0, s0
+// CHECK-ASM: macc.h00 a4, a0, s0 # encoding: [0x3b,0x37,0x85,0x8a]
+
+mul.h11 a0, a4, a0
+// CHECK-ASM: mul.h11 a0, a4, a0 # encoding: [0x3b,0x35,0xa7,0x92]
+
+macc.h11 s6, a4, s4
+// CHECK-ASM: macc.h11 s6, a4, s4 # encoding: [0x3b,0x3b,0x47,0x9b]
+
+mulu.h00 s6, s0, a0
+// CHECK-ASM: mulu.h00 s6, s0, a0 # encoding: [0x3b,0x3b,0xa4,0xa2]
+
+maccu.h00 s0, s6, s0
+// CHECK-ASM: maccu.h00 s0, s6, s0 # encoding: [0x3b,0x34,0x8b,0xaa]
+
+mulu.h11 s0, s4, s6
+// CHECK-ASM: mulu.h11 s0, s4, s6 # encoding: [0x3b,0x34,0x6a,0xb3]
+
+maccu.h11 s0, t4, t4
+// CHECK-ASM: maccu.h11 s0, t4, t4 # encoding: [0x3b,0xb4,0xde,0xbb]
+
+mulsu.h00 a4, s4, s6
+// CHECK-ASM: mulsu.h00 a4, s4, s6 # encoding: [0x3b,0x37,0x6a,0xe3]
+
+maccsu.h00 s4, s4, s0
+// CHECK-ASM: maccsu.h00 s4, s4, s0 # encoding: [0x3b,0x3a,0x8a,0xea]
+
+mulsu.h11 s8, s4, s0
+// CHECK-ASM: mulsu.h11 s8, s4, s0 # encoding: [0x3b,0x3c,0x8a,0xf2]
+
+maccsu.h11 s0, a2, s6
+// CHECK-ASM: maccsu.h11 s0, a2, s6 # encoding: [0x3b,0x34,0x66,0xfb]
+
+ppack.h t1, a2, t5
+// CHECK-ASM: ppack.h t1, a2, t5 # encoding: [0x3b,0x43,0xe6,0x81]
+
+ppackbt.h t5, t3, s2
+// CHECK-ASM: ppackbt.h t5, t3, s2 # encoding: [0x3b,0x4f,0x2e,0x91]
+
+ppacktb.h t1, t1, s0
+// CHECK-ASM: ppacktb.h t1, t1, s0 # encoding: [0x3b,0x43,0x83,0xa0]
+
+ppackt.h t3, s0, s0
+// CHECK-ASM: ppackt.h t3, s0, s0 # encoding: [0x3b,0x4e,0x84,0xb0]
+
+packbt t1, t1, s2
+// CHECK-ASM: packbt t1, t1, s2 # encoding: [0x3b,0x43,0x23,0x93]
+
+packtb t5, s0, a2
+// CHECK-ASM: packtb t5, s0, a2 # encoding: [0x3b,0x4f,0xc4,0xa2]
+
+packt a4, t5, t5
+// CHECK-ASM: packt a4, t5, t5 # encoding: [0x3b,0x47,0xef,0xb3]
+
+pm2add.h t3, t1, s0
+// CHECK-ASM: pm2add.h t3, t1, s0 # encoding: [0x3b,0x5e,0x83,0x80]
+
+pm4add.b t1, s2, t5
+// CHECK-ASM: pm4add.b t1, s2, t5 # encoding: [0x3b,0x53,0xe9,0x85]
+
+pm2adda.h t1, s2, a4
+// CHECK-ASM: pm2adda.h t1, s2, a4 # encoding: [0x3b,0x53,0xe9,0x88]
+
+pm4adda.b t3, a0, t5
+// CHECK-ASM: pm4adda.b t3, a0, t5 # encoding: [0x3b,0x5e,0xe5,0x8d]
+
+pm2add.hx s0, t5, a4
+// CHECK-ASM: pm2add.hx s0, t5, a4 # encoding: [0x3b,0x54,0xef,0x90]
+
+pm2adda.hx a0, a0, t1
+// CHECK-ASM: pm2adda.hx a0, a0, t1 # encoding: [0x3b,0x55,0x65,0x98]
+
+pm2addu.h s2, t5, a2
+// CHECK-ASM: pm2addu.h s2, t5, a2 # encoding: [0x3b,0x59,0xcf,0xa0]
+
+pm4addu.b t5, s0, t1
+// CHECK-ASM: pm4addu.b t5, s0, t1 # encoding: [0x3b,0x5f,0x64,0xa4]
+
+pm2addau.h t3, t1, t5
+// CHECK-ASM: pm2addau.h t3, t1, t5 # encoding: [0x3b,0x5e,0xe3,0xa9]
+
+pm4addau.b a4, t3, a0
+// CHECK-ASM: pm4addau.b a4, t3, a0 # encoding: [0x3b,0x57,0xae,0xac]
+
+pmq2add.h t1, a2, t1
+// CHECK-ASM: pmq2add.h t1, a2, t1 # encoding: [0x3b,0x53,0x66,0xb0]
+
+pmqr2add.h a2, a4, s2
+// CHECK-ASM: pmqr2add.h a2, a4, s2 # encoding: [0x3b,0x56,0x27,0xb5]
+
+pmq2adda.h t5, t3, t1
+// CHECK-ASM: pmq2adda.h t5, t3, t1 # encoding: [0x3b,0x5f,0x6e,0xb8]
+
+pmqr2adda.h t1, s0, a2
+// CHECK-ASM: pmqr2adda.h t1, s0, a2 # encoding: [0x3b,0x53,0xc4,0xbc]
+
+pm2sub.h t1, a0, a4
+// CHECK-ASM: pm2sub.h t1, a0, a4 # encoding: [0x3b,0x53,0xe5,0xc0]
+
+pm2sadd.h s2, s2, t3
+// CHECK-ASM: pm2sadd.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0xc5]
+
+pm2suba.h s0, s0, t3
+// CHECK-ASM: pm2suba.h s0, s0, t3 # encoding: [0x3b,0x54,0xc4,0xc9]
+
+pm2sub.hx a2, a2, a0
+// CHECK-ASM: pm2sub.hx a2, a2, a0 # encoding: [0x3b,0x56,0xa6,0xd0]
+
+pm2sadd.hx t5, s2, a0
+// CHECK-ASM: pm2sadd.hx t5, s2, a0 # encoding: [0x3b,0x5f,0xa9,0xd4]
+
+pm2suba.hx a4, a2, t5
+// CHECK-ASM: pm2suba.hx a4, a2, t5 # encoding: [0x3b,0x57,0xe6,0xd9]
+
+pm2addsu.h s0, s0, s2
+// CHECK-ASM: pm2addsu.h s0, s0, s2 # encoding: [0x3b,0x54,0x24,0xe1]
+
+pm4addsu.b a0, s0, t3
+// CHECK-ASM: pm4addsu.b a0, s0, t3 # encoding: [0x3b,0x55,0xc4,0xe5]
+
+pm2addasu.h a4, t1, a2
+// CHECK-ASM: pm2addasu.h a4, t1, a2 # encoding: [0x3b,0x57,0xc3,0xe8]
+
+pm4addasu.b s2, s0, a2
+// CHECK-ASM: pm4addasu.b s2, s0, a2 # encoding: [0x3b,0x59,0xc4,0xec]
+
+mqacc.h01 a4, t1, a0
+// CHECK-ASM: mqacc.h01 a4, t1, a0 # encoding: [0x3b,0x57,0xa3,0xb8]
+
+mqracc.h01 s0, a0, t5
+// CHECK-ASM: mqracc.h01 s0, a0, t5 # encoding: [0x3b,0x54,0xe5,0xbd]
+
+pas.hx t5, s2, t5
+// CHECK-ASM: pas.hx t5, s2, t5 # encoding: [0x3b,0x6f,0xe9,0x81]
+
+psa.hx s0, t1, t3
+// CHECK-ASM: psa.hx s0, t1, t3 # encoding: [0x3b,0x64,0xc3,0x85]
+
+psas.hx t5, s2, a2
+// CHECK-ASM: psas.hx t5, s2, a2 # encoding: [0x3b,0x6f,0xc9,0x90]
+
+pssa.hx s2, t3, t5
+// CHECK-ASM: pssa.hx s2, t3, t5 # encoding: [0x3b,0x69,0xee,0x95]
+
+pmseq.h a0, t1, s0
+// CHECK-ASM: pmseq.h a0, t1, s0 # encoding: [0x3b,0x65,0x83,0xc0]
+
+pmseq.b s0, s2, s0
+// CHECK-ASM: pmseq.b s0, s2, s0 # encoding: [0x3b,0x64,0x89,0xc4]
+
+pmslt.h t3, a2, a4
+// CHECK-ASM: pmslt.h t3, a2, a4 # encoding: [0x3b,0x6e,0xe6,0xd0]
+
+pmslt.b t5, a4, t1
+// CHECK-ASM: pmslt.b t5, a4, t1 # encoding: [0x3b,0x6f,0x67,0xd4]
+
+pmsltu.h s2, s0, s2
+// CHECK-ASM: pmsltu.h s2, s0, s2 # encoding: [0x3b,0x69,0x24,0xd9]
+
+pmsltu.b s0, s2, t5
+// CHECK-ASM: pmsltu.b s0, s2, t5 # encoding: [0x3b,0x64,0xe9,0xdd]
+
+pmin.h s2, t3, s2
+// CHECK-ASM: pmin.h s2, t3, s2 # encoding: [0x3b,0x69,0x2e,0xe1]
+
+pmin.b a2, a2, t5
+// CHECK-ASM: pmin.b a2, a2, t5 # encoding: [0x3b,0x66,0xe6,0xe5]
+
+pminu.h a0, a4, a2
+// CHECK-ASM: pminu.h a0, a4, a2 # encoding: [0x3b,0x65,0xc7,0xe8]
+
+pminu.b a4, t3, s2
+// CHECK-ASM: pminu.b a4, t3, s2 # encoding: [0x3b,0x67,0x2e,0xed]
+
+pmax.h a4, s2, a0
+// CHECK-ASM: pmax.h a4, s2, a0 # encoding: [0x3b,0x67,0xa9,0xf0]
+
+pmax.b t1, s0, s0
+// CHECK-ASM: pmax.b t1, s0, s0 # encoding: [0x3b,0x63,0x84,0xf4]
+
+pmaxu.h a0, s0, s0
+// CHECK-ASM: pmaxu.h a0, s0, s0 # encoding: [0x3b,0x65,0x84,0xf8]
+
+pmaxu.b t3, a0, t1
+// CHECK-ASM: pmaxu.b t3, a0, t1 # encoding: [0x3b,0x6e,0x65,0xfc]
+
+mseq a4, t1, s0
+// CHECK-ASM: mseq a4, t1, s0 # encoding: [0x3b,0x67,0x83,0xc2]
+
+mslt t5, t5, t1
+// CHECK-ASM: mslt t5, t5, t1 # encoding: [0x3b,0x6f,0x6f,0xd2]
+
+msltu s2, a0, t3
+// CHECK-ASM: msltu s2, a0, t3 # encoding: [0x3b,0x69,0xc5,0xdb]
+
+pmulh.h s0, t3, t3
+// CHECK-ASM: pmulh.h s0, t3, t3 # encoding: [0x3b,0x74,0xce,0x81]
+
+pmulhr.h t1, t5, s0
+// CHECK-ASM: pmulhr.h t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x84]
+
+pmhacc.h s0, t5, s2
+// CHECK-ASM: pmhacc.h s0, t5, s2 # encoding: [0x3b,0x74,0x2f,0x89]
+
+pmhracc.h a4, t3, a2
+// CHECK-ASM: pmhracc.h a4, t3, a2 # encoding: [0x3b,0x77,0xce,0x8c]
+
+pmulhu.h a4, t5, a2
+// CHECK-ASM: pmulhu.h a4, t5, a2 # encoding: [0x3b,0x77,0xcf,0x90]
+
+pmulhru.h a4, a2, a4
+// CHECK-ASM: pmulhru.h a4, a2, a4 # encoding: [0x3b,0x77,0xe6,0x94]
+
+pmhaccu.h a4, t1, t3
+// CHECK-ASM: pmhaccu.h a4, t1, t3 # encoding: [0x3b,0x77,0xc3,0x99]
+
+pmhraccu.h s2, s0, t1
+// CHECK-ASM: pmhraccu.h s2, s0, t1 # encoding: [0x3b,0x79,0x64,0x9c]
+
+pmulh.h.be a0, t5, a4
+// CHECK-ASM: pmulh.h.be a0, t5, a4 # encoding: [0x3b,0x75,0xef,0xa0]
+
+pmulhsu.h.be s0, a4, s2
+// CHECK-ASM: pmulhsu.h.be s0, a4, s2 # encoding: [0x3b,0x74,0x27,0xa5]
+
+pmhaccu.h.be s0, a0, t5
+// CHECK-ASM: pmhaccu.h.be s0, a0, t5 # encoding: [0x3b,0x74,0xe5,0xa9]
+
+pmhaccsu.h.be t3, s0, a4
+// CHECK-ASM: pmhaccsu.h.be t3, s0, a4 # encoding: [0x3b,0x7e,0xe4,0xac]
+
+pmulh.h.bo a0, a4, s2
+// CHECK-ASM: pmulh.h.bo a0, a4, s2 # encoding: [0x3b,0x75,0x27,0xb1]
+
+pmulhsu.h.bo t5, t3, t1
+// CHECK-ASM: pmulhsu.h.bo t5, t3, t1 # encoding: [0x3b,0x7f,0x6e,0xb4]
+
+pmhacc.h.bo t1, t5, a2
+// CHECK-ASM: pmhacc.h.bo t1, t5, a2 # encoding: [0x3b,0x73,0xcf,0xb8]
+
+pmhaccsu.h.bo a2, a0, a4
+// CHECK-ASM: pmhaccsu.h.bo a2, a0, a4 # encoding: [0x3b,0x76,0xe5,0xbc]
+
+pmulhsu.h s0, a0, t1
+// CHECK-ASM: pmulhsu.h s0, a0, t1 # encoding: [0x3b,0x74,0x65,0xc0]
+
+pmulhrsu.h t3, t5, a4
+// CHECK-ASM: pmulhrsu.h t3, t5, a4 # encoding: [0x3b,0x7e,0xef,0xc4]
+
+pmhaccsu.h s0, s0, a4
+// CHECK-ASM: pmhaccsu.h s0, s0, a4 # encoding: [0x3b,0x74,0xe4,0xc8]
+
+pmhraccsu.h a2, a2, a0
+// CHECK-ASM: pmhraccsu.h a2, a2, a0 # encoding: [0x3b,0x76,0xa6,0xcc]
+
+pmulq.h a0, t1, t1
+// CHECK-ASM: pmulq.h a0, t1, t1 # encoding: [0x3b,0x75,0x63,0xd0]
+
+pmulqr.h s2, s0, s2
+// CHECK-ASM: pmulqr.h s2, s0, s2 # encoding: [0x3b,0x79,0x24,0xd5]
+
+mulhr a4, s2, t5
+// CHECK-ASM: mulhr a4, s2, t5 # encoding: [0x3b,0x77,0xe9,0x87]
+
+mhacc t1, s0, a2
+// CHECK-ASM: mhacc t1, s0, a2 # encoding: [0x3b,0x73,0xc4,0x8a]
+
+mhracc t1, t5, s0
+// CHECK-ASM: mhracc t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x8e]
+
+mulhru t1, t5, s0
+// CHECK-ASM: mulhru t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x96]
+
+mhaccu t3, a2, s2
+// CHECK-ASM: mhaccu t3, a2, s2 # encoding: [0x3b,0x7e,0x26,0x9b]
+
+mhraccu a0, t1, a4
+// CHECK-ASM: mhraccu a0, t1, a4 # encoding: [0x3b,0x75,0xe3,0x9e]
+
+mulh.h0 t3, a4, t1
+// CHECK-ASM: mulh.h0 t3, a4, t1 # encoding: [0x3b,0x7e,0x67,0xa2]
+
+mulhsu.h0 t1, a2, a0
+// CHECK-ASM: mulhsu.h0 t1, a2, a0 # encoding: [0x3b,0x73,0xa6,0xa6]
+
+mhacc.h0 s0, a2, t3
+// CHECK-ASM: mhacc.h0 s0, a2, t3 # encoding: [0x3b,0x74,0xc6,0xab]
+
+mhaccsu.h0 a2, t1, s0
+// CHECK-ASM: mhaccsu.h0 a2, t1, s0 # encoding: [0x3b,0x76,0x83,0xae]
+
+mulh.h1 t1, t1, t3
+// CHECK-ASM: mulh.h1 t1, t1, t3 # encoding: [0x3b,0x73,0xc3,0xb3]
+
+mulhsu.h1 t3, a2, t1
+// CHECK-ASM: mulhsu.h1 t3, a2, t1 # encoding: [0x3b,0x7e,0x66,0xb6]
+
+mhacc.h1 t3, a2, a0
+// CHECK-ASM: mhacc.h1 t3, a2, a0 # encoding: [0x3b,0x7e,0xa6,0xba]
+
+mhaccsu.h1 s0, s2, s0
+// CHECK-ASM: mhaccsu.h1 s0, s2, s0 # encoding: [0x3b,0x74,0x89,0xbe]
+
+mulhrsu.h t5, a4, t5
+// CHECK-ASM: mulhrsu.h t5, a4, t5 # encoding: [0x3b,0x7f,0xe7,0xc7]
+
+mhaccsu a0, a2, s2
+// CHECK-ASM: mhaccsu a0, a2, s2 # encoding: [0x3b,0x75,0x26,0xcb]
+
+mhraccsu a0, a0, t1
+// CHECK-ASM: mhraccsu a0, a0, t1 # encoding: [0x3b,0x75,0x65,0xce]
+
+mulq t1, a2, a2
+// CHECK-ASM: mulq t1, a2, a2 # encoding: [0x3b,0x73,0xc6,0xd2]
+
+mulqr a4, a4, t3
+// CHECK-ASM: mulqr a4, a4, t3 # encoding: [0x3b,0x77,0xc7,0xd7]
+
+mqacc.h00 a2, t3, t3
+// CHECK-ASM: mqacc.h00 a2, t3, t3 # encoding: [0x3b,0x76,0xce,0xe9]
+
+mqracc.h00 t5, a4, t3
+// CHECK-ASM: mqracc.h00 t5, a4, t3 # encoding: [0x3b,0x7f,0xc7,0xed]
+
+mqacc.h11 t5, t5, s0
+// CHECK-ASM: mqacc.h11 t5, t5, s0 # encoding: [0x3b,0x7f,0x8f,0xf8]
+
+mqracc.h11 s0, t5, s2
+// CHECK-ASM: mqracc.h11 s0, t5, s2 # encoding: [0x3b,0x74,0x2f,0xfd]
+
+pwslli.b a0, t1
+// CHECK-ASM: pwslli.b a0, t1 # encoding: [0x1b,0x4a,0x03,0x01]
+
+pwslli.h s0, a0
+// CHECK-ASM: pwslli.h s0, a0 # encoding: [0x1b,0x48,0x05,0x12]
+
+wslli s2, t3
+// CHECK-ASM: wslli s2, t3 # encoding: [0x1b,0x42,0x0e,0x24]
+
+pwslai.b t5, t5
+// CHECK-ASM: pwslai.b t5, t5 # encoding: [0x1b,0x4e,0x0f,0x41]
+
+pwslai.h t5, a4
+// CHECK-ASM: pwslai.h t5, a4 # encoding: [0x1b,0x4e,0x07,0x42]
+
+wslai t1, a2
+// CHECK-ASM: wslai t1, a2 # encoding: [0x1b,0x46,0x06,0x44]
+
+pli.dh s0, 0x7
+// CHECK-ASM: pli.dh s0, 7 # encoding: [0x1b,0xa4,0x03,0x30]
+
+pli.db a2, 0x1
+// CHECK-ASM: pli.db a2, 1 # encoding: [0x1b,0x26,0x01,0x34]
+
+plui.dh t5, 0x5
+// CHECK-ASM: plui.dh t5, 5 # encoding: [0x1b,0xaf,0x02,0x70]
+
+pwslli.b.b0 t3, t1, s0
+// CHECK-ASM: pwslli.b.b0 t3, t1, s0 # encoding: [0x1b,0x2c,0x83,0x08]
+
+pwsll.h.h0 s0, a4, t1
+// CHECK-ASM: pwsll.h.h0 s0, a4, t1 # encoding: [0x1b,0x28,0x67,0x0a]
+
+wsll a0, s0, s2
+// CHECK-ASM: wsll a0, s0, s2 # encoding: [0x1b,0x2a,0x24,0x0f]
+
+pwsla.b.b0 s0, s0, s0
+// CHECK-ASM: pwsla.b.b0 s0, s0, s0 # encoding: [0x1b,0x28,0x84,0x48]
+
+pwsla.h.h0 a4, a2, t5
+// CHECK-ASM: pwsla.h.h0 a4, a2, t5 # encoding: [0x1b,0x2e,0xe6,0x4b]
+
+wsla s0, a0, s2
+// CHECK-ASM: wsla s0, a0, s2 # encoding: [0x1b,0x28,0x25,0x4f]
+
+wzip8p t1, s2, a2
+// CHECK-ASM: wzip8p t1, s2, a2 # encoding: [0x1b,0x26,0xc9,0x78]
+
+wzip16p s2, t3, s2
+// CHECK-ASM: wzip16p s2, t3, s2 # encoding: [0x1b,0x22,0x2e,0x7b]
+
+pwadd.h a4, a2, a0
+// CHECK-ASM: pwadd.h a4, a2, a0 # encoding: [0xbb,0x2e,0xa6,0x00]
+
+wadd t1, t5, t5
+// CHECK-ASM: wadd t1, t5, t5 # encoding: [0xbb,0x26,0xef,0x03]
+
+pwadd.b s0, t3, a4
+// CHECK-ASM: pwadd.b s0, t3, a4 # encoding: [0xbb,0x28,0xee,0x04]
+
+pw2wadd.h t3, t3, a4
+// CHECK-ASM: pw2wadd.h t3, t3, a4 # encoding: [0xbb,0x2c,0xee,0x06]
+
+pwadda.h t1, t3, s2
+// CHECK-ASM: pwadda.h t1, t3, s2 # encoding: [0xbb,0x26,0x2e,0x09]
+
+wadda s2, t1, a0
+// CHECK-ASM: wadda s2, t1, a0 # encoding: [0xbb,0x22,0xa3,0x0a]
+
+pwadda.b a2, a2, s2
+// CHECK-ASM: pwadda.b a2, a2, s2 # encoding: [0xbb,0x2c,0x26,0x0d]
+
+pw2wadda.h t3, t1, t1
+// CHECK-ASM: pw2wadda.h t3, t1, t1 # encoding: [0xbb,0x2c,0x63,0x0e]
+
+pwaddu.h a2, t1, a4
+// CHECK-ASM: pwaddu.h a2, t1, a4 # encoding: [0xbb,0x2c,0xe3,0x10]
+
+waddu t1, s0, t1
+// CHECK-ASM: waddu t1, s0, t1 # encoding: [0xbb,0x26,0x64,0x12]
+
+pwaddu.b s2, a0, t3
+// CHECK-ASM: pwaddu.b s2, a0, t3 # encoding: [0xbb,0x22,0xc5,0x15]
+
+pw2wadd.hx a0, s0, t1
+// CHECK-ASM: pw2wadd.hx a0, s0, t1 # encoding: [0xbb,0x2a,0x64,0x16]
+
+pwaddau.h t1, t5, t3
+// CHECK-ASM: pwaddau.h t1, t5, t3 # encoding: [0xbb,0x26,0xcf,0x19]
+
+waddau t3, s0, s0
+// CHECK-ASM: waddau t3, s0, s0 # encoding: [0xbb,0x2c,0x84,0x1a]
+
+pwaddau.b a0, a0, t1
+// CHECK-ASM: pwaddau.b a0, a0, t1 # encoding: [0xbb,0x2a,0x65,0x1c]
+
+pw2wadda.hx a4, a2, t3
+// CHECK-ASM: pw2wadda.hx a4, a2, t3 # encoding: [0xbb,0x2e,0xc6,0x1f]
+
+pwmul.h s2, t1, a0
+// CHECK-ASM: pwmul.h s2, t1, a0 # encoding: [0xbb,0x22,0xa3,0x20]
+
+wmul t3, a2, t5
+// CHECK-ASM: wmul t3, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x23]
+
+pwmul.b a0, s0, s2
+// CHECK-ASM: pwmul.b a0, s0, s2 # encoding: [0xbb,0x2a,0x24,0x25]
+
+pw2waddu.h s2, s2, a0
+// CHECK-ASM: pw2waddu.h s2, s2, a0 # encoding: [0xbb,0x22,0xa9,0x26]
+
+pwmacc.h s0, a2, a2
+// CHECK-ASM: pwmacc.h s0, a2, a2 # encoding: [0xbb,0x28,0xc6,0x28]
+
+wmacc a0, a2, a2
+// CHECK-ASM: wmacc a0, a2, a2 # encoding: [0xbb,0x2a,0xc6,0x2a]
+
+pm2waddau.h t5, a2, t5
+// CHECK-ASM: pm2waddau.h t5, a2, t5 # encoding: [0xbb,0x2e,0xe6,0x2f]
+
+pwmulu.h a2, a0, t5
+// CHECK-ASM: pwmulu.h a2, a0, t5 # encoding: [0xbb,0x2c,0xe5,0x31]
+
+wmulu s2, a0, t3
+// CHECK-ASM: wmulu s2, a0, t3 # encoding: [0xbb,0x22,0xc5,0x33]
+
+pwmulu.b a2, a4, a2
+// CHECK-ASM: pwmulu.b a2, a4, a2 # encoding: [0xbb,0x2c,0xc7,0x34]
+
+pwmaccu.h t1, a4, a2
+// CHECK-ASM: pwmaccu.h t1, a4, a2 # encoding: [0xbb,0x26,0xc7,0x38]
+
+wmaccu a2, a0, t1
+// CHECK-ASM: wmaccu a2, a0, t1 # encoding: [0xbb,0x2c,0x65,0x3a]
+
+pwsub.h s0, s2, t3
+// CHECK-ASM: pwsub.h s0, s2, t3 # encoding: [0xbb,0x28,0xc9,0x41]
+
+wsub t1, s2, a4
+// CHECK-ASM: wsub t1, s2, a4 # encoding: [0xbb,0x26,0xe9,0x42]
+
+pwsub.b a4, s2, s2
+// CHECK-ASM: pwsub.b a4, s2, s2 # encoding: [0xbb,0x2e,0x29,0x45]
+
+pw2wsub.h t1, a4, t3
+// CHECK-ASM: pw2wsub.h t1, a4, t3 # encoding: [0xbb,0x26,0xc7,0x47]
+
+pwsuba.h a4, t5, t1
+// CHECK-ASM: pwsuba.h a4, t5, t1 # encoding: [0xbb,0x2e,0x6f,0x48]
+
+wsuba a0, s0, t5
+// CHECK-ASM: wsuba a0, s0, t5 # encoding: [0xbb,0x2a,0xe4,0x4b]
+
+pwsuba.b a0, a2, s2
+// CHECK-ASM: pwsuba.b a0, a2, s2 # encoding: [0xbb,0x2a,0x26,0x4d]
+
+pw2wsuba.h t5, s0, s2
+// CHECK-ASM: pw2wsuba.h t5, s0, s2 # encoding: [0xbb,0x2e,0x24,0x4f]
+
+pwsubu.h t5, s2, a2
+// CHECK-ASM: pwsubu.h t5, s2, a2 # encoding: [0xbb,0x2e,0xc9,0x50]
+
+wsubu a2, a4, a0
+// CHECK-ASM: wsubu a2, a4, a0 # encoding: [0xbb,0x2c,0xa7,0x52]
+
+pwsubu.b a2, a2, t5
+// CHECK-ASM: pwsubu.b a2, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x55]
+
+pw2wsub.hx t5, a2, a0
+// CHECK-ASM: pw2wsub.hx t5, a2, a0 # encoding: [0xbb,0x2e,0xa6,0x56]
+
+pwsubau.h t5, s0, s2
+// CHECK-ASM: pwsubau.h t5, s0, s2 # encoding: [0xbb,0x2e,0x24,0x59]
+
+wsubau t5, a0, t1
+// CHECK-ASM: wsubau t5, a0, t1 # encoding: [0xbb,0x2e,0x65,0x5a]
+
+pwsubau.b a2, a0, a0
+// CHECK-ASM: pwsubau.b a2, a0, a0 # encoding: [0xbb,0x2c,0xa5,0x5c]
+
+pw2wsuba.hx a2, a2, t5
+// CHECK-ASM: pw2wsuba.hx a2, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x5f]
+
+pwmulsu.h s0, a2, t3
+// CHECK-ASM: pwmulsu.h s0, a2, t3 # encoding: [0xbb,0x28,0xc6,0x61]
+
+wmulsu a0, s2, a0
+// CHECK-ASM: wmulsu a0, s2, a0 # encoding: [0xbb,0x2a,0xa9,0x62]
+
+pwmulsu.b t3, t5, t1
+// CHECK-ASM: pwmulsu.b t3, t5, t1 # encoding: [0xbb,0x2c,0x6f,0x64]
+
+pm2waddsu.h a4, a2, s2
+// CHECK-ASM: pm2waddsu.h a4, a2, s2 # encoding: [0xbb,0x2e,0x26,0x67]
+
+pwmaccsu.h t5, s2, a2
+// CHECK-ASM: pwmaccsu.h t5, s2, a2 # encoding: [0xbb,0x2e,0xc9,0x68]
+
+wmaccsu t3, s0, a4
+// CHECK-ASM: wmaccsu t3, s0, a4 # encoding: [0xbb,0x2c,0xe4,0x6a]
+
+pm2waddasu.h t3, t5, a0
+// CHECK-ASM: pm2waddasu.h t3, t5, a0 # encoding: [0xbb,0x2c,0xaf,0x6e]
+
+pmqwacc.h t5, t5, a2
+// CHECK-ASM: pmqwacc.h t5, t5, a2 # encoding: [0xbb,0x2e,0xcf,0x78]
+
+pmqwacc s2, a4, a2
+// CHECK-ASM: pmqwacc s2, a4, a2 # encoding: [0xbb,0x22,0xc7,0x7a]
+
+pmqrwacc.h a4, t3, a4
+// CHECK-ASM: pmqrwacc.h a4, t3, a4 # encoding: [0xbb,0x2e,0xee,0x7c]
+
+pmqrwacc s0, s2, t5
+// CHECK-ASM: pmqrwacc s0, s2, t5 # encoding: [0xbb,0x28,0xe9,0x7f]
+
+predsum.dh s0, t3, a0
+// CHECK-ASM: predsum.dh s0, t3, a0 # encoding: [0x1b,0x44,0xac,0x08]
+
+predsum.db a2, s0, t3
+// CHECK-ASM: predsum.db a2, s0, t3 # encoding: [0x1b,0x46,0xc8,0x0d]
+
+predsumu.dh a2, a2, t3
+// CHECK-ASM: predsumu.dh a2, a2, t3 # encoding: [0x1b,0x46,0xcc,0x39]
+
+predsumu.db a2, a0, s0
+// CHECK-ASM: predsumu.db a2, a0, s0 # encoding: [0x1b,0x46,0x8a,0x3c]
+
+pnsrli.b a2, a0
+// CHECK-ASM: pnsrli.b a2, a0 # encoding: [0x1b,0xc6,0x0a,0x01]
+
+pnsrli.h a0, t3
+// CHECK-ASM: pnsrli.h a0, t3 # encoding: [0x1b,0xc5,0x0c,0x02]
+
+nsrli a2, a0
+// CHECK-ASM: nsrli a2, a0 # encoding: [0x1b,0xc6,0x0a,0x04]
+
+pnclipiu.b a4, t3
+// CHECK-ASM: pnclipiu.b a4, t3 # encoding: [0x1b,0xc7,0x0c,0x21]
+
+pnclipiu.h t1, s2
+// CHECK-ASM: pnclipiu.h t1, s2 # encoding: [0x1b,0xc3,0x02,0x22]
+
+nclipiu s0, a2
+// CHECK-ASM: nclipiu s0, a2 # encoding: [0x1b,0xc4,0x0c,0x24]
+
+pnclipriu.b s2, s0
+// CHECK-ASM: pnclipriu.b s2, s0 # encoding: [0x1b,0xc9,0x08,0x31]
+
+pnclipriu.h s0, s0
+// CHECK-ASM: pnclipriu.h s0, s0 # encoding: [0x1b,0xc4,0x08,0x32]
+
+nclipriu t3, t3
+// CHECK-ASM: nclipriu t3, t3 # encoding: [0x1b,0xce,0x0c,0x34]
+
+pnsrai.b s2, t5
+// CHECK-ASM: pnsrai.b s2, t5 # encoding: [0x1b,0xc9,0x0e,0x41]
+
+pnsrai.h s0, a0
+// CHECK-ASM: pnsrai.h s0, a0 # encoding: [0x1b,0xc4,0x0a,0x42]
+
+nsrai a4, t3
+// CHECK-ASM: nsrai a4, t3 # encoding: [0x1b,0xc7,0x0c,0x44]
+
+pnsari.b t5, t5
+// CHECK-ASM: pnsari.b t5, t5 # encoding: [0x1b,0xcf,0x0e,0x51]
+
+pnsari.h t1, a4
+// CHECK-ASM: pnsari.h t1, a4 # encoding: [0x1b,0xc3,0x0e,0x52]
+
+nsari s0, t1
+// CHECK-ASM: nsari s0, t1 # encoding: [0x1b,0xc4,0x06,0x54]
+
+pnclipi.b t1, a4
+// CHECK-ASM: pnclipi.b t1, a4 # encoding: [0x1b,0xc3,0x0e,0x61]
+
+pnclipi.h a0, a4
+// CHECK-ASM: pnclipi.h a0, a4 # encoding: [0x1b,0xc5,0x0e,0x62]
+
+nclipi t5, t5
+// CHECK-ASM: nclipi t5, t5 # encoding: [0x1b,0xcf,0x0e,0x64]
+
+pnclipri.b a0, s0
+// CHECK-ASM: pnclipri.b a0, s0 # encoding: [0x1b,0xc5,0x08,0x71]
+
+pnclipri.h s2, t5
+// CHECK-ASM: pnclipri.h s2, t5 # encoding: [0x1b,0xc9,0x0e,0x72]
+
+nclipri t3, s0
+// CHECK-ASM: nclipri t3, s0 # encoding: [0x1b,0xce,0x08,0x74]
+
+pnsrl.b.b0 t3, s0, a4
+// CHECK-ASM: pnsrl.b.b0 t3, s0, a4 # encoding: [0x1b,0xce,0xe8,0x08]
+
+pnsrl.h.h0 a2, t1, a4
+// CHECK-ASM: pnsrl.h.h0 a2, t1, a4 # encoding: [0x1b,0xc6,0xe6,0x0a]
+
+nsrl a2, a2, a0
+// CHECK-ASM: nsrl a2, a2, a0 # encoding: [0x1b,0xc6,0xac,0x0e]
+
+pnclipu.b.b0 a4, t5, a2
+// CHECK-ASM: pnclipu.b.b0 a4, t5, a2 # encoding: [0x1b,0xc7,0xce,0x28]
+
+pnclipu.h.h0 t1, a2, a4
+// CHECK-ASM: pnclipu.h.h0 t1, a2, a4 # encoding: [0x1b,0xc3,0xec,0x2a]
+
+nclipu t5, s2, t1
+// CHECK-ASM: nclipu t5, s2, t1 # encoding: [0x1b,0xcf,0x62,0x2e]
+
+pnclipru.b.b0 t5, s2, s2
+// CHECK-ASM: pnclipru.b.b0 t5, s2, s2 # encoding: [0x1b,0xcf,0x22,0x39]
+
+pnclipru.h.h0 t5, s2, a0
+// CHECK-ASM: pnclipru.h.h0 t5, s2, a0 # encoding: [0x1b,0xcf,0xa2,0x3a]
+
+nclipru a4, t5, t5
+// CHECK-ASM: nclipru a4, t5, t5 # encoding: [0x1b,0xc7,0xee,0x3f]
+
+pnsra.b.b0 a4, t1, a4
+// CHECK-ASM: pnsra.b.b0 a4, t1, a4 # encoding: [0x1b,0xc7,0xe6,0x48]
+
+pnsra.h.h0 s0, s2, t3
+// CHECK-ASM: pnsra.h.h0 s0, s2, t3 # encoding: [0x1b,0xc4,0xc2,0x4b]
+
+nsra t1, s0, a4
+// CHECK-ASM: nsra t1, s0, a4 # encoding: [0x1b,0xc3,0xe8,0x4e]
+
+pnsrar.b.b0 a2, s0, a4
+// CHECK-ASM: pnsrar.b.b0 a2, s0, a4 # encoding: [0x1b,0xc6,0xe8,0x58]
+
+pnsrar.h.h0 s0, a4, a0
+// CHECK-ASM: pnsrar.h.h0 s0, a4, a0 # encoding: [0x1b,0xc4,0xae,0x5a]
+
+nsrar a4, a4, s0
+// CHECK-ASM: nsrar a4, a4, s0 # encoding: [0x1b,0xc7,0x8e,0x5e]
+
+pnclip.b.b0 t1, t5, t3
+// CHECK-ASM: pnclip.b.b0 t1, t5, t3 # encoding: [0x1b,0xc3,0xce,0x69]
+
+pnclip.h.h0 a0, a2, a0
+// CHECK-ASM: pnclip.h.h0 a0, a2, a0 # encoding: [0x1b,0xc5,0xac,0x6a]
+
+nclip t3, t5, t3
+// CHECK-ASM: nclip t3, t5, t3 # encoding: [0x1b,0xce,0xce,0x6f]
+
+pnclipr.b.b0 t1, a2, a0
+// CHECK-ASM: pnclipr.b.b0 t1, a2, a0 # encoding: [0x1b,0xc3,0xac,0x78]
+
+pnclipr.h.h0 a4, s2, t3
+// CHECK-ASM: pnclipr.h.h0 a4, s2, t3 # encoding: [0x1b,0xc7,0xc2,0x7b]
+
+nclipr t1, t5, a2
+// CHECK-ASM: nclipr t1, t5, a2 # encoding: [0x1b,0xc3,0xce,0x7e]
+
+pslli.db a0, s2
+// CHECK-ASM: pslli.db a0, s2 # encoding: [0x1b,0x4a,0x82,0x00]
+
+pslli.dh t3, t1
+// CHECK-ASM: pslli.dh t3, t1 # encoding: [0x1b,0x4c,0x06,0x01]
+
+pslli.dw a4, t3
+// CHECK-ASM: pslli.dw a4, t3 # encoding: [0x1b,0x4e,0x0c,0x02]
+
+psslai.dh t1, a4
+// CHECK-ASM: psslai.dh t1, a4 # encoding: [0x1b,0x46,0x0e,0x51]
+
+psslai.dw a0, t3
+// CHECK-ASM: psslai.dw a0, t3 # encoding: [0x1b,0x4a,0x0c,0x52]
+
+psextb.dh t1, t5
+// CHECK-ASM: psextb.dh t1, t5 # encoding: [0x1b,0x26,0x4e,0x60]
+
+psextb.dw t5, t5
+// CHECK-ASM: psextb.dw t5, t5 # encoding: [0x1b,0x2e,0x4e,0x62]
+
+psextw.dw s0, t1
+// CHECK-ASM: psextw.dw s0, t1 # encoding: [0x1b,0x28,0x56,0x62]
+
+psabs.dh s0, s2
+// CHECK-ASM: psabs.dh s0, s2 # encoding: [0x1b,0x28,0x72,0x60]
+
+psabs.db s2, a2
+// CHECK-ASM: psabs.db s2, a2 # encoding: [0x1b,0x22,0x7c,0x64]
+
+psll.dh.h0 s2, t3, a4
+// CHECK-ASM: psll.dh.h0 s2, t3, a4 # encoding: [0x1b,0x62,0xec,0x08]
+
+psll.dw.w a2, t1, t3
+// CHECK-ASM: psll.dw.w a2, t1, t3 # encoding: [0x1b,0x6c,0xc6,0x0b]
+
+psll.db.b0 a0, a4, a2
+// CHECK-ASM: psll.db.b0 a0, a4, a2 # encoding: [0x1b,0x6a,0xce,0x0c]
+
+padd.dh.h0 t1, a4, s2
+// CHECK-ASM: padd.dh.h0 t1, a4, s2 # encoding: [0x1b,0x66,0x2e,0x19]
+
+padd.dw.w a4, a4, t3
+// CHECK-ASM: padd.dw.w a4, a4, t3 # encoding: [0x1b,0x6e,0xce,0x1b]
+
+padd.db.b0 a2, a4, t3
+// CHECK-ASM: padd.db.b0 a2, a4, t3 # encoding: [0x1b,0x6c,0xce,0x1d]
+
+pssha.dh.h0 a0, s0, s2
+// CHECK-ASM: pssha.dh.h0 a0, s0, s2 # encoding: [0x1b,0x6a,0x28,0x69]
+
+pssha.dw.w a0, t1, s2
+// CHECK-ASM: pssha.dw.w a0, t1, s2 # encoding: [0x1b,0x6a,0x26,0x6b]
+
+psshar.dh.h0 a2, a4, t3
+// CHECK-ASM: psshar.dh.h0 a2, a4, t3 # encoding: [0x1b,0x6c,0xce,0x79]
+
+psshar.dw.w s0, t3, s0
+// CHECK-ASM: psshar.dw.w s0, t3, s0 # encoding: [0x1b,0x68,0x8c,0x7a]
+
+psrli.db t5, a2
+// CHECK-ASM: psrli.db t5, a2 # encoding: [0x1b,0xce,0x8c,0x00]
+
+psrli.dh a2, t3
+// CHECK-ASM: psrli.dh a2, t3 # encoding: [0x1b,0xcc,0x0c,0x01]
+
+psrli.dw s2, t1
+// CHECK-ASM: psrli.dw s2, t1 # encoding: [0x1b,0xc2,0x06,0x02]
+
+pusati.dh a0, a4
+// CHECK-ASM: pusati.dh a0, a4 # encoding: [0x1b,0xca,0x0e,0x21]
+
+pusati.dw a0, s2
+// CHECK-ASM: pusati.dw a0, s2 # encoding: [0x1b,0xca,0x02,0x22]
+
+psrai.db t5, t5
+// CHECK-ASM: psrai.db t5, t5 # encoding: [0x1b,0xce,0x8e,0x40]
+
+psrai.dh s0, a2
+// CHECK-ASM: psrai.dh s0, a2 # encoding: [0x1b,0xc8,0x0c,0x41]
+
+psrai.dw t5, a0
+// CHECK-ASM: psrai.dw t5, a0 # encoding: [0x1b,0xce,0x0a,0x42]
+
+psrari.dh a2, a2
+// CHECK-ASM: psrari.dh a2, a2 # encoding: [0x1b,0xcc,0x0c,0x51]
+
+psrari.dw a4, a0
+// CHECK-ASM: psrari.dw a4, a0 # encoding: [0x1b,0xce,0x0a,0x52]
+
+psati.dh s2, s2
+// CHECK-ASM: psati.dh s2, s2 # encoding: [0x1b,0xc2,0x02,0x61]
+
+psati.dw t5, t3
+// CHECK-ASM: psati.dw t5, t3 # encoding: [0x1b,0xce,0x0c,0x62]
+
+psrl.dh.h0 a0, t1, t5
+// CHECK-ASM: psrl.dh.h0 a0, t1, t5 # encoding: [0x1b,0xea,0xe6,0x09]
+
+psrl.dw.w s0, s2, t1
+// CHECK-ASM: psrl.dw.w s0, s2, t1 # encoding: [0x1b,0xe8,0x62,0x0a]
+
+psrl.db.b0 a0, s0, t5
+// CHECK-ASM: psrl.db.b0 a0, s0, t5 # encoding: [0x1b,0xea,0xe8,0x0d]
+
+psra.dh.h0 a4, t3, t1
+// CHECK-ASM: psra.dh.h0 a4, t3, t1 # encoding: [0x1b,0xee,0x6c,0x48]
+
+psra.dw.w a2, s2, t1
+// CHECK-ASM: psra.dw.w a2, s2, t1 # encoding: [0x1b,0xec,0x62,0x4a]
+
+psra.db.b0 s0, t1, t5
+// CHECK-ASM: psra.db.b0 s0, t1, t5 # encoding: [0x1b,0xe8,0xe6,0x4d]
+
+padd.dh s2, a4, a2
+// CHECK-ASM: padd.dh s2, a4, a2 # encoding: [0x1b,0x62,0x8e,0x81]
+
+padd.dw a2, s2, a2
+// CHECK-ASM: padd.dw a2, s2, a2 # encoding: [0x1b,0x6c,0x82,0x83]
+
+padd.db a4, a2, a2
+// CHECK-ASM: padd.db a4, a2, a2 # encoding: [0x1b,0x6e,0x8c,0x85]
+
+addd t1, s2, s0
+// CHECK-ASM: addd t1, s2, s0 # encoding: [0x1b,0x66,0x02,0x87]
+
+psadd.dh t3, s2, t3
+// CHECK-ASM: psadd.dh t3, s2, t3 # encoding: [0x1b,0x6c,0x82,0x91]
+
+psadd.dw a4, t3, t3
+// CHECK-ASM: psadd.dw a4, t3, t3 # encoding: [0x1b,0x6e,0x8c,0x93]
+
+psadd.db t5, s0, a2
+// CHECK-ASM: psadd.db t5, s0, a2 # encoding: [0x1b,0x6e,0x88,0x95]
+
+paadd.dh t1, s2, a0
+// CHECK-ASM: paadd.dh t1, s2, a0 # encoding: [0x1b,0x66,0x42,0x99]
+
+paadd.dw a4, a2, s0
+// CHECK-ASM: paadd.dw a4, a2, s0 # encoding: [0x1b,0x6e,0x0c,0x9b]
+
+paadd.db t5, t3, s0
+// CHECK-ASM: paadd.db t5, t3, s0 # encoding: [0x1b,0x6e,0x0c,0x9d]
+
+psaddu.dh a4, a2, t5
+// CHECK-ASM: psaddu.dh a4, a2, t5 # encoding: [0x1b,0x6e,0xcc,0xb1]
+
+psaddu.dw a4, t5, s2
+// CHECK-ASM: psaddu.dw a4, t5, s2 # encoding: [0x1b,0x6e,0x4e,0xb2]
+
+psaddu.db a4, a0, t1
+// CHECK-ASM: psaddu.db a4, a0, t1 # encoding: [0x1b,0x6e,0xca,0xb4]
+
+paaddu.dh a4, a4, s2
+// CHECK-ASM: paaddu.dh a4, a4, s2 # encoding: [0x1b,0x6e,0x4e,0xb8]
+
+paaddu.dw t3, s0, t5
+// CHECK-ASM: paaddu.dw t3, s0, t5 # encoding: [0x1b,0x6c,0xc8,0xbb]
+
+paaddu.db a0, s0, s0
+// CHECK-ASM: paaddu.db a0, s0, s0 # encoding: [0x1b,0x6a,0x08,0xbd]
+
+psub.dh t5, a4, a4
+// CHECK-ASM: psub.dh t5, a4, a4 # encoding: [0x1b,0x6e,0xce,0xc1]
+
+psub.dw t1, s0, t5
+// CHECK-ASM: psub.dw t1, s0, t5 # encoding: [0x1b,0x66,0xc8,0xc3]
+
+psub.db a4, a0, t5
+// CHECK-ASM: psub.db a4, a0, t5 # encoding: [0x1b,0x6e,0xca,0xc5]
+
+subd a2, a4, t1
+// CHECK-ASM: subd a2, a4, t1 # encoding: [0x1b,0x6c,0xce,0xc6]
+
+pdif.dh t5, t1, t3
+// CHECK-ASM: pdif.dh t5, t1, t3 # encoding: [0x1b,0x6e,0x86,0xc9]
+
+pdif.db t1, t5, a0
+// CHECK-ASM: pdif.db t1, t5, a0 # encoding: [0x1b,0x66,0x4e,0xcd]
+
+pssub.dh s0, s2, s2
+// CHECK-ASM: pssub.dh s0, s2, s2 # encoding: [0x1b,0x68,0x42,0xd0]
+
+pssub.dw t3, a2, t3
+// CHECK-ASM: pssub.dw t3, a2, t3 # encoding: [0x1b,0x6c,0x8c,0xd3]
+
+pssub.db a0, s0, s2
+// CHECK-ASM: pssub.db a0, s0, s2 # encoding: [0x1b,0x6a,0x48,0xd4]
+
+pasub.dh t1, a4, s0
+// CHECK-ASM: pasub.dh t1, a4, s0 # encoding: [0x1b,0x66,0x0e,0xd9]
+
+pasub.dw t1, s2, s2
+// CHECK-ASM: pasub.dw t1, s2, s2 # encoding: [0x1b,0x66,0x42,0xda]
+
+pasub.db a0, a0, a0
+// CHECK-ASM: pasub.db a0, a0, a0 # encoding: [0x1b,0x6a,0x4a,0xdd]
+
+pdifu.dh t5, a4, a4
+// CHECK-ASM: pdifu.dh t5, a4, a4 # encoding: [0x1b,0x6e,0xce,0xe9]
+
+pdifu.db t1, t1, a4
+// CHECK-ASM: pdifu.db t1, t1, a4 # encoding: [0x1b,0x66,0xc6,0xed]
+
+pssubu.dh t5, t1, t5
+// CHECK-ASM: pssubu.dh t5, t1, t5 # encoding: [0x1b,0x6e,0xc6,0xf1]
+
+pssubu.dw a4, a4, t1
+// CHECK-ASM: pssubu.dw a4, a4, t1 # encoding: [0x1b,0x6e,0xce,0xf2]
+
+pssubu.db s0, t5, a2
+// CHECK-ASM: pssubu.db s0, t5, a2 # encoding: [0x1b,0x68,0x8e,0xf5]
+
+pasubu.dh t5, a2, a2
+// CHECK-ASM: pasubu.dh t5, a2, a2 # encoding: [0x1b,0x6e,0x8c,0xf9]
+
+pasubu.dw a0, a2, a4
+// CHECK-ASM: pasubu.dw a0, a2, a4 # encoding: [0x1b,0x6a,0xcc,0xfb]
+
+pasubu.db a0, s0, s0
+// CHECK-ASM: pasubu.db a0, s0, s0 # encoding: [0x1b,0x6a,0x08,0xfd]
+
+psh1add.dh t5, a4, t5
+// CHECK-ASM: psh1add.dh t5, a4, t5 # encoding: [0x1b,0x6e,0xde,0xa1]
+
+psh1add.dw a4, t5, s0
+// CHECK-ASM: psh1add.dw a4, t5, s0 # encoding: [0x1b,0x6e,0x1e,0xa3]
+
+pssh1sadd.dh t3, a4, a0
+// CHECK-ASM: pssh1sadd.dh t3, a4, a0 # encoding: [0x1b,0x6c,0x5e,0xb1]
+
+pssh1sadd.dw t1, t1, a2
+// CHECK-ASM: pssh1sadd.dw t1, t1, a2 # encoding: [0x1b,0x66,0x96,0xb3]
+
+ppack.dh a2, t1, s2
+// CHECK-ASM: ppack.dh a2, t1, s2 # encoding: [0x1b,0xec,0x46,0x80]
+
+ppack.dw t5, t3, a4
+// CHECK-ASM: ppack.dw t5, t3, a4 # encoding: [0x1b,0xee,0xcc,0x83]
+
+ppackbt.dh t1, t3, t1
+// CHECK-ASM: ppackbt.dh t1, t3, t1 # encoding: [0x1b,0xe6,0xcc,0x90]
+
+ppackbt.dw a4, t5, a2
+// CHECK-ASM: ppackbt.dw a4, t5, a2 # encoding: [0x1b,0xee,0x8e,0x93]
+
+ppacktb.dh a4, t1, a2
+// CHECK-ASM: ppacktb.dh a4, t1, a2 # encoding: [0x1b,0xee,0x86,0xa1]
+
+ppacktb.dw a2, t5, s0
+// CHECK-ASM: ppacktb.dw a2, t5, s0 # encoding: [0x1b,0xec,0x0e,0xa3]
+
+ppackt.dh a0, a0, s0
+// CHECK-ASM: ppackt.dh a0, a0, s0 # encoding: [0x1b,0xea,0x0a,0xb1]
+
+ppackt.dw a4, a4, a2
+// CHECK-ASM: ppackt.dw a4, a4, a2 # encoding: [0x1b,0xee,0x8e,0xb3]
+
+pas.dhx t3, t3, s2
+// CHECK-ASM: pas.dhx t3, t3, s2 # encoding: [0x1b,0xec,0x5c,0x80]
+
+psa.dhx a0, s2, a2
+// CHECK-ASM: psa.dhx a0, s2, a2 # encoding: [0x1b,0xea,0x92,0x85]
+
+psas.dhx a2, a2, s0
+// CHECK-ASM: psas.dhx a2, a2, s0 # encoding: [0x1b,0xec,0x1c,0x91]
+
+pssa.dhx t3, t3, t3
+// CHECK-ASM: pssa.dhx t3, t3, t3 # encoding: [0x1b,0xec,0x9c,0x95]
+
+paax.dhx t3, t3, a4
+// CHECK-ASM: paax.dhx t3, t3, a4 # encoding: [0x1b,0xec,0xdc,0x99]
+
+pasa.dhx a0, t1, t1
+// CHECK-ASM: pasa.dhx a0, t1, t1 # encoding: [0x1b,0xea,0xd6,0x9c]
+
+pmseq.dh a4, t1, t3
+// CHECK-ASM: pmseq.dh a4, t1, t3 # encoding: [0x1b,0xee,0x96,0xc1]
+
+pmseq.dw t1, s0, a2
+// CHECK-ASM: pmseq.dw t1, s0, a2 # encoding: [0x1b,0xe6,0x98,0xc3]
+
+pmseq.db a2, a2, t5
+// CHECK-ASM: pmseq.db a2, a2, t5 # encoding: [0x1b,0xec,0xdc,0xc5]
+
+pmslt.dh s2, t5, s2
+// CHECK-ASM: pmslt.dh s2, t5, s2 # encoding: [0x1b,0xe2,0x5e,0xd0]
+
+pmslt.dw t1, t1, a2
+// CHECK-ASM: pmslt.dw t1, t1, a2 # encoding: [0x1b,0xe6,0x96,0xd3]
+
+pmslt.db t5, s0, s2
+// CHECK-ASM: pmslt.db t5, s0, s2 # encoding: [0x1b,0xee,0x58,0xd4]
+
+pmsltu.dh s2, a0, s2
+// CHECK-ASM: pmsltu.dh s2, a0, s2 # encoding: [0x1b,0xe2,0x5a,0xd8]
+
+pmsltu.dw s0, t3, a0
+// CHECK-ASM: pmsltu.dw s0, t3, a0 # encoding: [0x1b,0xe8,0x5c,0xdb]
+
+pmsltu.db s0, t3, t3
+// CHECK-ASM: pmsltu.db s0, t3, t3 # encoding: [0x1b,0xe8,0x9c,0xdd]
+
+pmin.dh a2, s0, t3
+// CHECK-ASM: pmin.dh a2, s0, t3 # encoding: [0x1b,0xec,0x98,0xe1]
+
+pmin.db t3, s2, t3
+// CHECK-ASM: pmin.db t3, s2, t3 # encoding: [0x1b,0xec,0x92,0xe5]
+
+pminu.dh t1, t3, t5
+// CHECK-ASM: pminu.dh t1, t3, t5 # encoding: [0x1b,0xe6,0xdc,0xe9]
+
+pminu.db t1, s0, a2
+// CHECK-ASM: pminu.db t1, s0, a2 # encoding: [0x1b,0xe6,0x98,0xed]
+
+pmax.dh a0, a0, a0
+// CHECK-ASM: pmax.dh a0, a0, a0 # encoding: [0x1b,0xea,0x5a,0xf1]
+
+pmax.db a2, a2, s2
+// CHECK-ASM: pmax.db a2, a2, s2 # encoding: [0x1b,0xec,0x5c,0xf4]
+
+pmaxu.dh a4, t3, s0
+// CHECK-ASM: pmaxu.dh a4, t3, s0 # encoding: [0x1b,0xee,0x1c,0xf9]
+
+pmaxu.db a4, t5, a0
+// CHECK-ASM: pmaxu.db a4, t5, a0 # encoding: [0x1b,0xee,0x5e,0xfd]
diff --git a/llvm/test/MC/RISCV/rv64p-invalid.s b/llvm/test/MC/RISCV/rv64p-invalid.s
new file mode 100644
index 00000000000000..8ab5437ad3166d
--- /dev/null
+++ b/llvm/test/MC/RISCV/rv64p-invalid.s
@@ -0,0 +1,9 @@
+# RUN: not llvm-mc -triple=riscv64 --mattr=+experimental-p %s 2>&1 \
+# RUN: | FileCheck %s --check-prefixes=CHECK-ERROR
+
+# Imm overflow
+pli.h a0, 0x400
+# CHECK-ERROR: immediate must be an integer in the range [-512, 511]
+
+pli.w a1, -0x201
+# CHECK-ERROR: immediate must be an integer in the range [-512, 511]
diff --git a/llvm/test/MC/RISCV/rv64p-valid.s b/llvm/test/MC/RISCV/rv64p-valid.s
new file mode 100644
index 00000000000000..b4200e1cfb0134
--- /dev/null
+++ b/llvm/test/MC/RISCV/rv64p-valid.s
@@ -0,0 +1,911 @@
+// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --llvm-mc-binary ./llvm-mc --tool ./llvm-objdump --version 5
+# RUN: llvm-mc %s -triple=riscv64 -mattr=+experimental-p -riscv-no-aliases -show-encoding \
+# RUN: | FileCheck -check-prefixes=CHECK-ASM %s
+clz a0, a1
+// CHECK-ASM: clz a0, a1 # encoding: [0x13,0x95,0x05,0x60]
+
+cls a1, a2
+// CHECK-ASM: cls a1, a2 # encoding: [0x93,0x15,0x36,0x60]
+
+sext.b a2, a3
+// CHECK-ASM: sext.b a2, a3 # encoding: [0x13,0x96,0x46,0x60]
+
+sext.h t0, t1
+// CHECK-ASM: sext.h t0, t1 # encoding: [0x93,0x12,0x53,0x60]
+
+abs a4, a5
+// CHECK-ASM: abs a4, a5 # encoding: [0x13,0x97,0x77,0x60]
+
+rev16 s0, s1
+// CHECK-ASM: rev16 s0, s1 # encoding: [0x13,0xd4,0x04,0x6b]
+
+rev8 s0, s1
+// CHECK-ASM: rev8 s0, s1 # encoding: [0x13,0xd4,0x84,0x6b]
+
+rev s2, s3
+// CHECK-ASM: rev s2, s3 # encoding: [0x13,0xd9,0xf9,0x7b]
+
+clzw s0, s1
+// CHECK-ASM: clzw s0, s1 # encoding: [0x1b,0x94,0x04,0x60]
+
+clsw s2, s3
+// CHECK-ASM: clsw s2, s3 # encoding: [0x1b,0x99,0x39,0x60]
+
+absw s2, s3
+// CHECK-ASM: absw s2, s3 # encoding: [0x1b,0x99,0x79,0x60]
+
+sh1add a0, a1, a2
+// CHECK-ASM: sh1add a0, a1, a2 # encoding: [0x33,0xa5,0xc5,0x20]
+
+pack s0, s1, s2
+// CHECK-ASM: pack s0, s1, s2 # encoding: [0x33,0xc4,0x24,0x09]
+
+min t0, t1, t2
+// CHECK-ASM: min t0, t1, t2 # encoding: [0xb3,0x42,0x73,0x0a]
+
+minu x1, x2, x3
+// CHECK-ASM: minu ra, sp, gp # encoding: [0xb3,0x50,0x31,0x0a]
+
+max t3, t4, t5
+// CHECK-ASM: max t3, t4, t5 # encoding: [0x33,0xee,0xee,0x0b]
+
+maxu a4, a5, a6
+// CHECK-ASM: maxu a4, a5, a6 # encoding: [0x33,0xf7,0x07,0x0b]
+
+pslli.b a6, a7
+// CHECK-ASM: pslli.b a6, a7 # encoding: [0x1b,0xa8,0x88,0x80]
+
+pslli.h x1, x2
+// CHECK-ASM: pslli.h ra, sp # encoding: [0x9b,0x20,0x01,0x81]
+
+pslli.w x1, x2
+// CHECK-ASM: pslli.w ra, sp # encoding: [0x9b,0x20,0x01,0x82]
+
+psslai.h t0, t1
+// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0x51]
+
+psslai.w a4, a5
+// CHECK-ASM: psslai.w a4, a5 # encoding: [0x1b,0xa7,0x07,0x52]
+
+pli.h a5, 0x5
+// CHECK-ASM: pli.h a5, 5 # encoding: [0x9b,0xa7,0x02,0xb0]
+
+pli.w a5, 0x5
+// CHECK-ASM: pli.w a5, 5 # encoding: [0x9b,0xa7,0x02,0xb2]
+
+pli.b a6, 0x6
+// CHECK-ASM: pli.b a6, 6 # encoding: [0x1b,0x28,0x06,0xb4]
+
+psextb.h t3, a2
+// CHECK-ASM: psextb.h t3, a2 # encoding: [0x1b,0x2e,0x46,0xe0]
+
+psextb.w a2, s0
+// CHECK-ASM: psextb.w a2, s0 # encoding: [0x1b,0x26,0x44,0xe2]
+
+psexth.w t1, t3
+// CHECK-ASM: psexth.w t1, t3 # encoding: [0x1b,0x23,0x5e,0xe2]
+
+psabs.h t1, t5
+// CHECK-ASM: psabs.h t1, t5 # encoding: [0x1b,0x23,0x7f,0xe0]
+
+psabs.b a0, s2
+// CHECK-ASM: psabs.b a0, s2 # encoding: [0x1b,0x25,0x79,0xe4]
+
+plui.h s2, 0x4
+// CHECK-ASM: plui.h s2, 4 # encoding: [0x1b,0x29,0x02,0xf0]
+
+plui.w a2, 0x1
+// CHECK-ASM: plui.w a2, 1 # encoding: [0x1b,0xa6,0x00,0xf2]
+
+psll.h.h0 s0, a2, s2
+// CHECK-ASM: psll.h.h0 s0, a2, s2 # encoding: [0x1b,0x24,0x26,0x89]
+
+psll.b.b0 a0, t3, t5
+// CHECK-ASM: psll.b.b0 a0, t3, t5 # encoding: [0x1b,0x25,0xee,0x8d]
+
+padd.h.h0 t1, a2, s0
+// CHECK-ASM: padd.h.h0 t1, a2, s0 # encoding: [0x1b,0x23,0x86,0x98]
+
+padd.b.b0 t3, t1, t3
+// CHECK-ASM: padd.b.b0 t3, t1, t3 # encoding: [0x1b,0x2e,0xc3,0x9d]
+
+pssha.h.h0 s0, t1, a2
+// CHECK-ASM: pssha.h.h0 s0, t1, a2 # encoding: [0x1b,0x24,0xc3,0xe8]
+
+psshar.h.h0 s2, t5, t3
+// CHECK-ASM: psshar.h.h0 s2, t5, t3 # encoding: [0x1b,0x29,0xcf,0xf9]
+
+psll.w.w0 s0, t1, a0
+// CHECK-ASM: psll.w.w0 s0, t1, a0 # encoding: [0x1b,0x24,0xa3,0x8a]
+
+padd.w.w0 s2, a2, a0
+// CHECK-ASM: padd.w.w0 s2, a2, a0 # encoding: [0x1b,0x29,0xa6,0x9a]
+
+pssha.w.w0 a4, a2, t1
+// CHECK-ASM: pssha.w.w0 a4, a2, t1 # encoding: [0x1b,0x27,0x66,0xea]
+
+psshar.w.w0 a2, a0, a4
+// CHECK-ASM: psshar.w.w0 a2, a0, a4 # encoding: [0x1b,0x26,0xe5,0xfa]
+
+sha a0, t5, t5
+// CHECK-ASM: sha a0, t5, t5 # encoding: [0x1b,0x25,0xef,0xef]
+
+shar t5, t5, t3
+// CHECK-ASM: shar t5, t5, t3 # encoding: [0x1b,0x2f,0xcf,0xff]
+
+psrli.b t1, a0
+// CHECK-ASM: psrli.b t1, a0 # encoding: [0x1b,0x43,0x85,0x80]
+
+psrli.h a4, s0
+// CHECK-ASM: psrli.h a4, s0 # encoding: [0x1b,0x47,0x04,0x81]
+
+pusati.h t3, s0
+// CHECK-ASM: pusati.h t3, s0 # encoding: [0x1b,0x4e,0x04,0xa1]
+
+psrai.b t1, t1
+// CHECK-ASM: psrai.b t1, t1 # encoding: [0x1b,0x43,0x83,0xc0]
+
+psrai.h a2, t5
+// CHECK-ASM: psrai.h a2, t5 # encoding: [0x1b,0x46,0x0f,0xc1]
+
+psrari.h t1, t5
+// CHECK-ASM: psrari.h t1, t5 # encoding: [0x1b,0x43,0x0f,0xd1]
+
+psati.h a2, s2
+// CHECK-ASM: psati.h a2, s2 # encoding: [0x1b,0x46,0x09,0xe1]
+
+psrli.w s2, a0
+// CHECK-ASM: psrli.w s2, a0 # encoding: [0x1b,0x49,0x05,0x82]
+
+pusati.w t3, a4
+// CHECK-ASM: pusati.w t3, a4 # encoding: [0x1b,0x4e,0x07,0xa2]
+
+usati s0, a2
+// CHECK-ASM: usati s0, a2 # encoding: [0x1b,0x44,0x06,0xa4]
+
+psrl.h.h0 a2, t3, t3
+// CHECK-ASM: psrl.h.h0 a2, t3, t3 # encoding: [0x1b,0x46,0xce,0x89]
+
+psrl.b.b0 s0, t1, s0
+// CHECK-ASM: psrl.b.b0 s0, t1, s0 # encoding: [0x1b,0x44,0x83,0x8c]
+
+predsum.h t5, a0, a2
+// CHECK-ASM: predsum.h t5, a0, a2 # encoding: [0x1b,0x4f,0xc5,0x98]
+
+predsum.b t5, a4, s2
+// CHECK-ASM: predsum.b t5, a4, s2 # encoding: [0x1b,0x4f,0x27,0x9d]
+
+predsumu.h a2, s2, a0
+// CHECK-ASM: predsumu.h a2, s2, a0 # encoding: [0x1b,0x46,0xa9,0xb8]
+
+predsumu.b s2, s0, t1
+// CHECK-ASM: predsumu.b s2, s0, t1 # encoding: [0x1b,0x49,0x64,0xbc]
+
+psra.h.h0 a0, t3, s2
+// CHECK-ASM: psra.h.h0 a0, t3, s2 # encoding: [0x1b,0x45,0x2e,0xc9]
+
+psra.b.b0 a4, t5, a4
+// CHECK-ASM: psra.b.b0 a4, t5, a4 # encoding: [0x1b,0x47,0xef,0xcc]
+
+psrl.w.w0 t3, t1, a2
+// CHECK-ASM: psrl.w.w0 t3, t1, a2 # encoding: [0x1b,0x4e,0xc3,0x8a]
+
+predsum.w s2, a2, t5
+// CHECK-ASM: predsum.w s2, a2, t5 # encoding: [0x1b,0x49,0xe6,0x9b]
+
+predsumu.w s2, a0, a2
+// CHECK-ASM: predsumu.w s2, a0, a2 # encoding: [0x1b,0x49,0xc5,0xba]
+
+psra.w.w0 t5, a0, t5
+// CHECK-ASM: psra.w.w0 t5, a0, t5 # encoding: [0x1b,0x4f,0xe5,0xcb]
+
+padd.h t1, t5, s2
+// CHECK-ASM: padd.h t1, t5, s2 # encoding: [0x3b,0x03,0x2f,0x81]
+
+padd.b t5, s0, t1
+// CHECK-ASM: padd.b t5, s0, t1 # encoding: [0x3b,0x0f,0x64,0x84]
+
+psadd.h a2, a2, s2
+// CHECK-ASM: psadd.h a2, a2, s2 # encoding: [0x3b,0x06,0x26,0x91]
+
+psadd.b t1, a0, s0
+// CHECK-ASM: psadd.b t1, a0, s0 # encoding: [0x3b,0x03,0x85,0x94]
+
+paadd.h t5, s0, t3
+// CHECK-ASM: paadd.h t5, s0, t3 # encoding: [0x3b,0x0f,0xc4,0x99]
+
+paadd.b a4, s2, a4
+// CHECK-ASM: paadd.b a4, s2, a4 # encoding: [0x3b,0x07,0xe9,0x9c]
+
+psaddu.h a0, t1, t1
+// CHECK-ASM: psaddu.h a0, t1, t1 # encoding: [0x3b,0x05,0x63,0xb0]
+
+psaddu.b t3, a2, a4
+// CHECK-ASM: psaddu.b t3, a2, a4 # encoding: [0x3b,0x0e,0xe6,0xb4]
+
+paaddu.h t3, s2, a2
+// CHECK-ASM: paaddu.h t3, s2, a2 # encoding: [0x3b,0x0e,0xc9,0xb8]
+
+paaddu.b t3, a0, t3
+// CHECK-ASM: paaddu.b t3, a0, t3 # encoding: [0x3b,0x0e,0xc5,0xbd]
+
+psub.h s0, s2, t3
+// CHECK-ASM: psub.h s0, s2, t3 # encoding: [0x3b,0x04,0xc9,0xc1]
+
+psub.b t5, t1, a4
+// CHECK-ASM: psub.b t5, t1, a4 # encoding: [0x3b,0x0f,0xe3,0xc4]
+
+pdif.h t1, a4, a2
+// CHECK-ASM: pdif.h t1, a4, a2 # encoding: [0x3b,0x03,0xc7,0xc8]
+
+pdif.b t3, t1, t5
+// CHECK-ASM: pdif.b t3, t1, t5 # encoding: [0x3b,0x0e,0xe3,0xcd]
+
+pssub.h a0, a2, t3
+// CHECK-ASM: pssub.h a0, a2, t3 # encoding: [0x3b,0x05,0xc6,0xd1]
+
+pssub.b a2, t5, a4
+// CHECK-ASM: pssub.b a2, t5, a4 # encoding: [0x3b,0x06,0xef,0xd4]
+
+pasub.h t5, t3, t3
+// CHECK-ASM: pasub.h t5, t3, t3 # encoding: [0x3b,0x0f,0xce,0xd9]
+
+pasub.b s0, t3, s2
+// CHECK-ASM: pasub.b s0, t3, s2 # encoding: [0x3b,0x04,0x2e,0xdd]
+
+pdifu.h t5, s0, a4
+// CHECK-ASM: pdifu.h t5, s0, a4 # encoding: [0x3b,0x0f,0xe4,0xe8]
+
+pdifu.b t3, a0, t5
+// CHECK-ASM: pdifu.b t3, a0, t5 # encoding: [0x3b,0x0e,0xe5,0xed]
+
+pssubu.h t3, s2, a0
+// CHECK-ASM: pssubu.h t3, s2, a0 # encoding: [0x3b,0x0e,0xa9,0xf0]
+
+pssubu.b t3, a4, t3
+// CHECK-ASM: pssubu.b t3, a4, t3 # encoding: [0x3b,0x0e,0xc7,0xf5]
+
+pasubu.h a2, s0, t5
+// CHECK-ASM: pasubu.h a2, s0, t5 # encoding: [0x3b,0x06,0xe4,0xf9]
+
+pasubu.b s0, t5, a4
+// CHECK-ASM: pasubu.b s0, t5, a4 # encoding: [0x3b,0x04,0xef,0xfc]
+
+padd.w t3, s0, a0
+// CHECK-ASM: padd.w t3, s0, a0 # encoding: [0x3b,0x0e,0xa4,0x82]
+
+psadd.w t3, t1, s2
+// CHECK-ASM: psadd.w t3, t1, s2 # encoding: [0x3b,0x0e,0x23,0x93]
+
+paadd.w t5, t1, a4
+// CHECK-ASM: paadd.w t5, t1, a4 # encoding: [0x3b,0x0f,0xe3,0x9a]
+
+psaddu.w s0, s2, t5
+// CHECK-ASM: psaddu.w s0, s2, t5 # encoding: [0x3b,0x04,0xe9,0xb3]
+
+paaddu.w s0, t1, s0
+// CHECK-ASM: paaddu.w s0, t1, s0 # encoding: [0x3b,0x04,0x83,0xba]
+
+psub.w t3, a0, s0
+// CHECK-ASM: psub.w t3, a0, s0 # encoding: [0x3b,0x0e,0x85,0xc2]
+
+pssub.w t3, a4, t1
+// CHECK-ASM: pssub.w t3, a4, t1 # encoding: [0x3b,0x0e,0x67,0xd2]
+
+pasub.w t3, a2, a4
+// CHECK-ASM: pasub.w t3, a2, a4 # encoding: [0x3b,0x0e,0xe6,0xda]
+
+pssubu.w a0, a4, t3
+// CHECK-ASM: pssubu.w a0, a4, t3 # encoding: [0x3b,0x05,0xc7,0xf3]
+
+pasubu.w a0, t3, a4
+// CHECK-ASM: pasubu.w a0, t3, a4 # encoding: [0x3b,0x05,0xee,0xfa]
+
+slx a0, a2, s2
+// CHECK-ASM: slx a0, a2, s2 # encoding: [0x3b,0x15,0x26,0x8f]
+
+pmul.h.beo a2, a4, a2
+// CHECK-ASM: pmul.h.beo a2, a4, a2 # encoding: [0x3b,0x16,0xc7,0x90]
+
+mvm s0, t1, a2
+// CHECK-ASM: mvm s0, t1, a2 # encoding: [0x3b,0x14,0xc3,0xa8]
+
+mvmn a2, a4, a0
+// CHECK-ASM: mvmn a2, a4, a0 # encoding: [0x3b,0x16,0xa7,0xaa]
+
+merge a4, a2, a2
+// CHECK-ASM: merge a4, a2, a2 # encoding: [0x3b,0x17,0xc6,0xac]
+
+srx t1, t3, a4
+// CHECK-ASM: srx t1, t3, a4 # encoding: [0x3b,0x13,0xee,0xae]
+
+pmulu.h.beo s2, a4, a0
+// CHECK-ASM: pmulu.h.beo s2, a4, a0 # encoding: [0x3b,0x19,0xa7,0xb0]
+
+pdifsumu.b t3, t5, t3
+// CHECK-ASM: pdifsumu.b t3, t5, t3 # encoding: [0x3b,0x1e,0xcf,0xb5]
+
+pdifsumau.b s2, a2, a0
+// CHECK-ASM: pdifsumau.b s2, a2, a0 # encoding: [0x3b,0x19,0xa6,0xbc]
+
+pmul.w.heo s2, t5, t3
+// CHECK-ASM: pmul.w.heo s2, t5, t3 # encoding: [0x3b,0x19,0xcf,0x93]
+
+mul.w01 t5, a4, t1
+// CHECK-ASM: mul.w01 t5, a4, t1 # encoding: [0x3b,0x1f,0x67,0x96]
+
+pmacc.w.heo t1, t1, a0
+// CHECK-ASM: pmacc.w.heo t1, t1, a0 # encoding: [0x3b,0x13,0xa3,0x9a]
+
+macc.w01 s2, a0, t3
+// CHECK-ASM: macc.w01 s2, a0, t3 # encoding: [0x3b,0x19,0xc5,0x9f]
+
+pmulu.w.heo t1, a4, a2
+// CHECK-ASM: pmulu.w.heo t1, a4, a2 # encoding: [0x3b,0x13,0xc7,0xb2]
+
+mulu.w01 t5, t1, t5
+// CHECK-ASM: mulu.w01 t5, t1, t5 # encoding: [0x3b,0x1f,0xe3,0xb7]
+
+pmaccu.w.heo t5, t5, a4
+// CHECK-ASM: pmaccu.w.heo t5, t5, a4 # encoding: [0x3b,0x1f,0xef,0xba]
+
+maccu.w01 a0, a0, t1
+// CHECK-ASM: maccu.w01 a0, a0, t1 # encoding: [0x3b,0x15,0x65,0xbe]
+
+psh1add.h a2, a2, t3
+// CHECK-ASM: psh1add.h a2, a2, t3 # encoding: [0x3b,0x26,0xc6,0xa1]
+
+pssh1sadd.h a2, t3, t3
+// CHECK-ASM: pssh1sadd.h a2, t3, t3 # encoding: [0x3b,0x26,0xce,0xb1]
+
+psh1add.w s2, t5, a2
+// CHECK-ASM: psh1add.w s2, t5, a2 # encoding: [0x3b,0x29,0xcf,0xa2]
+
+pssh1sadd.w a4, t3, s0
+// CHECK-ASM: pssh1sadd.w a4, t3, s0 # encoding: [0x3b,0x27,0x8e,0xb2]
+
+unzip8p a4, t3, t1
+// CHECK-ASM: unzip8p a4, t3, t1 # encoding: [0x3b,0x27,0x6e,0xe0]
+
+unzip16p t5, a4, t3
+// CHECK-ASM: unzip16p t5, a4, t3 # encoding: [0x3b,0x2f,0xc7,0xe3]
+
+unzip8hp s0, a0, t1
+// CHECK-ASM: unzip8hp s0, a0, t1 # encoding: [0x3b,0x24,0x65,0xe4]
+
+unzip16hp a0, a0, a2
+// CHECK-ASM: unzip16hp a0, a0, a2 # encoding: [0x3b,0x25,0xc5,0xe6]
+
+zip8p t5, t3, t3
+// CHECK-ASM: zip8p t5, t3, t3 # encoding: [0x3b,0x2f,0xce,0xf1]
+
+zip16p a0, t5, a0
+// CHECK-ASM: zip16p a0, t5, a0 # encoding: [0x3b,0x25,0xaf,0xf2]
+
+zip8hp t5, a0, a2
+// CHECK-ASM: zip8hp t5, a0, a2 # encoding: [0x3b,0x2f,0xc5,0xf4]
+
+zip16hp t1, t5, a4
+// CHECK-ASM: zip16hp t1, t5, a4 # encoding: [0x3b,0x23,0xef,0xf6]
+
+pmul.h.bee a4, a4, s2
+// CHECK-ASM: pmul.h.bee a4, a4, s2 # encoding: [0x3b,0x37,0x27,0x81]
+
+pmul.h.boo t1, s2, s0
+// CHECK-ASM: pmul.h.boo t1, s2, s0 # encoding: [0x3b,0x33,0x89,0x90]
+
+pmulu.h.bee a4, a2, a0
+// CHECK-ASM: pmulu.h.bee a4, a2, a0 # encoding: [0x3b,0x37,0xa6,0xa0]
+
+pmulu.h.boo a4, s0, a4
+// CHECK-ASM: pmulu.h.boo a4, s0, a4 # encoding: [0x3b,0x37,0xe4,0xb0]
+
+pmulsu.h.bee a2, s0, a4
+// CHECK-ASM: pmulsu.h.bee a2, s0, a4 # encoding: [0x3b,0x36,0xe4,0xe0]
+
+pmulsu.h.boo t3, t1, a4
+// CHECK-ASM: pmulsu.h.boo t3, t1, a4 # encoding: [0x3b,0x3e,0xe3,0xf0]
+
+pmul.w.bee s2, t1, a2
+// CHECK-ASM: pmul.w.bee s2, t1, a2 # encoding: [0x3b,0x39,0xc3,0x82]
+
+mul.w00 a4, a0, a2
+// CHECK-ASM: mul.w00 a4, a0, a2 # encoding: [0x3b,0x37,0xc5,0x86]
+
+pmacc.w.hee s2, t5, a2
+// CHECK-ASM: pmacc.w.hee s2, t5, a2 # encoding: [0x3b,0x39,0xcf,0x8a]
+
+macc.w00 t1, a0, t5
+// CHECK-ASM: macc.w00 t1, a0, t5 # encoding: [0x3b,0x33,0xe5,0x8f]
+
+pmul.w.hoo s0, a4, s0
+// CHECK-ASM: pmul.w.hoo s0, a4, s0 # encoding: [0x3b,0x34,0x87,0x92]
+
+mul.w11 a0, t3, a0
+// CHECK-ASM: mul.w11 a0, t3, a0 # encoding: [0x3b,0x35,0xae,0x96]
+
+pmacc.w.hoo a4, a4, t1
+// CHECK-ASM: pmacc.w.hoo a4, a4, t1 # encoding: [0x3b,0x37,0x67,0x9a]
+
+macc.w11 t3, s2, a2
+// CHECK-ASM: macc.w11 t3, s2, a2 # encoding: [0x3b,0x3e,0xc9,0x9e]
+
+pmulu.w.hee a2, t3, t1
+// CHECK-ASM: pmulu.w.hee a2, t3, t1 # encoding: [0x3b,0x36,0x6e,0xa2]
+
+mulu.w00 a0, t5, s2
+// CHECK-ASM: mulu.w00 a0, t5, s2 # encoding: [0x3b,0x35,0x2f,0xa7]
+
+pmaccu.w.hee t3, t3, t5
+// CHECK-ASM: pmaccu.w.hee t3, t3, t5 # encoding: [0x3b,0x3e,0xee,0xab]
+
+maccu.w00 s2, t1, s2
+// CHECK-ASM: maccu.w00 s2, t1, s2 # encoding: [0x3b,0x39,0x23,0xaf]
+
+pmulu.w.hoo s0, t5, t5
+// CHECK-ASM: pmulu.w.hoo s0, t5, t5 # encoding: [0x3b,0x34,0xef,0xb3]
+
+mulu.w11 s0, t1, a4
+// CHECK-ASM: mulu.w11 s0, t1, a4 # encoding: [0x3b,0x34,0xe3,0xb6]
+
+pmaccu.w.hoo a0, s0, t5
+// CHECK-ASM: pmaccu.w.hoo a0, s0, t5 # encoding: [0x3b,0x35,0xe4,0xbb]
+
+maccu.w11 s2, t3, t5
+// CHECK-ASM: maccu.w11 s2, t3, t5 # encoding: [0x3b,0x39,0xee,0xbf]
+
+pmulsu.w.hee t5, t5, t5
+// CHECK-ASM: pmulsu.w.hee t5, t5, t5 # encoding: [0x3b,0x3f,0xef,0xe3]
+
+mulsu.w00 t1, s0, a4
+// CHECK-ASM: mulsu.w00 t1, s0, a4 # encoding: [0x3b,0x33,0xe4,0xe6]
+
+pmaccsu.w.hee a4, a0, t1
+// CHECK-ASM: pmaccsu.w.hee a4, a0, t1 # encoding: [0x3b,0x37,0x65,0xea]
+
+maccsu.w00 a4, s2, s0
+// CHECK-ASM: maccsu.w00 a4, s2, s0 # encoding: [0x3b,0x37,0x89,0xee]
+
+pmulsu.w.hoo t1, t3, s2
+// CHECK-ASM: pmulsu.w.hoo t1, t3, s2 # encoding: [0x3b,0x33,0x2e,0xf3]
+
+mulsu.w11 a2, s2, a2
+// CHECK-ASM: mulsu.w11 a2, s2, a2 # encoding: [0x3b,0x36,0xc9,0xf6]
+
+pmaccsu.w.hoo a0, a2, t3
+// CHECK-ASM: pmaccsu.w.hoo a0, a2, t3 # encoding: [0x3b,0x35,0xc6,0xfb]
+
+maccsu.w11 t5, a4, s2
+// CHECK-ASM: maccsu.w11 t5, a4, s2 # encoding: [0x3b,0x3f,0x27,0xff]
+
+ppack.h s0, s0, s2
+// CHECK-ASM: ppack.h s0, s0, s2 # encoding: [0x3b,0x44,0x24,0x81]
+
+ppackbt.h a4, s2, t3
+// CHECK-ASM: ppackbt.h a4, s2, t3 # encoding: [0x3b,0x47,0xc9,0x91]
+
+ppacktb.h t3, s0, t3
+// CHECK-ASM: ppacktb.h t3, s0, t3 # encoding: [0x3b,0x4e,0xc4,0xa1]
+
+ppackt.h a0, t1, t5
+// CHECK-ASM: ppackt.h a0, t1, t5 # encoding: [0x3b,0x45,0xe3,0xb1]
+
+ppack.w t5, a2, a4
+// CHECK-ASM: ppack.w t5, a2, a4 # encoding: [0x3b,0x4f,0xe6,0x82]
+
+ppackbt.w t5, s0, t5
+// CHECK-ASM: ppackbt.w t5, s0, t5 # encoding: [0x3b,0x4f,0xe4,0x93]
+
+ppackbt a0, t5, a0
+// CHECK-ASM: ppackbt a0, t5, a0 # encoding: [0x3b,0x45,0xaf,0x96]
+
+ppacktb.w t5, t1, t1
+// CHECK-ASM: ppacktb.w t5, t1, t1 # encoding: [0x3b,0x4f,0x63,0xa2]
+
+ppacktb t5, a4, a4
+// CHECK-ASM: ppacktb t5, a4, a4 # encoding: [0x3b,0x4f,0xe7,0xa6]
+
+ppackt.w t3, a0, s2
+// CHECK-ASM: ppackt.w t3, a0, s2 # encoding: [0x3b,0x4e,0x25,0xb3]
+
+ppackt a2, t3, t1
+// CHECK-ASM: ppackt a2, t3, t1 # encoding: [0x3b,0x46,0x6e,0xb6]
+
+pm2add.h a4, t3, t5
+// CHECK-ASM: pm2add.h a4, t3, t5 # encoding: [0x3b,0x57,0xee,0x81]
+
+pm4add.b t1, s2, s2
+// CHECK-ASM: pm4add.b t1, s2, s2 # encoding: [0x3b,0x53,0x29,0x85]
+
+pm2adda.h a0, t5, s0
+// CHECK-ASM: pm2adda.h a0, t5, s0 # encoding: [0x3b,0x55,0x8f,0x88]
+
+pm4adda.b a0, t5, a2
+// CHECK-ASM: pm4adda.b a0, t5, a2 # encoding: [0x3b,0x55,0xcf,0x8c]
+
+pm2add.hx a0, s0, t3
+// CHECK-ASM: pm2add.hx a0, s0, t3 # encoding: [0x3b,0x55,0xc4,0x91]
+
+pm2adda.hx s0, a0, s2
+// CHECK-ASM: pm2adda.hx s0, a0, s2 # encoding: [0x3b,0x54,0x25,0x99]
+
+pm2addu.h t1, a4, a0
+// CHECK-ASM: pm2addu.h t1, a4, a0 # encoding: [0x3b,0x53,0xa7,0xa0]
+
+pm4addu.b a0, t1, t3
+// CHECK-ASM: pm4addu.b a0, t1, t3 # encoding: [0x3b,0x55,0xc3,0xa5]
+
+pm2addau.h s2, a2, a0
+// CHECK-ASM: pm2addau.h s2, a2, a0 # encoding: [0x3b,0x59,0xa6,0xa8]
+
+pm4addau.b s2, s2, t5
+// CHECK-ASM: pm4addau.b s2, s2, t5 # encoding: [0x3b,0x59,0xe9,0xad]
+
+pmq2add.h s2, s2, t3
+// CHECK-ASM: pmq2add.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0xb1]
+
+pmqr2add.h a4, a2, a0
+// CHECK-ASM: pmqr2add.h a4, a2, a0 # encoding: [0x3b,0x57,0xa6,0xb4]
+
+pmq2adda.h a2, s2, t1
+// CHECK-ASM: pmq2adda.h a2, s2, t1 # encoding: [0x3b,0x56,0x69,0xb8]
+
+pmqr2adda.h a2, a0, a0
+// CHECK-ASM: pmqr2adda.h a2, a0, a0 # encoding: [0x3b,0x56,0xa5,0xbc]
+
+pm2sub.h t5, s0, s0
+// CHECK-ASM: pm2sub.h t5, s0, s0 # encoding: [0x3b,0x5f,0x84,0xc0]
+
+pm2sadd.h a0, t5, a0
+// CHECK-ASM: pm2sadd.h a0, t5, a0 # encoding: [0x3b,0x55,0xaf,0xc4]
+
+pm2suba.h s0, a4, t5
+// CHECK-ASM: pm2suba.h s0, a4, t5 # encoding: [0x3b,0x54,0xe7,0xc9]
+
+pm2sub.hx t3, t5, a0
+// CHECK-ASM: pm2sub.hx t3, t5, a0 # encoding: [0x3b,0x5e,0xaf,0xd0]
+
+pm2sadd.hx t1, a0, t3
+// CHECK-ASM: pm2sadd.hx t1, a0, t3 # encoding: [0x3b,0x53,0xc5,0xd5]
+
+pm2suba.hx t3, a0, a4
+// CHECK-ASM: pm2suba.hx t3, a0, a4 # encoding: [0x3b,0x5e,0xe5,0xd8]
+
+pm2addsu.h t3, a0, t3
+// CHECK-ASM: pm2addsu.h t3, a0, t3 # encoding: [0x3b,0x5e,0xc5,0xe1]
+
+pm4addsu.b t1, t5, s0
+// CHECK-ASM: pm4addsu.b t1, t5, s0 # encoding: [0x3b,0x53,0x8f,0xe4]
+
+pm2addasu.h t1, t3, t3
+// CHECK-ASM: pm2addasu.h t1, t3, t3 # encoding: [0x3b,0x53,0xce,0xe9]
+
+pm4addasu.b t3, a0, a0
+// CHECK-ASM: pm4addasu.b t3, a0, a0 # encoding: [0x3b,0x5e,0xa5,0xec]
+
+pm2add.w t3, s0, t5
+// CHECK-ASM: pm2add.w t3, s0, t5 # encoding: [0x3b,0x5e,0xe4,0x83]
+
+pm4add.h s2, s2, t3
+// CHECK-ASM: pm4add.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0x87]
+
+pm2adda.w a2, a0, s0
+// CHECK-ASM: pm2adda.w a2, a0, s0 # encoding: [0x3b,0x56,0x85,0x8a]
+
+pm4adda.h s2, s0, t1
+// CHECK-ASM: pm4adda.h s2, s0, t1 # encoding: [0x3b,0x59,0x64,0x8e]
+
+pm2add.wx t1, s0, a4
+// CHECK-ASM: pm2add.wx t1, s0, a4 # encoding: [0x3b,0x53,0xe4,0x92]
+
+pm2adda.wx t5, t3, s0
+// CHECK-ASM: pm2adda.wx t5, t3, s0 # encoding: [0x3b,0x5f,0x8e,0x9a]
+
+pm2addu.w s2, a0, s2
+// CHECK-ASM: pm2addu.w s2, a0, s2 # encoding: [0x3b,0x59,0x25,0xa3]
+
+pm4addu.h a4, a2, a2
+// CHECK-ASM: pm4addu.h a4, a2, a2 # encoding: [0x3b,0x57,0xc6,0xa6]
+
+pm2addau.w s0, s0, a4
+// CHECK-ASM: pm2addau.w s0, s0, a4 # encoding: [0x3b,0x54,0xe4,0xaa]
+
+pm4addau.h a2, a4, t5
+// CHECK-ASM: pm4addau.h a2, a4, t5 # encoding: [0x3b,0x56,0xe7,0xaf]
+
+pmq2add.w t5, t1, t1
+// CHECK-ASM: pmq2add.w t5, t1, t1 # encoding: [0x3b,0x5f,0x63,0xb2]
+
+pmqr2add.w s0, t1, a4
+// CHECK-ASM: pmqr2add.w s0, t1, a4 # encoding: [0x3b,0x54,0xe3,0xb6]
+
+pmq2adda.w a4, s0, t1
+// CHECK-ASM: pmq2adda.w a4, s0, t1 # encoding: [0x3b,0x57,0x64,0xba]
+
+pmqr2adda.w a4, t5, s0
+// CHECK-ASM: pmqr2adda.w a4, t5, s0 # encoding: [0x3b,0x57,0x8f,0xbe]
+
+pm2sub.w t3, a2, t1
+// CHECK-ASM: pm2sub.w t3, a2, t1 # encoding: [0x3b,0x5e,0x66,0xc2]
+
+pm2suba.w t5, t5, t3
+// CHECK-ASM: pm2suba.w t5, t5, t3 # encoding: [0x3b,0x5f,0xcf,0xcb]
+
+pm2sub.wx t5, s2, s0
+// CHECK-ASM: pm2sub.wx t5, s2, s0 # encoding: [0x3b,0x5f,0x89,0xd2]
+
+pm2suba.wx a2, a0, a4
+// CHECK-ASM: pm2suba.wx a2, a0, a4 # encoding: [0x3b,0x56,0xe5,0xda]
+
+pm2addsu.w s0, s0, s2
+// CHECK-ASM: pm2addsu.w s0, s0, s2 # encoding: [0x3b,0x54,0x24,0xe3]
+
+pm4addsu.h a2, s2, s0
+// CHECK-ASM: pm4addsu.h a2, s2, s0 # encoding: [0x3b,0x56,0x89,0xe6]
+
+pm2addasu.w a0, a2, a0
+// CHECK-ASM: pm2addasu.w a0, a2, a0 # encoding: [0x3b,0x55,0xa6,0xea]
+
+pm4addasu.h a0, s0, t5
+// CHECK-ASM: pm4addasu.h a0, s0, t5 # encoding: [0x3b,0x55,0xe4,0xef]
+
+pmqacc.w.heo t5, t1, a4
+// CHECK-ASM: pmqacc.w.heo t5, t1, a4 # encoding: [0x3b,0x5f,0xe3,0xf8]
+
+mqacc.w01 a0, a2, t3
+// CHECK-ASM: mqacc.w01 a0, a2, t3 # encoding: [0x3b,0x55,0xc6,0xfb]
+
+pmqracc.w.heo a4, t1, s2
+// CHECK-ASM: pmqracc.w.heo a4, t1, s2 # encoding: [0x3b,0x57,0x23,0xfd]
+
+mqracc.w01 s0, t5, a4
+// CHECK-ASM: mqracc.w01 s0, t5, a4 # encoding: [0x3b,0x54,0xef,0xfe]
+
+pas.hx a0, t5, t1
+// CHECK-ASM: pas.hx a0, t5, t1 # encoding: [0x3b,0x65,0x6f,0x80]
+
+psa.hx a2, t3, a0
+// CHECK-ASM: psa.hx a2, t3, a0 # encoding: [0x3b,0x66,0xae,0x84]
+
+psas.hx s0, a0, a2
+// CHECK-ASM: psas.hx s0, a0, a2 # encoding: [0x3b,0x64,0xc5,0x90]
+
+pssa.hx a0, t1, t5
+// CHECK-ASM: pssa.hx a0, t1, t5 # encoding: [0x3b,0x65,0xe3,0x95]
+
+pmseq.h t3, s0, t1
+// CHECK-ASM: pmseq.h t3, s0, t1 # encoding: [0x3b,0x6e,0x64,0xc0]
+
+pmseq.b t5, s2, a2
+// CHECK-ASM: pmseq.b t5, s2, a2 # encoding: [0x3b,0x6f,0xc9,0xc4]
+
+pmslt.h t1, a0, a4
+// CHECK-ASM: pmslt.h t1, a0, a4 # encoding: [0x3b,0x63,0xe5,0xd0]
+
+pmslt.b s2, t3, t1
+// CHECK-ASM: pmslt.b s2, t3, t1 # encoding: [0x3b,0x69,0x6e,0xd4]
+
+pmsltu.h t1, a0, t5
+// CHECK-ASM: pmsltu.h t1, a0, t5 # encoding: [0x3b,0x63,0xe5,0xd9]
+
+pmsltu.b t3, a4, s2
+// CHECK-ASM: pmsltu.b t3, a4, s2 # encoding: [0x3b,0x6e,0x27,0xdd]
+
+pmin.h a2, a2, s2
+// CHECK-ASM: pmin.h a2, a2, s2 # encoding: [0x3b,0x66,0x26,0xe1]
+
+pmin.b t3, a2, a0
+// CHECK-ASM: pmin.b t3, a2, a0 # encoding: [0x3b,0x6e,0xa6,0xe4]
+
+pminu.h a2, s2, t1
+// CHECK-ASM: pminu.h a2, s2, t1 # encoding: [0x3b,0x66,0x69,0xe8]
+
+pminu.b a0, t1, a0
+// CHECK-ASM: pminu.b a0, t1, a0 # encoding: [0x3b,0x65,0xa3,0xec]
+
+pmax.h a0, s0, a4
+// CHECK-ASM: pmax.h a0, s0, a4 # encoding: [0x3b,0x65,0xe4,0xf0]
+
+pmax.b t1, t3, a2
+// CHECK-ASM: pmax.b t1, t3, a2 # encoding: [0x3b,0x63,0xce,0xf4]
+
+pmaxu.h t1, a0, s2
+// CHECK-ASM: pmaxu.h t1, a0, s2 # encoding: [0x3b,0x63,0x25,0xf9]
+
+pmaxu.b t1, t3, s2
+// CHECK-ASM: pmaxu.b t1, t3, s2 # encoding: [0x3b,0x63,0x2e,0xfd]
+
+pas.wx t1, a2, s0
+// CHECK-ASM: pas.wx t1, a2, s0 # encoding: [0x3b,0x63,0x86,0x82]
+
+psa.wx t3, t3, a2
+// CHECK-ASM: psa.wx t3, t3, a2 # encoding: [0x3b,0x6e,0xce,0x86]
+
+psas.wx a4, a4, s2
+// CHECK-ASM: psas.wx a4, a4, s2 # encoding: [0x3b,0x67,0x27,0x93]
+
+pssa.wx a0, a2, a0
+// CHECK-ASM: pssa.wx a0, a2, a0 # encoding: [0x3b,0x65,0xa6,0x96]
+
+paas.wx s0, a4, t1
+// CHECK-ASM: paas.wx s0, a4, t1 # encoding: [0x3b,0x64,0x67,0x9a]
+
+pasa.wx t1, s2, s2
+// CHECK-ASM: pasa.wx t1, s2, s2 # encoding: [0x3b,0x63,0x29,0x9f]
+
+pmseq.w t1, a4, s2
+// CHECK-ASM: pmseq.w t1, a4, s2 # encoding: [0x3b,0x63,0x27,0xc3]
+
+pmslt.w t5, t5, t3
+// CHECK-ASM: pmslt.w t5, t5, t3 # encoding: [0x3b,0x6f,0xcf,0xd3]
+
+pmsltu.w s2, a4, t1
+// CHECK-ASM: pmsltu.w s2, a4, t1 # encoding: [0x3b,0x69,0x67,0xda]
+
+pmin.w t5, a4, t5
+// CHECK-ASM: pmin.w t5, a4, t5 # encoding: [0x3b,0x6f,0xe7,0xe3]
+
+pminu.w a0, a2, a0
+// CHECK-ASM: pminu.w a0, a2, a0 # encoding: [0x3b,0x65,0xa6,0xea]
+
+pmax.w a0, s2, t1
+// CHECK-ASM: pmax.w a0, s2, t1 # encoding: [0x3b,0x65,0x69,0xf2]
+
+pmaxu.w a0, a4, a4
+// CHECK-ASM: pmaxu.w a0, a4, a4 # encoding: [0x3b,0x65,0xe7,0xfa]
+
+pmulh.h a0, t5, t1
+// CHECK-ASM: pmulh.h a0, t5, t1 # encoding: [0x3b,0x75,0x6f,0x80]
+
+pmulhr.h s2, t5, t3
+// CHECK-ASM: pmulhr.h s2, t5, t3 # encoding: [0x3b,0x79,0xcf,0x85]
+
+pmhacc.h t5, t3, a4
+// CHECK-ASM: pmhacc.h t5, t3, a4 # encoding: [0x3b,0x7f,0xee,0x88]
+
+pmhracc.h s2, t5, s2
+// CHECK-ASM: pmhracc.h s2, t5, s2 # encoding: [0x3b,0x79,0x2f,0x8d]
+
+pmulhu.h t3, t1, t1
+// CHECK-ASM: pmulhu.h t3, t1, t1 # encoding: [0x3b,0x7e,0x63,0x90]
+
+pmulhru.h s0, t5, t1
+// CHECK-ASM: pmulhru.h s0, t5, t1 # encoding: [0x3b,0x74,0x6f,0x94]
+
+pmhaccu.h t3, a0, t3
+// CHECK-ASM: pmhaccu.h t3, a0, t3 # encoding: [0x3b,0x7e,0xc5,0x99]
+
+pmhraccu.h t5, t3, a2
+// CHECK-ASM: pmhraccu.h t5, t3, a2 # encoding: [0x3b,0x7f,0xce,0x9c]
+
+pmulh.h.be t1, a0, a0
+// CHECK-ASM: pmulh.h.be t1, a0, a0 # encoding: [0x3b,0x73,0xa5,0xa0]
+
+pmulhsu.h.be t3, s0, a4
+// CHECK-ASM: pmulhsu.h.be t3, s0, a4 # encoding: [0x3b,0x7e,0xe4,0xa4]
+
+pmhaccu.h.be t1, a0, a4
+// CHECK-ASM: pmhaccu.h.be t1, a0, a4 # encoding: [0x3b,0x73,0xe5,0xa8]
+
+pmhaccsu.h.be s2, t5, t3
+// CHECK-ASM: pmhaccsu.h.be s2, t5, t3 # encoding: [0x3b,0x79,0xcf,0xad]
+
+pmulh.h.bo a0, s0, a2
+// CHECK-ASM: pmulh.h.bo a0, s0, a2 # encoding: [0x3b,0x75,0xc4,0xb0]
+
+pmulhsu.h.bo t1, t3, t3
+// CHECK-ASM: pmulhsu.h.bo t1, t3, t3 # encoding: [0x3b,0x73,0xce,0xb5]
+
+pmhacc.h.bo t3, t5, s2
+// CHECK-ASM: pmhacc.h.bo t3, t5, s2 # encoding: [0x3b,0x7e,0x2f,0xb9]
+
+pmhaccsu.h.bo t5, t5, t1
+// CHECK-ASM: pmhaccsu.h.bo t5, t5, t1 # encoding: [0x3b,0x7f,0x6f,0xbc]
+
+pmulhsu.h s2, t3, a4
+// CHECK-ASM: pmulhsu.h s2, t3, a4 # encoding: [0x3b,0x79,0xee,0xc0]
+
+pmulhrsu.h a0, a0, t5
+// CHECK-ASM: pmulhrsu.h a0, a0, t5 # encoding: [0x3b,0x75,0xe5,0xc5]
+
+pmhaccsu.h s0, t3, t1
+// CHECK-ASM: pmhaccsu.h s0, t3, t1 # encoding: [0x3b,0x74,0x6e,0xc8]
+
+pmhraccsu.h s0, t5, a4
+// CHECK-ASM: pmhraccsu.h s0, t5, a4 # encoding: [0x3b,0x74,0xef,0xcc]
+
+pmulq.h t3, t1, s0
+// CHECK-ASM: pmulq.h t3, t1, s0 # encoding: [0x3b,0x7e,0x83,0xd0]
+
+pmulqr.h t1, s2, s0
+// CHECK-ASM: pmulqr.h t1, s2, s0 # encoding: [0x3b,0x73,0x89,0xd4]
+
+pmulh.w t5, a4, a4
+// CHECK-ASM: pmulh.w t5, a4, a4 # encoding: [0x3b,0x7f,0xe7,0x82]
+
+pmulhr.w t1, t5, t1
+// CHECK-ASM: pmulhr.w t1, t5, t1 # encoding: [0x3b,0x73,0x6f,0x86]
+
+pmhacc.w t5, s0, t5
+// CHECK-ASM: pmhacc.w t5, s0, t5 # encoding: [0x3b,0x7f,0xe4,0x8b]
+
+pmhracc.w s0, s2, t5
+// CHECK-ASM: pmhracc.w s0, s2, t5 # encoding: [0x3b,0x74,0xe9,0x8f]
+
+pmulhu.w a2, a0, a4
+// CHECK-ASM: pmulhu.w a2, a0, a4 # encoding: [0x3b,0x76,0xe5,0x92]
+
+pmulhru.w t1, t1, a4
+// CHECK-ASM: pmulhru.w t1, t1, a4 # encoding: [0x3b,0x73,0xe3,0x96]
+
+pmhaccu.w a0, s0, a0
+// CHECK-ASM: pmhaccu.w a0, s0, a0 # encoding: [0x3b,0x75,0xa4,0x9a]
+
+pmhraccu.w s2, s0, t3
+// CHECK-ASM: pmhraccu.w s2, s0, t3 # encoding: [0x3b,0x79,0xc4,0x9f]
+
+pmulh.w.he t5, s0, t5
+// CHECK-ASM: pmulh.w.he t5, s0, t5 # encoding: [0x3b,0x7f,0xe4,0xa3]
+
+pmulhsu.w.he a2, t3, a2
+// CHECK-ASM: pmulhsu.w.he a2, t3, a2 # encoding: [0x3b,0x76,0xce,0xa6]
+
+pmhacc.w.he a2, a0, t1
+// CHECK-ASM: pmhacc.w.he a2, a0, t1 # encoding: [0x3b,0x76,0x65,0xaa]
+
+pmhaccsu.w.he t1, a4, t1
+// CHECK-ASM: pmhaccsu.w.he t1, a4, t1 # encoding: [0x3b,0x73,0x67,0xae]
+
+pmulh.w.ho t1, a0, t3
+// CHECK-ASM: pmulh.w.ho t1, a0, t3 # encoding: [0x3b,0x73,0xc5,0xb3]
+
+pmulhsu.w.ho s2, t3, a4
+// CHECK-ASM: pmulhsu.w.ho s2, t3, a4 # encoding: [0x3b,0x79,0xee,0xb6]
+
+pmhacc.w.ho s0, t5, a2
+// CHECK-ASM: pmhacc.w.ho s0, t5, a2 # encoding: [0x3b,0x74,0xcf,0xba]
+
+pmhaccsu.w.ho a0, a0, a0
+// CHECK-ASM: pmhaccsu.w.ho a0, a0, a0 # encoding: [0x3b,0x75,0xa5,0xbe]
+
+pmulhsu.w t3, a2, a4
+// CHECK-ASM: pmulhsu.w t3, a2, a4 # encoding: [0x3b,0x7e,0xe6,0xc2]
+
+pmulhrsu.w t5, a0, a0
+// CHECK-ASM: pmulhrsu.w t5, a0, a0 # encoding: [0x3b,0x7f,0xa5,0xc6]
+
+pmhaccsu.w a4, a0, a0
+// CHECK-ASM: pmhaccsu.w a4, a0, a0 # encoding: [0x3b,0x77,0xa5,0xca]
+
+pmhraccsu.w t5, t1, t3
+// CHECK-ASM: pmhraccsu.w t5, t1, t3 # encoding: [0x3b,0x7f,0xc3,0xcf]
+
+pmulq.w a2, a2, t5
+// CHECK-ASM: pmulq.w a2, a2, t5 # encoding: [0x3b,0x76,0xe6,0xd3]
+
+pmulqr.w a0, t3, t5
+// CHECK-ASM: pmulqr.w a0, t3, t5 # encoding: [0x3b,0x75,0xee,0xd7]
+
+pmqacc.w.hee t5, a4, t1
+// CHECK-ASM: pmqacc.w.hee t5, a4, t1 # encoding: [0x3b,0x7f,0x67,0xe8]
+
+mqacc.w00 t1, t1, a0
+// CHECK-ASM: mqacc.w00 t1, t1, a0 # encoding: [0x3b,0x73,0xa3,0xea]
+
+pmqracc.w.hee t1, a2, t5
+// CHECK-ASM: pmqracc.w.hee t1, a2, t5 # encoding: [0x3b,0x73,0xe6,0xed]
+
+mqracc.w00 s2, s2, a2
+// CHECK-ASM: mqracc.w00 s2, s2, a2 # encoding: [0x3b,0x79,0xc9,0xee]
+
+pmqacc.w.hoo a2, a0, a0
+// CHECK-ASM: pmqacc.w.hoo a2, a0, a0 # encoding: [0x3b,0x76,0xa5,0xf8]
+
+mqacc.w11 a4, a2, a2
+// CHECK-ASM: mqacc.w11 a4, a2, a2 # encoding: [0x3b,0x77,0xc6,0xfa]
+
+pmqracc.w.hoo s0, t1, t3
+// CHECK-ASM: pmqracc.w.hoo s0, t1, t3 # encoding: [0x3b,0x74,0xc3,0xfd]
+
+mqracc.w11 s2, t1, a4
+// CHECK-ASM: mqracc.w11 s2, t1, a4 # encoding: [0x3b,0x79,0xe3,0xfe]
More information about the llvm-commits
mailing list