From 87f3f8cf1bbd17ab54ee05acd16b4f4d74209bde Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Thu, 31 Oct 2024 01:01:06 +1100 Subject: [PATCH 01/17] [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 a1df0f7d686e6..89202a825fc64 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 `__. +``experimental-p``, ``experimental-p`` + LLVM implements the `012 specification `__. + 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 8177280044bf4..b941c2b15a0cb 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 ab04b09a7ad15..f4902099ddc3f 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 f721d7148526b..b764d76964033 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 bb5bb6352c32a..4b72fc5471531 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 0000000000000..fd32bc70a54d6 --- /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 funct5, bits<7> wuimm, + bits<3> funct3, RISCVOpcode opcode, + string opcodestr> + : RVInstIBase { + let Inst{31-27} = funct5; + let Inst{26-20} = wuimm; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm9 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 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 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 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 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 { + let Inst{31} = bfr; + let Inst{30-28} = f; + let Inst{27} = aft; + let Inst{26-20} = wuimm; +} + +class RVPUnary1F0 f, bits<7> wuimm, string opcodestr> + : RVPUnaryF<1, f, 0, wuimm, opcodestr>; + +class RVPUnary0F0Rdp 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 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 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 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 { + let Inst{31} = bfr; + let Inst{30-28} = f; + let Inst{27} = aft; + let Inst{26-25} = w; +} + +class RVPBinary1F1W f, bits<2> w, string opcodestr, bits<3> funct3, + RISCVOpcode Opcode = OPC_OP_32> + : RVPBinaryFW<1, f, 1, w, opcodestr, funct3, Opcode>; + +class RVPBinary1F0W f, bits<2> w, string opcodestr, bits<3> funct3, + RISCVOpcode Opcode = OPC_OP_32> + : RVPBinaryFW<1, f, 0, w, opcodestr, funct3, Opcode>; + +class RVPBinary0F1WRdp 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 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 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 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 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 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 { + let Inst{31} = bfr; + let Inst{30-27} = f; + let Inst{26-25} = w; +} + +class RVPBinary1LongFW f, bits<2> w, string opcodestr, bits<3> funct3> + : RVPBinaryLongFW<1, f, w, opcodestr, funct3>; + +class RVPBinary0LongFW 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 funct5, string opcodestr> { + def NAME # _B : RVPUnary; + def NAME # _H : RVPUnary; +} + +multiclass RVPUnaryHNonPacked funct5, string opcodestr> { + def P # NAME # _H : RVPUnary; + def NAME: RVPUnary; +} + +multiclass RVPUnaryBHW funct5, string opcodestr> { + defm NAME : RVPUnaryBH; + def NAME # _W: RVPUnary; +} + +multiclass RVPUnaryHW funct5, string opcodestr> { + def NAME # _H : RVPUnary; + def NAME # _W: RVPUnary; +} + +//===----------------------------------------------------------------------===// +// 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 124caa3b69d31..2ce909c5d0e21 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 a09261609d844..072ff59f0dccf 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 4e77a53bd706c..047f020047a63 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 c5c0d2f3a0b12..8e8c42e033b8a 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 ac0e3c6c1bdbf..1ffb10789bbbd 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 0000000000000..4b705a8db4854 --- /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 0000000000000..57f96048898ee --- /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 0000000000000..8ab5437ad3166 --- /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 0000000000000..b4200e1cfb013 --- /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] From 4d5931098e849120c8044005ae6f4d2ccfcb2837 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 17 Jan 2025 13:36:10 +1100 Subject: [PATCH 02/17] add comment for Base P in RISCVFeatures.td --- llvm/lib/Target/RISCV/RISCVFeatures.td | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td index b764d76964033..5314229ac5b4b 100644 --- a/llvm/lib/Target/RISCV/RISCVFeatures.td +++ b/llvm/lib/Target/RISCV/RISCVFeatures.td @@ -1016,6 +1016,7 @@ def HasStdExtSmctrOrSsctr : Predicate<"Subtarget->hasStdExtSmctrOrSsctr()">, "'Smctr' (Control Transfer Records Machine Level) or " "'Ssctr' (Control Transfer Records Supervisor Level)">; +// Packed SIMD Extensions def FeatureStdExtP : RISCVExperimentalExtension<1, 0, "'Base P' (Packed SIMD)">; From 0ec3cc19385c18f748b58af45cebb1012347d8c8 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 17 Jan 2025 14:50:15 +1100 Subject: [PATCH 03/17] update ISAInfoTest --- llvm/unittests/TargetParser/RISCVISAInfoTest.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp index 3a7ea4550d417..a8eadd8a75b48 100644 --- a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp +++ b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp @@ -1105,6 +1105,7 @@ R"(All available -march extensions for RISC-V xwchc 2.2 Experimental extensions + p 1.0 zicfilp 1.0 This is a long dummy description zicfiss 1.0 zalasr 0.1 From 6e73065e73553695c4b342f47705d83f914ee2fd Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 17 Jan 2025 15:01:45 +1100 Subject: [PATCH 04/17] change version to 0.12 --- llvm/docs/RISCVUsage.rst | 2 +- llvm/lib/Target/RISCV/RISCVFeatures.td | 2 +- llvm/test/MC/RISCV/attribute-arch.s | 4 ++-- llvm/unittests/TargetParser/RISCVISAInfoTest.cpp | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/llvm/docs/RISCVUsage.rst b/llvm/docs/RISCVUsage.rst index 89202a825fc64..17c20225cfab6 100644 --- a/llvm/docs/RISCVUsage.rst +++ b/llvm/docs/RISCVUsage.rst @@ -336,7 +336,7 @@ The primary goal of experimental support is to assist in the process of ratifica LLVM implements the `0.3 draft specification `__. ``experimental-p``, ``experimental-p`` - LLVM implements the `012 specification `__. + LLVM implements the `012 draft specification `__. 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`. diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td index 5314229ac5b4b..7d0b52f1b8bf9 100644 --- a/llvm/lib/Target/RISCV/RISCVFeatures.td +++ b/llvm/lib/Target/RISCV/RISCVFeatures.td @@ -1018,7 +1018,7 @@ def HasStdExtSmctrOrSsctr : Predicate<"Subtarget->hasStdExtSmctrOrSsctr()">, // Packed SIMD Extensions def FeatureStdExtP - : RISCVExperimentalExtension<1, 0, + : RISCVExperimentalExtension<0, 12, "'Base P' (Packed SIMD)">; def HasStdExtP : Predicate<"Subtarget->hasStdExtP()">, AssemblerPredicate<(all_of FeatureStdExtP), diff --git a/llvm/test/MC/RISCV/attribute-arch.s b/llvm/test/MC/RISCV/attribute-arch.s index 047f020047a63..641f554e01155 100644 --- a/llvm/test/MC/RISCV/attribute-arch.s +++ b/llvm/test/MC/RISCV/attribute-arch.s @@ -475,7 +475,7 @@ # CHECK: attribute 5, "rv32i2p1_sdtrig1p0" .attribute arch, "rv32i_p1p0" -# CHECK: attribute 5, "rv32i2p1_p1p0" +# CHECK: attribute 5, "rv32i2p1_p0p12" .attribute arch, "rv64i_p1p0" -# CHECK: attribute 5, "rv64i2p1_p1p0" \ No newline at end of file +# CHECK: attribute 5, "rv64i2p1_p0p12" \ No newline at end of file diff --git a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp index a8eadd8a75b48..27243baf2dc5a 100644 --- a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp +++ b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp @@ -1105,7 +1105,7 @@ R"(All available -march extensions for RISC-V xwchc 2.2 Experimental extensions - p 1.0 + p 0.12 zicfilp 1.0 This is a long dummy description zicfiss 1.0 zalasr 0.1 From a406a8dbc6a0dff567d8e16c82fa2e170f9f8e51 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Mon, 20 Jan 2025 11:15:48 +1100 Subject: [PATCH 05/17] fix tests --- clang/test/Driver/print-supported-extensions-riscv.c | 1 + llvm/test/CodeGen/RISCV/attributes.ll | 2 +- llvm/test/MC/RISCV/attribute-arch.s | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/clang/test/Driver/print-supported-extensions-riscv.c b/clang/test/Driver/print-supported-extensions-riscv.c index b28e0a07dad24..5284d0aa9052c 100644 --- a/clang/test/Driver/print-supported-extensions-riscv.c +++ b/clang/test/Driver/print-supported-extensions-riscv.c @@ -180,6 +180,7 @@ // CHECK-NEXT: xwchc 2.2 'Xwchc' (WCH/QingKe additional compressed opcodes) // CHECK-EMPTY: // CHECK-NEXT: Experimental extensions +// CHECK-NEXT: p 0.12 'P' ('Base P' (Packed SIMD)) // CHECK-NEXT: zicfilp 1.0 'Zicfilp' (Landing pad) // CHECK-NEXT: zicfiss 1.0 'Zicfiss' (Shadow stack) // CHECK-NEXT: zalasr 0.1 'Zalasr' (Load-Acquire and Store-Release Instructions) diff --git a/llvm/test/CodeGen/RISCV/attributes.ll b/llvm/test/CodeGen/RISCV/attributes.ll index 072ff59f0dccf..3d2afda9d0c71 100644 --- a/llvm/test/CodeGen/RISCV/attributes.ll +++ b/llvm/test/CodeGen/RISCV/attributes.ll @@ -615,7 +615,7 @@ ; RV64SSCTR: .attribute 5, "rv64i2p1_sscsrind1p0_ssctr1p0" ; RV64SDEXT: .attribute 5, "rv64i2p1_sdext1p0" ; RV64SDTRIG: .attribute 5, "rv64i2p1_sdtrig1p0" -; RV64P: .attribute 5, "rv64i2p1_p1p0" +; RV64P: .attribute 5, "rv64i2p1_p0p12" ; 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 641f554e01155..be040dfcd6cdf 100644 --- a/llvm/test/MC/RISCV/attribute-arch.s +++ b/llvm/test/MC/RISCV/attribute-arch.s @@ -474,8 +474,8 @@ .attribute arch, "rv32i_sdtrig1p0" # CHECK: attribute 5, "rv32i2p1_sdtrig1p0" -.attribute arch, "rv32i_p1p0" +.attribute arch, "rv32i_p0p12" # CHECK: attribute 5, "rv32i2p1_p0p12" -.attribute arch, "rv64i_p1p0" +.attribute arch, "rv64i_p0p12" # CHECK: attribute 5, "rv64i2p1_p0p12" \ No newline at end of file From a36987a3b2003b0b3237f7b7db0e775b2b4630b9 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Mon, 20 Jan 2025 12:08:25 +1100 Subject: [PATCH 06/17] fix code format, remove unneeded default arguments, fix simm10 leaf definition --- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 932 +++++++++++------------ llvm/test/CodeGen/RISCV/attributes.ll | 2 +- 2 files changed, 465 insertions(+), 469 deletions(-) diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index fd32bc70a54d6..7372d3b81085f 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -8,10 +8,10 @@ // // 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. -/// +// +// This version is still experimental as the 'P' extension hasn't been +// ratified yet. +// //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// @@ -21,9 +21,9 @@ def simm10 : RISCVSImmLeafOp<10> { let MCOperandPredicate = [{ int64_t Imm; - if (MCOp.evaluateAsConstantImm(Imm)) - return isInt<10>(Imm); - return MCOp.isBareSymbolRef(); + if (!MCOp.evaluateAsConstantImm(Imm)) + return false; + return isInt<10>(Imm); }]; } @@ -37,15 +37,14 @@ class RVPUnary funct5, bits<7> wuimm, string opcodestr> : RVInstIBase { - let Inst{31-27} = funct5; - let Inst{26-20} = wuimm; + let Inst{31-27} = funct5; + let Inst{26-20} = wuimm; } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryImm9 funct7, RISCVOpcode opcode, - string opcodestr, DAGOperand TyRd = GPR> - : RVInstIBase<0b010, opcode, (outs TyRd:$rd), (ins simm10:$simm10), - opcodestr, "$rd, $simm10"> { +class RVPUnaryImm9 funct7, string opcodestr, DAGOperand TyRd = GPR> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs TyRd:$rd), (ins simm10:$simm10), + opcodestr, "$rd, $simm10"> { bits<10> simm10; let Inst{31-25} = funct7; @@ -53,10 +52,9 @@ class RVPUnaryImm9 funct7, RISCVOpcode opcode, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryImm8 funct8, RISCVOpcode opcode, - string opcodestr, DAGOperand TyRd = GPR> - : RVInstIBase<0b010, opcode, (outs TyRd:$rd), (ins uimm8:$uimm8), - opcodestr, "$rd, $uimm8"> { +class RVPUnaryImm8 funct8, string opcodestr, DAGOperand TyRd = GPR> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs TyRd:$rd), (ins uimm8:$uimm8), + opcodestr, "$rd, $uimm8"> { bits<8> uimm8; let Inst{31-24} = funct8; let Inst{23-16} = uimm8; @@ -64,10 +62,9 @@ class RVPUnaryImm8 funct8, RISCVOpcode opcode, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryWUF w, bits<5> uf, - string opcodestr> +class RVPUnaryWUF w, bits<5> uf, string opcodestr> : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins GPR:$rs1), - opcodestr, "$rd, $rs1"> { + opcodestr, "$rd, $rs1"> { let Inst{31-27} = 0b11100; let Inst{26-25} = w; let Inst{24-20} = uf; @@ -75,8 +72,8 @@ class RVPUnaryWUF w, bits<5> uf, let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPUnaryWUFRs1pRdp w, bits<5> uf, string opcodestr> - : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPRPairRV32:$rdp), (ins GPRPairRV32:$rs1p), - opcodestr, "$rdp, $rs1p"> { + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPRPairRV32:$rdp), + (ins GPRPairRV32:$rs1p), opcodestr, "$rdp, $rs1p"> { bits<4> rs1p; bits<4> rdp; @@ -90,10 +87,8 @@ class RVPUnaryWUFRs1pRdp w, bits<5> uf, string opcodestr> } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryF 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"> +class RVPUnaryF f, bit aft, bits<7> wuimm, string opcodestr, + bits<3> funct3, dag outs, dag ins, string argstr> : RVInstIBase { let Inst{31} = bfr; let Inst{30-28} = f; @@ -102,7 +97,8 @@ class RVPUnaryF f, bit aft, bits<7> wuimm, } class RVPUnary1F0 f, bits<7> wuimm, string opcodestr> - : RVPUnaryF<1, f, 0, wuimm, opcodestr>; + : RVPUnaryF<1, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd), + (ins GPR:$rs1), "$rd, $rs1">; class RVPUnary0F0Rdp f, bits<7> wuimm, string opcodestr> : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp), @@ -115,7 +111,7 @@ class RVPUnary0F0Rdp f, bits<7> wuimm, string opcodestr> class RVPUnary0F0Rs1p f, bits<7> wuimm, string opcodestr> : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd), - (ins GPRPairRV32:$rs1p), "$rd, $rs1p"> { + (ins GPRPairRV32:$rs1p), "$rd, $rs1p"> { bits<4> rs1p; let Inst{19-16} = rs1p; @@ -125,7 +121,7 @@ class RVPUnary0F0Rs1p f, bits<7> wuimm, string opcodestr> class RVPUnary0F0Rs1pRdp f, bits<7> wuimm, string opcodestr, bit aft = 0b0> : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp), - (ins GPRPairRV32:$rs1p), "$rdp, $rs1p"> { + (ins GPRPairRV32:$rs1p), "$rdp, $rs1p"> { bits<4> rs1p; bits<4> rdp; @@ -136,10 +132,10 @@ class RVPUnary0F0Rs1pRdp f, bits<7> wuimm, string opcodestr, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPBinaryFW 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"> +class RVPBinaryFW 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 { let Inst{31} = bfr; let Inst{30-28} = f; @@ -148,7 +144,7 @@ class RVPBinaryFW f, bit aft, bits<2> w, } class RVPBinary1F1W f, bits<2> w, string opcodestr, bits<3> funct3, - RISCVOpcode Opcode = OPC_OP_32> + RISCVOpcode Opcode = OPC_OP_IMM_32> : RVPBinaryFW<1, f, 1, w, opcodestr, funct3, Opcode>; class RVPBinary1F0W f, bits<2> w, string opcodestr, bits<3> funct3, @@ -156,7 +152,7 @@ class RVPBinary1F0W f, bits<2> w, string opcodestr, bits<3> funct3, : RVPBinaryFW<1, f, 0, w, opcodestr, funct3, Opcode>; class RVPBinary0F1WRdp f, bits<2> w, string opcodestr, - RISCVOpcode Opcode = OPC_OP_IMM_32> + 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; @@ -191,7 +187,8 @@ class RVPBinary0F1WRs1pRdp f, bits<2> w, string opcodestr, let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPBinary1FWRs2pRs1pRdp 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), + : RVInstRBase<0b110, Opcode, (outs GPRPairRV32:$rdp), + (ins GPRPairRV32:$rs1p, GPRPairRV32:$rs2p), opcodestr, "$rdp, $rs1p, $rs2p"> { bits<4> rs1p; bits<4> rs2p; @@ -209,7 +206,8 @@ class RVPBinary1FWRs2pRs1pRdp f, bits<2> w, string opcodestr, } class RVPBinary1F0WRs2pRs1pRdp f, bits<2> w, string opcodestr, - bit bfr = 0b1, bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32> + 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; @@ -225,10 +223,8 @@ class RVPBinary1F0WRs2pRs1pRdp f, bits<2> w, string opcodestr, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPBinaryLongFW 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"> +class RVPBinaryLongFW f, bits<2> w, string opcodestr, + bits<3> funct3, dag outs, dag ins, string argstr> : RVInstRBase { let Inst{31} = bfr; @@ -236,8 +232,9 @@ class RVPBinaryLongFW f, bits<2> w, let Inst{26-25} = w; } -class RVPBinary1LongFW f, bits<2> w, string opcodestr, bits<3> funct3> - : RVPBinaryLongFW<1, f, w, opcodestr, funct3>; +class RVPBinary1LongFW f, bits<2> w, bits<3> funct3, string opcodestr> + : RVPBinaryLongFW<1, f, w, opcodestr, funct3, (outs GPR:$rd), + (ins GPR:$rs1, GPR:$rs2), "$rd, $rs1, $rs2">; class RVPBinary0LongFW f, bits<2> w, string opcodestr> : RVPBinaryLongFW<0, f, w, opcodestr, 0b010, (outs GPRPairRV32:$rdp), @@ -301,12 +298,11 @@ let Predicates = [HasStdExtP, IsRV64] in { } // 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] +def PLI_H : RVPUnaryImm9<0b1011000, "pli.h">; +let Predicates = [HasStdExtP, IsRV64] in +def PLI_W : RVPUnaryImm9<0b1011001, "pli.w">; let Predicates = [HasStdExtP] in -def PLI_B : RVPUnaryImm8<0b10110100, OPC_OP_IMM_32, "pli.b">; +def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { @@ -324,41 +320,41 @@ 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">; +def PLUI_H : RVPUnaryImm9<0b1111000, "plui.h">; let Predicates = [HasStdExtP, IsRV64] in -def PLUI_W : RVPUnaryImm9<0b1111001, OPC_OP_IMM_32, "plui.w">; +def PLUI_W : RVPUnaryImm9<0b1111001, "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>; +def PSLL_H_H0 : RVPBinary1F1W<0b000, 0b00, "psll.h.h0", 0b010>; +def PSLL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psll.b.b0", 0b010>; +def PADD_H_H0 : RVPBinary1F1W<0b001, 0b00, "padd.h.h0", 0b010>; +def PADD_B_B0 : RVPBinary1F1W<0b001, 0b10, "padd.b.b0", 0b010>; +def PSSHA_H_H0 : RVPBinary1F1W<0b110, 0b00, "pssha.h.h0", 0b010>; +def PSSHAR_H_H0 : RVPBinary1F1W<0b111, 0b00, "psshar.h.h0", 0b010>; } // 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>; +def SSHA : RVPBinary1F1W<0b110, 0b01, "ssha", 0b010>; +def SSHAR : RVPBinary1F1W<0b111, 0b01, "sshar", 0b010>; } // 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>; +def PSLL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psll.w.w0", 0b010>; +def PADD_W_W0 : RVPBinary1F1W<0b001, 0b01, "padd.w.w0", 0b010>; +def PSSHA_W_W0 : RVPBinary1F1W<0b110, 0b01, "pssha.w.w0", 0b010>; +def PSSHAR_W_W0 : RVPBinary1F1W<0b111, 0b01, "psshar.w.w0", 0b010>; +def SHA : RVPBinary1F1W<0b110, 0b11, "sha", 0b010>; +def SHAR : RVPBinary1F1W<0b111, 0b11, "shar", 0b010>; } // 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">; +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_", @@ -368,124 +364,124 @@ 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">; +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>; +def PSRL_H_H0 : RVPBinary1F1W<0b000, 0b00, "psrl.h.h0", 0b100>; +def PSRL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psrl.b.b0", 0b100>; +def PREDSUM_H : RVPBinary1F1W<0b001, 0b00, "predsum.h", 0b100>; +def PREDSUM_B : RVPBinary1F1W<0b001, 0b10, "predsum.b", 0b100>; +def PREDSUMU_H : RVPBinary1F1W<0b011, 0b00, "predsumu.h", 0b100>; +def PREDSUMU_B : RVPBinary1F1W<0b011, 0b10, "predsumu.b", 0b100>; +def PSRA_H_H0 : RVPBinary1F1W<0b100, 0b00, "psra.h.h0", 0b100>; +def PSRA_B_B0 : RVPBinary1F1W<0b100, 0b10, "psra.b.b0", 0b100>; } // 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>; +def PSRL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psrl.w.w0", 0b100>; +def PREDSUM_W : RVPBinary1F1W<0b001, 0b01, "predsum.w", 0b100>; +def PREDSUMU_W : RVPBinary1F1W<0b011, 0b01, "predsumu.w", 0b100>; +def PSRA_W_W0 : RVPBinary1F1W<0b100, 0b01, "psra.w.w0", 0b100>; } // 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>; +def PADD_H : RVPBinary1LongFW<0b0000, 0b00, 0b000, "padd.h">; +def PADD_B : RVPBinary1LongFW<0b0000, 0b10, 0b000, "padd.b">; +def PSADD_H : RVPBinary1LongFW<0b0010, 0b00, 0b000, "psadd.h">; +def PSADD_B : RVPBinary1LongFW<0b0010, 0b10, 0b000, "psadd.b">; +def PAADD_H : RVPBinary1LongFW<0b0011, 0b00, 0b000, "paadd.h">; +def PAADD_B : RVPBinary1LongFW<0b0011, 0b10, 0b000, "paadd.b">; + +def PSADDU_H : RVPBinary1LongFW<0b0110, 0b00, 0b000, "psaddu.h">; +def PSADDU_B : RVPBinary1LongFW<0b0110, 0b10, 0b000, "psaddu.b">; +def PAADDU_H : RVPBinary1LongFW<0b0111, 0b00, 0b000, "paaddu.h">; +def PAADDU_B : RVPBinary1LongFW<0b0111, 0b10, 0b000, "paaddu.b">; + +def PSUB_H : RVPBinary1LongFW<0b1000, 0b00, 0b000, "psub.h">; +def PSUB_B : RVPBinary1LongFW<0b1000, 0b10, 0b000, "psub.b">; +def PDIF_H : RVPBinary1LongFW<0b1001, 0b00, 0b000, "pdif.h">; +def PDIF_B : RVPBinary1LongFW<0b1001, 0b10, 0b000, "pdif.b">; +def PSSUB_H : RVPBinary1LongFW<0b1010, 0b00, 0b000, "pssub.h">; +def PSSUB_B : RVPBinary1LongFW<0b1010, 0b10, 0b000, "pssub.b">; +def PASUB_H : RVPBinary1LongFW<0b1011, 0b00, 0b000, "pasub.h">; +def PASUB_B : RVPBinary1LongFW<0b1011, 0b10, 0b000, "pasub.b">; + +def PDIFU_H : RVPBinary1LongFW<0b1101, 0b00, 0b000, "pdifu.h">; +def PDIFU_B : RVPBinary1LongFW<0b1101, 0b10, 0b000, "pdifu.b">; +def PSSUBU_H : RVPBinary1LongFW<0b1110, 0b00, 0b000, "pssubu.h">; +def PSSUBU_B : RVPBinary1LongFW<0b1110, 0b10, 0b000, "pssubu.b">; +def PASUBU_H : RVPBinary1LongFW<0b1111, 0b00, 0b000, "pasubu.h">; +def PASUBU_B : RVPBinary1LongFW<0b1111, 0b10, 0b000, "pasubu.b">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { -def SADD : RVPBinary1LongFW<0b0010, 0b01, "sadd", 0b000>; -def AADD : RVPBinary1LongFW<0b0011, 0b01, "aadd", 0b000>; +def SADD : RVPBinary1LongFW<0b0010, 0b01, 0b000, "sadd">; +def AADD : RVPBinary1LongFW<0b0011, 0b01, 0b000, "aadd">; -def SADDU : RVPBinary1LongFW<0b0110, 0b01, "saddu", 0b000>; -def AADDU : RVPBinary1LongFW<0b0111, 0b01, "aaddu", 0b000>; +def SADDU : RVPBinary1LongFW<0b0110, 0b01, 0b000, "saddu">; +def AADDU : RVPBinary1LongFW<0b0111, 0b01, 0b000, "aaddu">; -def SSUB : RVPBinary1LongFW<0b1010, 0b01, "ssub", 0b000>; -def ASUB : RVPBinary1LongFW<0b1011, 0b01, "asub", 0b000>; +def SSUB : RVPBinary1LongFW<0b1010, 0b01, 0b000, "ssub">; +def ASUB : RVPBinary1LongFW<0b1011, 0b01, 0b000, "asub">; -def SSUBU : RVPBinary1LongFW<0b1110, 0b01, "ssubu", 0b000>; -def ASUBU : RVPBinary1LongFW<0b1111, 0b01, "asubu", 0b000>; +def SSUBU : RVPBinary1LongFW<0b1110, 0b01, 0b000, "ssubu">; +def ASUBU : RVPBinary1LongFW<0b1111, 0b01, 0b000, "asubu">; } // 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 PADD_W : RVPBinary1LongFW<0b0000, 0b01, 0b000, "padd.w">; +def PSADD_W : RVPBinary1LongFW<0b0010, 0b01, 0b000, "psadd.w">; +def PAADD_W : RVPBinary1LongFW<0b0011, 0b01, 0b000, "paadd.w">; -def PSADDU_W : RVPBinary1LongFW<0b0110, 0b01, "psaddu.w", 0b000>; -def PAADDU_W : RVPBinary1LongFW<0b0111, 0b01, "paaddu.w", 0b000>; +def PSADDU_W : RVPBinary1LongFW<0b0110, 0b01, 0b000, "psaddu.w">; +def PAADDU_W : RVPBinary1LongFW<0b0111, 0b01, 0b000, "paaddu.w">; -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 PSUB_W : RVPBinary1LongFW<0b1000, 0b01, 0b000, "psub.w">; +def PSSUB_W : RVPBinary1LongFW<0b1010, 0b01, 0b000, "pssub.w">; +def PASUB_W : RVPBinary1LongFW<0b1011, 0b01, 0b000, "pasub.w">; -def PSSUBU_W : RVPBinary1LongFW<0b1110, 0b01, "pssubu.w", 0b000>; -def PASUBU_W : RVPBinary1LongFW<0b1111, 0b01, "pasubu.w", 0b000>; +def PSSUBU_W : RVPBinary1LongFW<0b1110, 0b01, 0b000, "pssubu.w">; +def PASUBU_W : RVPBinary1LongFW<0b1111, 0b01, 0b000, "pasubu.w">; } // 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>; +def SLX : RVPBinary1LongFW<0b0001, 0b11, 0b001, "slx">; +def PMUL_H_BEO : RVPBinary1LongFW<0b0010, 0b00, 0b001, "pmul.h.beo">; + +def MVM : RVPBinary1LongFW<0b0101, 0b00, 0b001, "mvm">; +def MVMN : RVPBinary1LongFW<0b0101, 0b01, 0b001, "mvmn">; +def MERGE : RVPBinary1LongFW<0b0101, 0b10, 0b001, "merge">; +def SRX : RVPBinary1LongFW<0b0101, 0b11, 0b001, "srx">; +def PMULU_H_BEO : RVPBinary1LongFW<0b0110, 0b00, 0b001, "pmulu.h.beo">; +def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, 0b001, "pdifsumu.b">; +def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, 0b001, "pdifsumau.b">; } // 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 MUL_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "mul.h01">; +def MACC_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "macc.h01">; -def MULU_H01 : RVPBinary1LongFW<0b0110, 0b01, "mulu.h01", 0b001>; -def MACCU_H01 : RVPBinary1LongFW<0b0111, 0b01, "maccu.h01", 0b001>; +def MULU_H01 : RVPBinary1LongFW<0b0110, 0b01, 0b001, "mulu.h01">; +def MACCU_H01 : RVPBinary1LongFW<0b0111, 0b01, 0b001, "maccu.h01">; } // 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>; +def PMUL_W_HEO : RVPBinary1LongFW<0b0010, 0b01, 0b001, "pmul.w.heo">; +def MUL_W01 : RVPBinary1LongFW<0b0010, 0b11, 0b001, "mul.w01">; +def PMACC_W_HEO : RVPBinary1LongFW<0b0011, 0b01, 0b001, "pmacc.w.heo">; +def MACC_W01 : RVPBinary1LongFW<0b0011, 0b11, 0b001, "macc.w01">; + +def PMULU_W_HEO : RVPBinary1LongFW<0b0110, 0b01, 0b001, "pmulu.w.heo">; +def MULU_W01 : RVPBinary1LongFW<0b0110, 0b11, 0b001, "mulu.w01">; +def PMACCU_W_HEO : RVPBinary1LongFW<0b0111, 0b01, 0b001, "pmaccu.w.heo">; +def MACCU_W01 : RVPBinary1LongFW<0b0111, 0b11, 0b001, "maccu.w01">; } // Predicates = [HasStdExtP, IsRV64] @@ -514,60 +510,60 @@ def ZIP16HP : RVPBinary1F0W<0b111, 0b11, "zip16hp", 0b010>; 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 PMUL_H_BEE : RVPBinary1LongFW<0b0000, 0b00, 0b011, "pmul.h.bee">; +def PMUL_H_BOO : RVPBinary1LongFW<0b0010, 0b00, 0b011, "pmul.h.boo">; -def PMULU_H_BEE : RVPBinary1LongFW<0b0100, 0b00, "pmulu.h.bee", 0b011>; -def PMULU_H_BOO : RVPBinary1LongFW<0b0110, 0b00, "pmulu.h.boo", 0b011>; +def PMULU_H_BEE : RVPBinary1LongFW<0b0100, 0b00, 0b011, "pmulu.h.bee">; +def PMULU_H_BOO : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.boo">; -def PMULSU_H_BEE : RVPBinary1LongFW<0b1100, 0b00, "pmulsu.h.bee", 0b011>; -def PMULSU_H_BOO : RVPBinary1LongFW<0b1110, 0b00, "pmulsu.h.boo", 0b011>; +def PMULSU_H_BEE : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.bee">; +def PMULSU_H_BOO : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.boo">; } // 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>; +def MUL_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "mul.h00">; +def MACC_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "macc.h00">; +def MUL_H11 : RVPBinary1LongFW<0b0010, 0b01, 0b011, "mul.h11">; +def MACC_H11 : RVPBinary1LongFW<0b0011, 0b01, 0b011, "macc.h11">; + +def MULU_H00 : RVPBinary1LongFW<0b0100, 0b01, 0b011, "mulu.h00">; +def MACCU_H00 : RVPBinary1LongFW<0b0101, 0b01, 0b011, "maccu.h00">; +def MULU_H11 : RVPBinary1LongFW<0b0110, 0b01, 0b011, "mulu.h11">; +def MACCU_H11 : RVPBinary1LongFW<0b0111, 0b01, 0b011, "maccu.h11">; + +def MULSU_H00 : RVPBinary1LongFW<0b1100, 0b01, 0b011, "mulsu.h00">; +def MACCSU_H00 : RVPBinary1LongFW<0b1101, 0b01, 0b011, "maccsu.h00">; +def MULSU_H11 : RVPBinary1LongFW<0b1110, 0b01, 0b011, "mulsu.h11">; +def MACCSU_H11 : RVPBinary1LongFW<0b1111, 0b01, 0b011, "maccsu.h11">; } // 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>; +def PMUL_W_BEE : RVPBinary1LongFW<0b0000, 0b01, 0b011, "pmul.w.bee">; +def MUL_W00 : RVPBinary1LongFW<0b0000, 0b11, 0b011, "mul.w00">; +def PMACC_W_HEE : RVPBinary1LongFW<0b0001, 0b01, 0b011, "pmacc.w.hee">; +def MACC_W00 : RVPBinary1LongFW<0b0001, 0b11, 0b011, "macc.w00">; +def PMUL_W_HOO : RVPBinary1LongFW<0b0010, 0b01, 0b011, "pmul.w.hoo">; +def MUL_W11 : RVPBinary1LongFW<0b0010, 0b11, 0b011, "mul.w11">; +def PMACC_W_HOO : RVPBinary1LongFW<0b0011, 0b01, 0b011, "pmacc.w.hoo">; +def MACC_W11 : RVPBinary1LongFW<0b0011, 0b11, 0b011, "macc.w11">; + +def PMULU_W_HEE : RVPBinary1LongFW<0b0100, 0b01, 0b011, "pmulu.w.hee">; +def MULU_W00 : RVPBinary1LongFW<0b0100, 0b11, 0b011, "mulu.w00">; +def PMACCU_W_HEE : RVPBinary1LongFW<0b0101, 0b01, 0b011, "pmaccu.w.hee">; +def MACCU_W00 : RVPBinary1LongFW<0b0101, 0b11, 0b011, "maccu.w00">; +def PMULU_W_HOO : RVPBinary1LongFW<0b0110, 0b01, 0b011, "pmulu.w.hoo">; +def MULU_W11 : RVPBinary1LongFW<0b0110, 0b11, 0b011, "mulu.w11">; +def PMACCU_W_HOO : RVPBinary1LongFW<0b0111, 0b01, 0b011, "pmaccu.w.hoo">; +def MACCU_W11 : RVPBinary1LongFW<0b0111, 0b11, 0b011, "maccu.w11">; + +def PMULSU_W_HEE : RVPBinary1LongFW<0b1100, 0b01, 0b011, "pmulsu.w.hee">; +def MULSU_W00 : RVPBinary1LongFW<0b1100, 0b11, 0b011, "mulsu.w00">; +def PMACCSU_W_HEE : RVPBinary1LongFW<0b1101, 0b01, 0b011, "pmaccsu.w.hee">; +def MACCSU_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b011, "maccsu.w00">; +def PMULSU_W_HOO : RVPBinary1LongFW<0b1110, 0b01, 0b011, "pmulsu.w.hoo">; +def MULSU_W11 : RVPBinary1LongFW<0b1110, 0b11, 0b011, "mulsu.w11">; +def PMACCSU_W_HOO : RVPBinary1LongFW<0b1111, 0b01, 0b011, "pmaccsu.w.hoo">; +def MACCSU_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b011, "maccsu.w11">; } // Predicates = [HasStdExtP, IsRV64] @@ -596,211 +592,211 @@ def PPACKT : RVPBinary1F0W<0b011, 0b11, "ppackt", 0b100>; 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>; +def PM2ADD_H : RVPBinary1LongFW<0b0000, 0b00, 0b101, "pm2add.h">; +def PM4ADD_B : RVPBinary1LongFW<0b0000, 0b10, 0b101, "pm4add.b">; +def PM2ADDA_H : RVPBinary1LongFW<0b0001, 0b00, 0b101, "pm2adda.h">; +def PM4ADDA_B : RVPBinary1LongFW<0b0001, 0b10, 0b101, "pm4adda.b">; +def PM2ADD_HX : RVPBinary1LongFW<0b0010, 0b00, 0b101, "pm2add.hx">; +def PM2ADDA_HX : RVPBinary1LongFW<0b0011, 0b00, 0b101, "pm2adda.hx">; + +def PM2ADDU_H : RVPBinary1LongFW<0b0100, 0b00, 0b101, "pm2addu.h">; +def PM4ADDU_B : RVPBinary1LongFW<0b0100, 0b10, 0b101, "pm4addu.b">; +def PM2ADDAU_H : RVPBinary1LongFW<0b0101, 0b00, 0b101, "pm2addau.h">; +def PM4ADDAU_B : RVPBinary1LongFW<0b0101, 0b10, 0b101, "pm4addau.b">; +def PMQ2ADD_H : RVPBinary1LongFW<0b0110, 0b00, 0b101, "pmq2add.h">; +def PMQR2ADD_H : RVPBinary1LongFW<0b0110, 0b10, 0b101, "pmqr2add.h">; +def PMQ2ADDA_H : RVPBinary1LongFW<0b0111, 0b00, 0b101, "pmq2adda.h">; +def PMQR2ADDA_H : RVPBinary1LongFW<0b0111, 0b10, 0b101, "pmqr2adda.h">; + +def PM2SUB_H : RVPBinary1LongFW<0b1000, 0b00, 0b101, "pm2sub.h">; +def PM2SADD_H : RVPBinary1LongFW<0b1000, 0b10, 0b101, "pm2sadd.h">; +def PM2SUBA_H : RVPBinary1LongFW<0b1001, 0b00, 0b101, "pm2suba.h">; +def PM2SUB_HX : RVPBinary1LongFW<0b1010, 0b00, 0b101, "pm2sub.hx">; +def PM2SADD_HX : RVPBinary1LongFW<0b1010, 0b10, 0b101, "pm2sadd.hx">; +def PM2SUBA_HX : RVPBinary1LongFW<0b1011, 0b00, 0b101, "pm2suba.hx">; + +def PM2ADDSU_H : RVPBinary1LongFW<0b1100, 0b00, 0b101, "pm2addsu.h">; +def PM4ADDSU_B : RVPBinary1LongFW<0b1100, 0b10, 0b101, "pm4addsu.b">; +def PM2ADDASU_H : RVPBinary1LongFW<0b1101, 0b00, 0b101, "pm2addasu.h">; +def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, 0b101, "pm4addasu.b">; } // 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>; +def MQACC_H01 : RVPBinary1LongFW<0b0111, 0b00, 0b101, "mqacc.h01">; +def MQRACC_H01 : RVPBinary1LongFW<0b0111, 0b10, 0b101, "mqracc.h01">; } // 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>; +def PM2ADD_W : RVPBinary1LongFW<0b0000, 0b01, 0b101, "pm2add.w">; +def PM4ADD_H : RVPBinary1LongFW<0b0000, 0b11, 0b101, "pm4add.h">; +def PM2ADDA_W : RVPBinary1LongFW<0b0001, 0b01, 0b101, "pm2adda.w">; +def PM4ADDA_H : RVPBinary1LongFW<0b0001, 0b11, 0b101, "pm4adda.h">; +def PM2ADD_WX : RVPBinary1LongFW<0b0010, 0b01, 0b101, "pm2add.wx">; +def PM2ADDA_WX : RVPBinary1LongFW<0b0011, 0b01, 0b101, "pm2adda.wx">; + +def PM2ADDU_W : RVPBinary1LongFW<0b0100, 0b01, 0b101, "pm2addu.w">; +def PM4ADDU_H : RVPBinary1LongFW<0b0100, 0b11, 0b101, "pm4addu.h">; +def PM2ADDAU_W : RVPBinary1LongFW<0b0101, 0b01, 0b101, "pm2addau.w">; +def PM4ADDAU_H : RVPBinary1LongFW<0b0101, 0b11, 0b101, "pm4addau.h">; +def PMQ2ADD_W : RVPBinary1LongFW<0b0110, 0b01, 0b101, "pmq2add.w">; +def PMQR2ADD_W : RVPBinary1LongFW<0b0110, 0b11, 0b101, "pmqr2add.w">; +def PMQ2ADDA_W : RVPBinary1LongFW<0b0111, 0b01, 0b101, "pmq2adda.w">; +def PMQR2ADDA_W : RVPBinary1LongFW<0b0111, 0b11, 0b101, "pmqr2adda.w">; + +def PM2SUB_W : RVPBinary1LongFW<0b1000, 0b01, 0b101, "pm2sub.w">; +def PM2SUBA_W : RVPBinary1LongFW<0b1001, 0b01, 0b101, "pm2suba.w">; +def PM2SUB_WX : RVPBinary1LongFW<0b1010, 0b01, 0b101, "pm2sub.wx">; +def PM2SUBA_WX : RVPBinary1LongFW<0b1011, 0b01, 0b101, "pm2suba.wx">; + +def PM2ADDSU_W : RVPBinary1LongFW<0b1100, 0b01, 0b101, "pm2addsu.w">; +def PM4ADDSU_H : RVPBinary1LongFW<0b1100, 0b11, 0b101, "pm4addsu.h">; +def PM2ADDASU_W : RVPBinary1LongFW<0b1101, 0b01, 0b101, "pm2addasu.w">; +def PM4ADDASU_H : RVPBinary1LongFW<0b1101, 0b11, 0b101, "pm4addasu.h">; + +def PMQACC_W_HEO : RVPBinary1LongFW<0b1111, 0b00, 0b101, "pmqacc.w.heo">; +def MQACC_W01 : RVPBinary1LongFW<0b1111, 0b01, 0b101, "mqacc.w01">; +def PMQRACC_W_HEO : RVPBinary1LongFW<0b1111, 0b10, 0b101, "pmqracc.w.heo">; +def MQRACC_W01 : RVPBinary1LongFW<0b1111, 0b11, 0b101, "mqracc.w01">; } // 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>; +def PAS_HX : RVPBinary1LongFW<0b0000, 0b00, 0b110, "pas.hx">; +def PSA_HX : RVPBinary1LongFW<0b0000, 0b10, 0b110, "psa.hx">; +def PSAS_HX : RVPBinary1LongFW<0b0010, 0b00, 0b110, "psas.hx">; +def PSSA_HX : RVPBinary1LongFW<0b0010, 0b10, 0b110, "pssa.hx">; + +def PMSEQ_H : RVPBinary1LongFW<0b1000, 0b00, 0b110, "pmseq.h">; +def PMSEQ_B : RVPBinary1LongFW<0b1000, 0b10, 0b110, "pmseq.b">; +def PMSLT_H : RVPBinary1LongFW<0b1010, 0b00, 0b110, "pmslt.h">; +def PMSLT_B : RVPBinary1LongFW<0b1010, 0b10, 0b110, "pmslt.b">; +def PMSLTU_H : RVPBinary1LongFW<0b1011, 0b00, 0b110, "pmsltu.h">; +def PMSLTU_B : RVPBinary1LongFW<0b1011, 0b10, 0b110, "pmsltu.b">; + +def PMIN_H : RVPBinary1LongFW<0b1100, 0b00, 0b110, "pmin.h">; +def PMIN_B : RVPBinary1LongFW<0b1100, 0b10, 0b110, "pmin.b">; +def PMINU_H : RVPBinary1LongFW<0b1101, 0b00, 0b110, "pminu.h">; +def PMINU_B : RVPBinary1LongFW<0b1101, 0b10, 0b110, "pminu.b">; +def PMAX_H : RVPBinary1LongFW<0b1110, 0b00, 0b110, "pmax.h">; +def PMAX_B : RVPBinary1LongFW<0b1110, 0b10, 0b110, "pmax.b">; +def PMAXU_H : RVPBinary1LongFW<0b1111, 0b00, 0b110, "pmaxu.h">; +def PMAXU_B : RVPBinary1LongFW<0b1111, 0b10, 0b110, "pmaxu.b">; } // 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>; +def MSEQ : RVPBinary1LongFW<0b1000, 0b01, 0b110, "mseq">; +def MSLT : RVPBinary1LongFW<0b1010, 0b01, 0b110, "mslt">; +def MSLTU : RVPBinary1LongFW<0b1011, 0b01, 0b110, "msltu">; } // 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>; +def PAS_WX : RVPBinary1LongFW<0b0000, 0b01, 0b110, "pas.wx">; +def PSA_WX : RVPBinary1LongFW<0b0000, 0b11, 0b110, "psa.wx">; +def PSAS_WX : RVPBinary1LongFW<0b0010, 0b01, 0b110, "psas.wx">; +def PSSA_WX : RVPBinary1LongFW<0b0010, 0b11, 0b110, "pssa.wx">; +def PAAS_WX : RVPBinary1LongFW<0b0011, 0b01, 0b110, "paas.wx">; +def PASA_WX : RVPBinary1LongFW<0b0011, 0b11, 0b110, "pasa.wx">; + +def PMSEQ_W : RVPBinary1LongFW<0b1000, 0b01, 0b110, "pmseq.w">; +def PMSLT_W : RVPBinary1LongFW<0b1010, 0b01, 0b110, "pmslt.w">; +def PMSLTU_W : RVPBinary1LongFW<0b1011, 0b01, 0b110, "pmsltu.w">; + +def PMIN_W : RVPBinary1LongFW<0b1100, 0b01, 0b110, "pmin.w">; +def PMINU_W : RVPBinary1LongFW<0b1101, 0b01, 0b110, "pminu.w">; +def PMAX_W : RVPBinary1LongFW<0b1110, 0b01, 0b110, "pmax.w">; +def PMAXU_W : RVPBinary1LongFW<0b1111, 0b01, 0b110, "pmaxu.w">; } // 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>; +def PMULH_H : RVPBinary1LongFW<0b0000, 0b00, 0b111, "pmulh.h">; +def PMULHR_H : RVPBinary1LongFW<0b0000, 0b10, 0b111, "pmulhr.h">; +def PMHACC_H : RVPBinary1LongFW<0b0001, 0b00, 0b111, "pmhacc.h">; +def PMHRACC_H : RVPBinary1LongFW<0b0001, 0b10, 0b111, "pmhracc.h">; +def PMULHU_H : RVPBinary1LongFW<0b0010, 0b00, 0b111, "pmulhu.h">; +def PMULHRU_H : RVPBinary1LongFW<0b0010, 0b10, 0b111, "pmulhru.h">; +def PMHACCU_H : RVPBinary1LongFW<0b0011, 0b00, 0b111, "pmhaccu.h">; +def PMHRACCU_H : RVPBinary1LongFW<0b0011, 0b10, 0b111, "pmhraccu.h">; + +def PMULH_H_BE : RVPBinary1LongFW<0b0100, 0b00, 0b111, "pmulh.h.be">; +def PMULHSU_H_BE : RVPBinary1LongFW<0b0100, 0b10, 0b111, "pmulhsu.h.be">; +def PMHACCU_H_BE : RVPBinary1LongFW<0b0101, 0b00, 0b111, "pmhaccu.h.be">; +def PMHACCSU_H_BE: RVPBinary1LongFW<0b0101, 0b10, 0b111, "pmhaccsu.h.be">; +def PMULH_H_BO : RVPBinary1LongFW<0b0110, 0b00, 0b111, "pmulh.h.bo">; +def PMULHSU_H_BO : RVPBinary1LongFW<0b0110, 0b10, 0b111, "pmulhsu.h.bo">; +def PMHACC_H_BO : RVPBinary1LongFW<0b0111, 0b00, 0b111, "pmhacc.h.bo">; +def PMHACCSU_H_BO: RVPBinary1LongFW<0b0111, 0b10, 0b111, "pmhaccsu.h.bo">; + +def PMULHSU_H : RVPBinary1LongFW<0b1000, 0b00, 0b111, "pmulhsu.h">; +def PMULHRSU_H : RVPBinary1LongFW<0b1000, 0b10, 0b111, "pmulhrsu.h">; +def PMHACCSU_H : RVPBinary1LongFW<0b1001, 0b00, 0b111, "pmhaccsu.h">; +def PMHRACCSU_H : RVPBinary1LongFW<0b1001, 0b10, 0b111, "pmhraccsu.h">; +def PMULQ_H : RVPBinary1LongFW<0b1010, 0b00, 0b111, "pmulq.h">; +def PMULQR_H : RVPBinary1LongFW<0b1010, 0b10, 0b111, "pmulqr.h">; } // 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>; +def MULHR : RVPBinary1LongFW<0b0000, 0b11, 0b111, "mulhr">; +def MHACC : RVPBinary1LongFW<0b0001, 0b01, 0b111, "mhacc">; +def MHRACC : RVPBinary1LongFW<0b0001, 0b11, 0b111, "mhracc">; +def MULHRU : RVPBinary1LongFW<0b0010, 0b11, 0b111, "mulhru">; +def MHACCU : RVPBinary1LongFW<0b0011, 0b01, 0b111, "mhaccu">; +def MHRACCU : RVPBinary1LongFW<0b0011, 0b11, 0b111, "mhraccu">; + +def MULH_H0 : RVPBinary1LongFW<0b0100, 0b01, 0b111, "mulh.h0">; +def MULHSU_H0 : RVPBinary1LongFW<0b0100, 0b11, 0b111, "mulhsu.h0">; +def MHACC_H0 : RVPBinary1LongFW<0b0101, 0b01, 0b111, "mhacc.h0">; +def MHACCSU_H0 : RVPBinary1LongFW<0b0101, 0b11, 0b111, "mhaccsu.h0">; +def MULH_H1 : RVPBinary1LongFW<0b0110, 0b01, 0b111, "mulh.h1">; +def MULHSU_H1 : RVPBinary1LongFW<0b0110, 0b11, 0b111, "mulhsu.h1">; +def MHACC_H1 : RVPBinary1LongFW<0b0111, 0b01, 0b111, "mhacc.h1">; +def MHACCSU_H1 : RVPBinary1LongFW<0b0111, 0b11, 0b111, "mhaccsu.h1">; + +def MULHRSU_H : RVPBinary1LongFW<0b1000, 0b11, 0b111, "mulhrsu.h">; +def MHACCSU : RVPBinary1LongFW<0b1001, 0b01, 0b111, "mhaccsu">; +def MHRACCSU : RVPBinary1LongFW<0b1001, 0b11, 0b111, "mhraccsu">; +def MULQ : RVPBinary1LongFW<0b1010, 0b01, 0b111, "mulq">; +def MULQR : RVPBinary1LongFW<0b1010, 0b11, 0b111, "mulqr">; + +def MQACC_H00 : RVPBinary1LongFW<0b1101, 0b00, 0b111, "mqacc.h00">; +def MQRACC_H00 : RVPBinary1LongFW<0b1101, 0b10, 0b111, "mqracc.h00">; +def MQACC_H11 : RVPBinary1LongFW<0b1111, 0b00, 0b111, "mqacc.h11">; +def MQRACC_H11 : RVPBinary1LongFW<0b1111, 0b10, 0b111, "mqracc.h11">; } // 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>; +def PMULH_W : RVPBinary1LongFW<0b0000, 0b01, 0b111, "pmulh.w">; +def PMULHR_W : RVPBinary1LongFW<0b0000, 0b11, 0b111, "pmulhr.w">; +def PMHACC_W : RVPBinary1LongFW<0b0001, 0b01, 0b111, "pmhacc.w">; +def PMHRACC_W : RVPBinary1LongFW<0b0001, 0b11, 0b111, "pmhracc.w">; +def PMULHU_W : RVPBinary1LongFW<0b0010, 0b01, 0b111, "pmulhu.w">; +def PMULHRU_W : RVPBinary1LongFW<0b0010, 0b11, 0b111, "pmulhru.w">; +def PMHACCU_W : RVPBinary1LongFW<0b0011, 0b01, 0b111, "pmhaccu.w">; +def PMHRACCU_W : RVPBinary1LongFW<0b0011, 0b11, 0b111, "pmhraccu.w">; + +def PMULH_W_HE : RVPBinary1LongFW<0b0100, 0b01, 0b111, "pmulh.w.he">; +def PMULHSU_W_HE : RVPBinary1LongFW<0b0100, 0b11, 0b111, "pmulhsu.w.he">; +def PMHACC_W_HE : RVPBinary1LongFW<0b0101, 0b01, 0b111, "pmhacc.w.he">; +def PMHACCSU_W_HE: RVPBinary1LongFW<0b0101, 0b11, 0b111, "pmhaccsu.w.he">; +def PMULH_W_HO : RVPBinary1LongFW<0b0110, 0b01, 0b111, "pmulh.w.ho">; +def PMULHSU_W_HO : RVPBinary1LongFW<0b0110, 0b11, 0b111, "pmulhsu.w.ho">; +def PMHACC_W_HO : RVPBinary1LongFW<0b0111, 0b01, 0b111, "pmhacc.w.ho">; +def PMHACCSU_W_HO: RVPBinary1LongFW<0b0111, 0b11, 0b111, "pmhaccsu.w.ho">; + +def PMULHSU_W : RVPBinary1LongFW<0b1000, 0b01, 0b111, "pmulhsu.w">; +def PMULHRSU_W : RVPBinary1LongFW<0b1000, 0b11, 0b111, "pmulhrsu.w">; +def PMHACCSU_W : RVPBinary1LongFW<0b1001, 0b01, 0b111, "pmhaccsu.w">; +def PMHRACCSU_W : RVPBinary1LongFW<0b1001, 0b11, 0b111, "pmhraccsu.w">; +def PMULQ_W : RVPBinary1LongFW<0b1010, 0b01, 0b111, "pmulq.w">; +def PMULQR_W : RVPBinary1LongFW<0b1010, 0b11, 0b111, "pmulqr.w">; + +def PMQACC_W_HEE : RVPBinary1LongFW<0b1101, 0b00, 0b111, "pmqacc.w.hee">; +def MQACC_W00 : RVPBinary1LongFW<0b1101, 0b01, 0b111, "mqacc.w00">; +def PMQRACC_W_HEE: RVPBinary1LongFW<0b1101, 0b10, 0b111, "pmqracc.w.hee">; +def MQRACC_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b111, "mqracc.w00">; +def PMQACC_W_HOO : RVPBinary1LongFW<0b1111, 0b00, 0b111, "pmqacc.w.hoo">; +def MQACC_W11 : RVPBinary1LongFW<0b1111, 0b01, 0b111, "mqacc.w11">; +def PMQRACC_W_HOO: RVPBinary1LongFW<0b1111, 0b10, 0b111, "pmqracc.w.hoo">; +def MQRACC_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b111, "mqracc.w11">; } // Predicates = [HasStdExtP, IsRV64] @@ -813,9 +809,9 @@ 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 PLI_DH : RVPUnaryImm9<0b0011000, "pli.dh", GPRPairRV32>; +def PLI_DB : RVPUnaryImm8<0b00110100, "pli.db", GPRPairRV32>; +def PLUI_DH : RVPUnaryImm9<0b0111000, "plui.dh", GPRPairRV32>; def PWSLLI_B_B0 : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.b.b0">; @@ -828,22 +824,22 @@ 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 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">; @@ -858,22 +854,22 @@ 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 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">; @@ -915,28 +911,28 @@ 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 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 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 NCLIPR : RVPBinary0F1WRs1p<0b111, 0b11, "nclipr", 0b1>; def PSLLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "pslli.db">; @@ -964,27 +960,27 @@ 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 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 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 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 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 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">; @@ -1031,38 +1027,38 @@ 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 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 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 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 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/test/CodeGen/RISCV/attributes.ll b/llvm/test/CodeGen/RISCV/attributes.ll index 3d2afda9d0c71..605fbd2e87488 100644 --- a/llvm/test/CodeGen/RISCV/attributes.ll +++ b/llvm/test/CodeGen/RISCV/attributes.ll @@ -466,7 +466,7 @@ ; RV32SUPM: .attribute 5, "rv32i2p1_supm1p0" ; RV32SMCTR: .attribute 5, "rv32i2p1_smctr1p0_sscsrind1p0" ; RV32SSCTR: .attribute 5, "rv32i2p1_sscsrind1p0_ssctr1p0" -; RV32P: .attribute 5, "rv32i2p1_p1p0" +; RV32P: .attribute 5, "rv32i2p1_p0p12" ; RV64M: .attribute 5, "rv64i2p1_m2p0_zmmul1p0" ; RV64ZMMUL: .attribute 5, "rv64i2p1_zmmul1p0" From 7061656abf3613181099556798dac244143c6d8c Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Wed, 12 Feb 2025 17:23:34 +1100 Subject: [PATCH 07/17] update extension to version 014 --- .../Driver/print-supported-extensions-riscv.c | 2 +- llvm/docs/RISCVUsage.rst | 2 +- llvm/lib/Target/RISCV/RISCVFeatures.td | 2 +- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 230 ++++++------ llvm/test/CodeGen/RISCV/attributes.ll | 4 +- llvm/test/MC/RISCV/attribute-arch.s | 8 +- llvm/test/MC/RISCV/rv32p-valid.s | 350 +++++++++--------- llvm/test/MC/RISCV/rv64p-valid.s | 286 +++++++------- .../TargetParser/RISCVISAInfoTest.cpp | 2 +- 9 files changed, 443 insertions(+), 443 deletions(-) diff --git a/clang/test/Driver/print-supported-extensions-riscv.c b/clang/test/Driver/print-supported-extensions-riscv.c index 5284d0aa9052c..9f0f3266928b4 100644 --- a/clang/test/Driver/print-supported-extensions-riscv.c +++ b/clang/test/Driver/print-supported-extensions-riscv.c @@ -180,7 +180,7 @@ // CHECK-NEXT: xwchc 2.2 'Xwchc' (WCH/QingKe additional compressed opcodes) // CHECK-EMPTY: // CHECK-NEXT: Experimental extensions -// CHECK-NEXT: p 0.12 'P' ('Base P' (Packed SIMD)) +// CHECK-NEXT: p 0.14 'P' ('Base P' (Packed SIMD)) // CHECK-NEXT: zicfilp 1.0 'Zicfilp' (Landing pad) // CHECK-NEXT: zicfiss 1.0 'Zicfiss' (Shadow stack) // CHECK-NEXT: zalasr 0.1 'Zalasr' (Load-Acquire and Store-Release Instructions) diff --git a/llvm/docs/RISCVUsage.rst b/llvm/docs/RISCVUsage.rst index 17c20225cfab6..8522f690ab3f6 100644 --- a/llvm/docs/RISCVUsage.rst +++ b/llvm/docs/RISCVUsage.rst @@ -336,7 +336,7 @@ The primary goal of experimental support is to assist in the process of ratifica LLVM implements the `0.3 draft specification `__. ``experimental-p``, ``experimental-p`` - LLVM implements the `012 draft specification `__. + LLVM implements the `014 draft specification `__. 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`. diff --git a/llvm/lib/Target/RISCV/RISCVFeatures.td b/llvm/lib/Target/RISCV/RISCVFeatures.td index 7d0b52f1b8bf9..36bba69db3c9c 100644 --- a/llvm/lib/Target/RISCV/RISCVFeatures.td +++ b/llvm/lib/Target/RISCV/RISCVFeatures.td @@ -1018,7 +1018,7 @@ def HasStdExtSmctrOrSsctr : Predicate<"Subtarget->hasStdExtSmctrOrSsctr()">, // Packed SIMD Extensions def FeatureStdExtP - : RISCVExperimentalExtension<0, 12, + : RISCVExperimentalExtension<0, 14, "'Base P' (Packed SIMD)">; def HasStdExtP : Predicate<"Subtarget->hasStdExtP()">, AssemblerPredicate<(all_of FeatureStdExtP), diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 7372d3b81085f..3f678dd10279b 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -306,15 +306,15 @@ def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { -def PSEXTB_H_RV32 : RVPUnaryWUF<0b00, 0b00100, "psextb.h">; +def PSEXT_H_B_RV32 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; 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 PSEXT_H_B_RV64 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; +def PSEXT_W_B : RVPUnaryWUF<0b01, 0b00100, "psext.w.b">; +def PSEXT_W_H : RVPUnaryWUF<0b01, 0b00101, "psext.w.h">; def PSABS_H_RV64 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; def PSABS_B_RV64 : RVPUnaryWUF<0b10, 0b00111, "psabs.b">; } // Predicates = [HasStdExtP, IsRV64] @@ -325,12 +325,12 @@ let Predicates = [HasStdExtP, IsRV64] in def PLUI_W : RVPUnaryImm9<0b1111001, "plui.w">; let Predicates = [HasStdExtP] in { -def PSLL_H_H0 : RVPBinary1F1W<0b000, 0b00, "psll.h.h0", 0b010>; -def PSLL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psll.b.b0", 0b010>; -def PADD_H_H0 : RVPBinary1F1W<0b001, 0b00, "padd.h.h0", 0b010>; -def PADD_B_B0 : RVPBinary1F1W<0b001, 0b10, "padd.b.b0", 0b010>; -def PSSHA_H_H0 : RVPBinary1F1W<0b110, 0b00, "pssha.h.h0", 0b010>; -def PSSHAR_H_H0 : RVPBinary1F1W<0b111, 0b00, "psshar.h.h0", 0b010>; +def PSLL_HS : RVPBinary1F1W<0b000, 0b00, "psll.hs", 0b010>; +def PSLL_BS : RVPBinary1F1W<0b000, 0b10, "psll.bs", 0b010>; +def PADD_HS : RVPBinary1F1W<0b001, 0b00, "padd.hs", 0b010>; +def PADD_BS : RVPBinary1F1W<0b001, 0b10, "padd.bs", 0b010>; +def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, "pssha.hs", 0b010>; +def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, "psshar.hs", 0b010>; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { @@ -339,10 +339,10 @@ def SSHAR : RVPBinary1F1W<0b111, 0b01, "sshar", 0b010>; } // Predicates = [HasStdExtP, IsRV32] let Predicates = [HasStdExtP, IsRV64] in { -def PSLL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psll.w.w0", 0b010>; -def PADD_W_W0 : RVPBinary1F1W<0b001, 0b01, "padd.w.w0", 0b010>; -def PSSHA_W_W0 : RVPBinary1F1W<0b110, 0b01, "pssha.w.w0", 0b010>; -def PSSHAR_W_W0 : RVPBinary1F1W<0b111, 0b01, "psshar.w.w0", 0b010>; +def PSLL_WS : RVPBinary1F1W<0b000, 0b01, "psll.ws", 0b010>; +def PADD_WS : RVPBinary1F1W<0b001, 0b01, "padd.ws", 0b010>; +def PSSHA_WS : RVPBinary1F1W<0b110, 0b01, "pssha.ws", 0b010>; +def PSSHAR_WS : RVPBinary1F1W<0b111, 0b01, "psshar.ws", 0b010>; def SHA : RVPBinary1F1W<0b110, 0b11, "sha", 0b010>; def SHAR : RVPBinary1F1W<0b111, 0b11, "shar", 0b010>; } // Predicates = [HasStdExtP, IsRV64] @@ -370,21 +370,21 @@ 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>; -def PSRL_B_B0 : RVPBinary1F1W<0b000, 0b10, "psrl.b.b0", 0b100>; -def PREDSUM_H : RVPBinary1F1W<0b001, 0b00, "predsum.h", 0b100>; -def PREDSUM_B : RVPBinary1F1W<0b001, 0b10, "predsum.b", 0b100>; -def PREDSUMU_H : RVPBinary1F1W<0b011, 0b00, "predsumu.h", 0b100>; -def PREDSUMU_B : RVPBinary1F1W<0b011, 0b10, "predsumu.b", 0b100>; -def PSRA_H_H0 : RVPBinary1F1W<0b100, 0b00, "psra.h.h0", 0b100>; -def PSRA_B_B0 : RVPBinary1F1W<0b100, 0b10, "psra.b.b0", 0b100>; +def PSRL_HS : RVPBinary1F1W<0b000, 0b00, "psrl.hs", 0b100>; +def PSRL_BS : RVPBinary1F1W<0b000, 0b10, "psrl.bs", 0b100>; +def PREDSUM_HS : RVPBinary1F1W<0b001, 0b00, "predsum.hs", 0b100>; +def PREDSUM_BS : RVPBinary1F1W<0b001, 0b10, "predsum.bs", 0b100>; +def PREDSUMU_HS : RVPBinary1F1W<0b011, 0b00, "predsumu.hs", 0b100>; +def PREDSUMU_BS : RVPBinary1F1W<0b011, 0b10, "predsumu.bs", 0b100>; +def PSRA_HS : RVPBinary1F1W<0b100, 0b00, "psra.hs", 0b100>; +def PSRA_BS : RVPBinary1F1W<0b100, 0b10, "psra.bs", 0b100>; } // Predicates = [HasStdExtP] let Predicates = [HasStdExtP, IsRV64] in { -def PSRL_W_W0 : RVPBinary1F1W<0b000, 0b01, "psrl.w.w0", 0b100>; -def PREDSUM_W : RVPBinary1F1W<0b001, 0b01, "predsum.w", 0b100>; -def PREDSUMU_W : RVPBinary1F1W<0b011, 0b01, "predsumu.w", 0b100>; -def PSRA_W_W0 : RVPBinary1F1W<0b100, 0b01, "psra.w.w0", 0b100>; +def PSRL_WS : RVPBinary1F1W<0b000, 0b01, "psrl.ws", 0b100>; +def PREDSUM_WS : RVPBinary1F1W<0b001, 0b01, "predsum.ws", 0b100>; +def PREDSUMU_WS : RVPBinary1F1W<0b011, 0b01, "predsumu.ws", 0b100>; +def PSRA_WS : RVPBinary1F1W<0b100, 0b01, "psra.ws", 0b100>; } // Predicates = [HasStdExtP, IsRV64] @@ -452,13 +452,13 @@ def PASUBU_W : RVPBinary1LongFW<0b1111, 0b01, 0b000, "pasubu.w">; let Predicates = [HasStdExtP] in { def SLX : RVPBinary1LongFW<0b0001, 0b11, 0b001, "slx">; -def PMUL_H_BEO : RVPBinary1LongFW<0b0010, 0b00, 0b001, "pmul.h.beo">; +def PMUL_H_B01 : RVPBinary1LongFW<0b0010, 0b00, 0b001, "pmul.h.b01">; def MVM : RVPBinary1LongFW<0b0101, 0b00, 0b001, "mvm">; def MVMN : RVPBinary1LongFW<0b0101, 0b01, 0b001, "mvmn">; def MERGE : RVPBinary1LongFW<0b0101, 0b10, 0b001, "merge">; def SRX : RVPBinary1LongFW<0b0101, 0b11, 0b001, "srx">; -def PMULU_H_BEO : RVPBinary1LongFW<0b0110, 0b00, 0b001, "pmulu.h.beo">; +def PMULU_H_B01 : RVPBinary1LongFW<0b0110, 0b00, 0b001, "pmulu.h.b01">; def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, 0b001, "pdifsumu.b">; def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, 0b001, "pdifsumau.b">; } // Predicates = [HasStdExtP] @@ -473,14 +473,14 @@ def MACCU_H01 : RVPBinary1LongFW<0b0111, 0b01, 0b001, "maccu.h01">; } // Predicates = [HasStdExtP, IsRV32] let Predicates = [HasStdExtP, IsRV64] in { -def PMUL_W_HEO : RVPBinary1LongFW<0b0010, 0b01, 0b001, "pmul.w.heo">; +def PMUL_W_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "pmul.w.h01">; def MUL_W01 : RVPBinary1LongFW<0b0010, 0b11, 0b001, "mul.w01">; -def PMACC_W_HEO : RVPBinary1LongFW<0b0011, 0b01, 0b001, "pmacc.w.heo">; +def PMACC_W_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "pmacc.w.h01">; def MACC_W01 : RVPBinary1LongFW<0b0011, 0b11, 0b001, "macc.w01">; -def PMULU_W_HEO : RVPBinary1LongFW<0b0110, 0b01, 0b001, "pmulu.w.heo">; +def PMULU_W_H01 : RVPBinary1LongFW<0b0110, 0b01, 0b001, "pmulu.w.h01">; def MULU_W01 : RVPBinary1LongFW<0b0110, 0b11, 0b001, "mulu.w01">; -def PMACCU_W_HEO : RVPBinary1LongFW<0b0111, 0b01, 0b001, "pmaccu.w.heo">; +def PMACCU_W_H01 : RVPBinary1LongFW<0b0111, 0b01, 0b001, "pmaccu.w.h01">; def MACCU_W01 : RVPBinary1LongFW<0b0111, 0b11, 0b001, "maccu.w01">; } // Predicates = [HasStdExtP, IsRV64] @@ -510,14 +510,14 @@ def ZIP16HP : RVPBinary1F0W<0b111, 0b11, "zip16hp", 0b010>; let Predicates = [HasStdExtP] in { -def PMUL_H_BEE : RVPBinary1LongFW<0b0000, 0b00, 0b011, "pmul.h.bee">; -def PMUL_H_BOO : RVPBinary1LongFW<0b0010, 0b00, 0b011, "pmul.h.boo">; +def PMUL_H_B00 : RVPBinary1LongFW<0b0000, 0b00, 0b011, "pmul.h.b00">; +def PMUL_H_B11 : RVPBinary1LongFW<0b0010, 0b00, 0b011, "pmul.h.b11">; -def PMULU_H_BEE : RVPBinary1LongFW<0b0100, 0b00, 0b011, "pmulu.h.bee">; -def PMULU_H_BOO : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.boo">; +def PMULU_H_B00 : RVPBinary1LongFW<0b0100, 0b00, 0b011, "pmulu.h.b00">; +def PMULU_H_B11 : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.b11">; -def PMULSU_H_BEE : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.bee">; -def PMULSU_H_BOO : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.boo">; +def PMULSU_H_B00 : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.b00">; +def PMULSU_H_B11 : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.b11">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { @@ -538,31 +538,31 @@ def MACCSU_H11 : RVPBinary1LongFW<0b1111, 0b01, 0b011, "maccsu.h11">; } // Predicates = [HasStdExtP, IsRV32] let Predicates = [HasStdExtP, IsRV64] in { -def PMUL_W_BEE : RVPBinary1LongFW<0b0000, 0b01, 0b011, "pmul.w.bee">; +def PMUL_W_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "pmul.w.h00">; def MUL_W00 : RVPBinary1LongFW<0b0000, 0b11, 0b011, "mul.w00">; -def PMACC_W_HEE : RVPBinary1LongFW<0b0001, 0b01, 0b011, "pmacc.w.hee">; +def PMACC_W_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "pmacc.w.h00">; def MACC_W00 : RVPBinary1LongFW<0b0001, 0b11, 0b011, "macc.w00">; -def PMUL_W_HOO : RVPBinary1LongFW<0b0010, 0b01, 0b011, "pmul.w.hoo">; +def PMUL_W_H11 : RVPBinary1LongFW<0b0010, 0b01, 0b011, "pmul.w.h11">; def MUL_W11 : RVPBinary1LongFW<0b0010, 0b11, 0b011, "mul.w11">; -def PMACC_W_HOO : RVPBinary1LongFW<0b0011, 0b01, 0b011, "pmacc.w.hoo">; +def PMACC_W_H11 : RVPBinary1LongFW<0b0011, 0b01, 0b011, "pmacc.w.h11">; def MACC_W11 : RVPBinary1LongFW<0b0011, 0b11, 0b011, "macc.w11">; -def PMULU_W_HEE : RVPBinary1LongFW<0b0100, 0b01, 0b011, "pmulu.w.hee">; +def PMULU_W_H00 : RVPBinary1LongFW<0b0100, 0b01, 0b011, "pmulu.w.h00">; def MULU_W00 : RVPBinary1LongFW<0b0100, 0b11, 0b011, "mulu.w00">; -def PMACCU_W_HEE : RVPBinary1LongFW<0b0101, 0b01, 0b011, "pmaccu.w.hee">; +def PMACCU_W_H00 : RVPBinary1LongFW<0b0101, 0b01, 0b011, "pmaccu.w.h00">; def MACCU_W00 : RVPBinary1LongFW<0b0101, 0b11, 0b011, "maccu.w00">; -def PMULU_W_HOO : RVPBinary1LongFW<0b0110, 0b01, 0b011, "pmulu.w.hoo">; +def PMULU_W_H11 : RVPBinary1LongFW<0b0110, 0b01, 0b011, "pmulu.w.h11">; def MULU_W11 : RVPBinary1LongFW<0b0110, 0b11, 0b011, "mulu.w11">; -def PMACCU_W_HOO : RVPBinary1LongFW<0b0111, 0b01, 0b011, "pmaccu.w.hoo">; +def PMACCU_W_H11 : RVPBinary1LongFW<0b0111, 0b01, 0b011, "pmaccu.w.h11">; def MACCU_W11 : RVPBinary1LongFW<0b0111, 0b11, 0b011, "maccu.w11">; -def PMULSU_W_HEE : RVPBinary1LongFW<0b1100, 0b01, 0b011, "pmulsu.w.hee">; +def PMULSU_W_H00 : RVPBinary1LongFW<0b1100, 0b01, 0b011, "pmulsu.w.h00">; def MULSU_W00 : RVPBinary1LongFW<0b1100, 0b11, 0b011, "mulsu.w00">; -def PMACCSU_W_HEE : RVPBinary1LongFW<0b1101, 0b01, 0b011, "pmaccsu.w.hee">; +def PMACCSU_W_H00 : RVPBinary1LongFW<0b1101, 0b01, 0b011, "pmaccsu.w.h00">; def MACCSU_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b011, "maccsu.w00">; -def PMULSU_W_HOO : RVPBinary1LongFW<0b1110, 0b01, 0b011, "pmulsu.w.hoo">; +def PMULSU_W_H11 : RVPBinary1LongFW<0b1110, 0b01, 0b011, "pmulsu.w.h11">; def MULSU_W11 : RVPBinary1LongFW<0b1110, 0b11, 0b011, "mulsu.w11">; -def PMACCSU_W_HOO : RVPBinary1LongFW<0b1111, 0b01, 0b011, "pmaccsu.w.hoo">; +def PMACCSU_W_H11 : RVPBinary1LongFW<0b1111, 0b01, 0b011, "pmaccsu.w.h11">; def MACCSU_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b011, "maccsu.w11">; } // Predicates = [HasStdExtP, IsRV64] @@ -653,9 +653,9 @@ def PM4ADDSU_H : RVPBinary1LongFW<0b1100, 0b11, 0b101, "pm4addsu.h">; def PM2ADDASU_W : RVPBinary1LongFW<0b1101, 0b01, 0b101, "pm2addasu.w">; def PM4ADDASU_H : RVPBinary1LongFW<0b1101, 0b11, 0b101, "pm4addasu.h">; -def PMQACC_W_HEO : RVPBinary1LongFW<0b1111, 0b00, 0b101, "pmqacc.w.heo">; +def PMQACC_W_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "pmqacc.w.h01">; def MQACC_W01 : RVPBinary1LongFW<0b1111, 0b01, 0b101, "mqacc.w01">; -def PMQRACC_W_HEO : RVPBinary1LongFW<0b1111, 0b10, 0b101, "pmqracc.w.heo">; +def PMQRACC_W_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "pmqracc.w.h01">; def MQRACC_W01 : RVPBinary1LongFW<0b1111, 0b11, 0b101, "mqracc.w01">; } // Predicates = [HasStdExtP, IsRV64] @@ -716,14 +716,14 @@ def PMULHRU_H : RVPBinary1LongFW<0b0010, 0b10, 0b111, "pmulhru.h">; def PMHACCU_H : RVPBinary1LongFW<0b0011, 0b00, 0b111, "pmhaccu.h">; def PMHRACCU_H : RVPBinary1LongFW<0b0011, 0b10, 0b111, "pmhraccu.h">; -def PMULH_H_BE : RVPBinary1LongFW<0b0100, 0b00, 0b111, "pmulh.h.be">; -def PMULHSU_H_BE : RVPBinary1LongFW<0b0100, 0b10, 0b111, "pmulhsu.h.be">; -def PMHACCU_H_BE : RVPBinary1LongFW<0b0101, 0b00, 0b111, "pmhaccu.h.be">; -def PMHACCSU_H_BE: RVPBinary1LongFW<0b0101, 0b10, 0b111, "pmhaccsu.h.be">; -def PMULH_H_BO : RVPBinary1LongFW<0b0110, 0b00, 0b111, "pmulh.h.bo">; -def PMULHSU_H_BO : RVPBinary1LongFW<0b0110, 0b10, 0b111, "pmulhsu.h.bo">; -def PMHACC_H_BO : RVPBinary1LongFW<0b0111, 0b00, 0b111, "pmhacc.h.bo">; -def PMHACCSU_H_BO: RVPBinary1LongFW<0b0111, 0b10, 0b111, "pmhaccsu.h.bo">; +def PMULH_H_B0 : RVPBinary1LongFW<0b0100, 0b00, 0b111, "pmulh.h.b0">; +def PMULHSU_H_B0 : RVPBinary1LongFW<0b0100, 0b10, 0b111, "pmulhsu.h.b0">; +def PMHACCU_H_B0 : RVPBinary1LongFW<0b0101, 0b00, 0b111, "pmhaccu.h.b0">; +def PMHACCSU_H_B0: RVPBinary1LongFW<0b0101, 0b10, 0b111, "pmhaccsu.h.b0">; +def PMULH_H_B1 : RVPBinary1LongFW<0b0110, 0b00, 0b111, "pmulh.h.b1">; +def PMULHSU_H_B1 : RVPBinary1LongFW<0b0110, 0b10, 0b111, "pmulhsu.h.b1">; +def PMHACC_H_B1 : RVPBinary1LongFW<0b0111, 0b00, 0b111, "pmhacc.h.b1">; +def PMHACCSU_H_B1: RVPBinary1LongFW<0b0111, 0b10, 0b111, "pmhaccsu.h.b1">; def PMULHSU_H : RVPBinary1LongFW<0b1000, 0b00, 0b111, "pmulhsu.h">; def PMULHRSU_H : RVPBinary1LongFW<0b1000, 0b10, 0b111, "pmulhrsu.h">; @@ -773,14 +773,14 @@ def PMULHRU_W : RVPBinary1LongFW<0b0010, 0b11, 0b111, "pmulhru.w">; def PMHACCU_W : RVPBinary1LongFW<0b0011, 0b01, 0b111, "pmhaccu.w">; def PMHRACCU_W : RVPBinary1LongFW<0b0011, 0b11, 0b111, "pmhraccu.w">; -def PMULH_W_HE : RVPBinary1LongFW<0b0100, 0b01, 0b111, "pmulh.w.he">; -def PMULHSU_W_HE : RVPBinary1LongFW<0b0100, 0b11, 0b111, "pmulhsu.w.he">; -def PMHACC_W_HE : RVPBinary1LongFW<0b0101, 0b01, 0b111, "pmhacc.w.he">; -def PMHACCSU_W_HE: RVPBinary1LongFW<0b0101, 0b11, 0b111, "pmhaccsu.w.he">; -def PMULH_W_HO : RVPBinary1LongFW<0b0110, 0b01, 0b111, "pmulh.w.ho">; -def PMULHSU_W_HO : RVPBinary1LongFW<0b0110, 0b11, 0b111, "pmulhsu.w.ho">; -def PMHACC_W_HO : RVPBinary1LongFW<0b0111, 0b01, 0b111, "pmhacc.w.ho">; -def PMHACCSU_W_HO: RVPBinary1LongFW<0b0111, 0b11, 0b111, "pmhaccsu.w.ho">; +def PMULH_W_H0 : RVPBinary1LongFW<0b0100, 0b01, 0b111, "pmulh.w.h0">; +def PMULHSU_W_H0 : RVPBinary1LongFW<0b0100, 0b11, 0b111, "pmulhsu.w.h0">; +def PMHACC_W_H0 : RVPBinary1LongFW<0b0101, 0b01, 0b111, "pmhacc.w.h0">; +def PMHACCSU_W_H0: RVPBinary1LongFW<0b0101, 0b11, 0b111, "pmhaccsu.w.h0">; +def PMULH_W_H1 : RVPBinary1LongFW<0b0110, 0b01, 0b111, "pmulh.w.h1">; +def PMULHSU_W_H1 : RVPBinary1LongFW<0b0110, 0b11, 0b111, "pmulhsu.w.h1">; +def PMHACC_W_H1 : RVPBinary1LongFW<0b0111, 0b01, 0b111, "pmhacc.w.h1">; +def PMHACCSU_W_H1: RVPBinary1LongFW<0b0111, 0b11, 0b111, "pmhaccsu.w.h1">; def PMULHSU_W : RVPBinary1LongFW<0b1000, 0b01, 0b111, "pmulhsu.w">; def PMULHRSU_W : RVPBinary1LongFW<0b1000, 0b11, 0b111, "pmulhrsu.w">; @@ -789,13 +789,13 @@ def PMHRACCSU_W : RVPBinary1LongFW<0b1001, 0b11, 0b111, "pmhraccsu.w">; def PMULQ_W : RVPBinary1LongFW<0b1010, 0b01, 0b111, "pmulq.w">; def PMULQR_W : RVPBinary1LongFW<0b1010, 0b11, 0b111, "pmulqr.w">; -def PMQACC_W_HEE : RVPBinary1LongFW<0b1101, 0b00, 0b111, "pmqacc.w.hee">; +def PMQACC_W_H00 : RVPBinary1LongFW<0b1101, 0b00, 0b111, "pmqacc.w.h00">; def MQACC_W00 : RVPBinary1LongFW<0b1101, 0b01, 0b111, "mqacc.w00">; -def PMQRACC_W_HEE: RVPBinary1LongFW<0b1101, 0b10, 0b111, "pmqracc.w.hee">; +def PMQRACC_W_H00: RVPBinary1LongFW<0b1101, 0b10, 0b111, "pmqracc.w.h00">; def MQRACC_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b111, "mqracc.w00">; -def PMQACC_W_HOO : RVPBinary1LongFW<0b1111, 0b00, 0b111, "pmqacc.w.hoo">; +def PMQACC_W_H11 : RVPBinary1LongFW<0b1111, 0b00, 0b111, "pmqacc.w.h11">; def MQACC_W11 : RVPBinary1LongFW<0b1111, 0b01, 0b111, "mqacc.w11">; -def PMQRACC_W_HOO: RVPBinary1LongFW<0b1111, 0b10, 0b111, "pmqracc.w.hoo">; +def PMQRACC_W_H11: RVPBinary1LongFW<0b1111, 0b10, 0b111, "pmqracc.w.h11">; def MQRACC_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b111, "mqracc.w11">; } // Predicates = [HasStdExtP, IsRV64] @@ -814,12 +814,12 @@ def PLI_DB : RVPUnaryImm8<0b00110100, "pli.db", GPRPairRV32>; def PLUI_DH : RVPUnaryImm9<0b0111000, "plui.dh", GPRPairRV32>; -def PWSLLI_B_B0 : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.b.b0">; -def PWSLL_H_H0 : RVPBinary0F1WRdp<0b000, 0b01, "pwsll.h.h0">; +def PWSLLI_BS : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.bs">; +def PWSLL_HS : RVPBinary0F1WRdp<0b000, 0b01, "pwsll.hs">; 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 PWSLA_BS : RVPBinary0F1WRdp<0b100, 0b00, "pwsla.bs">; +def PWSLA_HS : RVPBinary0F1WRdp<0b100, 0b01, "pwsla.hs">; def WSLA : RVPBinary0F1WRdp<0b100, 0b11, "wsla">; def WZIP8P : RVPBinary0F1WRdp<0b111, 0b00, "wzip8p">; def WZIP16P : RVPBinary0F1WRdp<0b111, 0b01, "wzip16p">; @@ -883,10 +883,10 @@ 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 PREDSUM_DHS : RVPBinary0F1WRs1p<0b000, 0b00, "predsum.dhs">; +def PREDSUM_DBS : RVPBinary0F1WRs1p<0b000, 0b10, "predsum.dbs">; +def PREDSUMU_DHS : RVPBinary0F1WRs1p<0b011, 0b00, "predsumu.dhs">; +def PREDSUMU_DBS : RVPBinary0F1WRs1p<0b011, 0b10, "predsumu.dbs">; def PNSRLI_B : RVPUnary0F0Rs1p<0b000, 0b0010000, "pnsrli.b">; def PNSRLI_H : RVPUnary0F0Rs1p<0b000, 0b0100000, "pnsrli.h">; @@ -911,27 +911,27 @@ 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 PNSRL_BS : RVPBinary0F1WRs1p<0b000, 0b00, "pnsrl.bs", 0b1>; +def PNSRL_HS : RVPBinary0F1WRs1p<0b000, 0b01, "pnsrl.hs", 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 PNCLIPU_BS : RVPBinary0F1WRs1p<0b010, 0b00, "pnclipu.bs", 0b1>; +def PNCLIPU_HS : RVPBinary0F1WRs1p<0b010, 0b01, "pnclipu.hs", 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 PNCLIPRU_BS : RVPBinary0F1WRs1p<0b011, 0b00, "pnclipru.bs", 0b1>; +def PNCLIPRU_HS : RVPBinary0F1WRs1p<0b011, 0b01, "pnclipru.hs", 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 PNSRA_BS : RVPBinary0F1WRs1p<0b100, 0b00, "pnsra.bs", 0b1>; +def PNSRA_HS : RVPBinary0F1WRs1p<0b100, 0b01, "pnsra.hs", 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 PNSRAR_BS : RVPBinary0F1WRs1p<0b101, 0b00, "pnsrar.bs", 0b1>; +def PNSRAR_HS : RVPBinary0F1WRs1p<0b101, 0b01, "pnsrar.hs", 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 PNCLIP_BS : RVPBinary0F1WRs1p<0b110, 0b00, "pnclip.bs", 0b1>; +def PNCLIP_HS : RVPBinary0F1WRs1p<0b110, 0b01, "pnclip.hs", 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 PNCLIPR_BS : RVPBinary0F1WRs1p<0b111, 0b00, "pnclipr.bs", 0b1>; +def PNCLIPR_HS : RVPBinary0F1WRs1p<0b111, 0b01, "pnclipr.hs", 0b1>; def NCLIPR : RVPBinary0F1WRs1p<0b111, 0b11, "nclipr", 0b1>; @@ -942,23 +942,23 @@ 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 PSEXT_DH_B : RVPUnaryWUFRs1pRdp<0b00, 0b00100, "psext.dh.b">; +def PSEXT_DW_B : RVPUnaryWUFRs1pRdp<0b01, 0b00100, "psext.dw.b">; +def PSEXT_DW_H : RVPUnaryWUFRs1pRdp<0b01, 0b00101, "psext.dw.h">; +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 PSLL_DHS : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psll.dhs">; +def PSLL_DWS : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psll.dws">; +def PSLL_DBS : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psll.dbs">; +def PADD_DHS : RVPBinary0F1WRs1pRdp<0b001, 0b00, "padd.dhs">; +def PADD_DWS : RVPBinary0F1WRs1pRdp<0b001, 0b01, "padd.dws">; +def PADD_DBS : RVPBinary0F1WRs1pRdp<0b001, 0b10, "padd.dbs">; -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 PSSHA_DHS : RVPBinary0F1WRs1pRdp<0b110, 0b00, "pssha.dhs">; +def PSSHA_DWS : RVPBinary0F1WRs1pRdp<0b110, 0b01, "pssha.dws">; +def PSSHAR_DHS : RVPBinary0F1WRs1pRdp<0b111, 0b00, "psshar.dhs">; +def PSSHAR_DWS : RVPBinary0F1WRs1pRdp<0b111, 0b01, "psshar.dws">; def PSRLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "psrli.db", 0b1>; def PSRLI_DH : RVPUnary0F0Rs1pRdp<0b000, 0b0010000, "psrli.dh", 0b1>; @@ -974,13 +974,13 @@ 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 PSRL_DHS : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psrl.dhs", 0b1>; +def PSRL_DWS : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psrl.dws", 0b1>; +def PSRL_DBS : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psrl.dbs", 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 PSRA_DHS : RVPBinary0F1WRs1pRdp<0b100, 0b00, "psra.dhs", 0b1>; +def PSRA_DWS : RVPBinary0F1WRs1pRdp<0b100, 0b01, "psra.dws", 0b1>; +def PSRA_DBS : RVPBinary0F1WRs1pRdp<0b100, 0b10, "psra.dbs", 0b1>; def PADD_DH : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b00, "padd.dh">; def PADD_DW : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b01, "padd.dw">; diff --git a/llvm/test/CodeGen/RISCV/attributes.ll b/llvm/test/CodeGen/RISCV/attributes.ll index 605fbd2e87488..4b93eb031af79 100644 --- a/llvm/test/CodeGen/RISCV/attributes.ll +++ b/llvm/test/CodeGen/RISCV/attributes.ll @@ -466,7 +466,7 @@ ; RV32SUPM: .attribute 5, "rv32i2p1_supm1p0" ; RV32SMCTR: .attribute 5, "rv32i2p1_smctr1p0_sscsrind1p0" ; RV32SSCTR: .attribute 5, "rv32i2p1_sscsrind1p0_ssctr1p0" -; RV32P: .attribute 5, "rv32i2p1_p0p12" +; RV32P: .attribute 5, "rv32i2p1_p0p14" ; RV64M: .attribute 5, "rv64i2p1_m2p0_zmmul1p0" ; RV64ZMMUL: .attribute 5, "rv64i2p1_zmmul1p0" @@ -615,7 +615,7 @@ ; RV64SSCTR: .attribute 5, "rv64i2p1_sscsrind1p0_ssctr1p0" ; RV64SDEXT: .attribute 5, "rv64i2p1_sdext1p0" ; RV64SDTRIG: .attribute 5, "rv64i2p1_sdtrig1p0" -; RV64P: .attribute 5, "rv64i2p1_p0p12" +; RV64P: .attribute 5, "rv64i2p1_p0p14" ; 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 be040dfcd6cdf..a8bb9b7e6cef1 100644 --- a/llvm/test/MC/RISCV/attribute-arch.s +++ b/llvm/test/MC/RISCV/attribute-arch.s @@ -474,8 +474,8 @@ .attribute arch, "rv32i_sdtrig1p0" # CHECK: attribute 5, "rv32i2p1_sdtrig1p0" -.attribute arch, "rv32i_p0p12" -# CHECK: attribute 5, "rv32i2p1_p0p12" +.attribute arch, "rv32i_p0p14" +# CHECK: attribute 5, "rv32i2p1_p0p14" -.attribute arch, "rv64i_p0p12" -# CHECK: attribute 5, "rv64i2p1_p0p12" \ No newline at end of file +.attribute arch, "rv64i_p0p14" +# CHECK: attribute 5, "rv64i2p1_p0p14" \ No newline at end of file diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s index 57f96048898ee..70d33102cbf18 100644 --- a/llvm/test/MC/RISCV/rv32p-valid.s +++ b/llvm/test/MC/RISCV/rv32p-valid.s @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --llvm-mc-binary ./llvm-mc --tool ./llvm-objdump --version 5 +// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --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 @@ -59,8 +59,8 @@ pli.h a5, 0x5 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] +psext.h.b a7, a0 +// CHECK-ASM: psext.h.b a7, a0 # encoding: [0x9b,0x28,0x45,0xe0] psabs.h a1, a2 // CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0] @@ -71,26 +71,26 @@ psabs.b t0, t1 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.hs a0, a1, a2 +// CHECK-ASM: psll.hs 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] +psll.bs a3, a4, a5 +// CHECK-ASM: psll.bs 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.hs t0, t1, t2 +// CHECK-ASM: padd.hs 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] +padd.bs x1, a1, a2 +// CHECK-ASM: padd.bs 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] +pssha.hs a3, a4, a5 +// CHECK-ASM: pssha.hs 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] +psshar.hs a6, a7, a0 +// CHECK-ASM: psshar.hs a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8] sshar x6, a7, a0 // CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa] @@ -125,29 +125,29 @@ psati.h a4, t0 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.hs a6, a7, a1 +// CHECK-ASM: psrl.hs 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] +psrl.bs a1, a2, a3 +// CHECK-ASM: psrl.bs 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.hs a4, a5, a6 +// CHECK-ASM: predsum.hs 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] +predsum.bs a7, a1, a1 +// CHECK-ASM: predsum.bs 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.hs t0, t1, t2 +// CHECK-ASM: predsumu.hs 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] +predsumu.bs t3, t4, t5 +// CHECK-ASM: predsumu.bs 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.hs x1, a1, a2 +// CHECK-ASM: psra.hs 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] +psra.bs x2, a2, a3 +// CHECK-ASM: psra.bs sp, a2, a3 # encoding: [0x1b,0x41,0xd6,0xcc] psslai.h t0, t1 // CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0xd1] @@ -161,8 +161,8 @@ pli.h a5, 0x5 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] +psext.h.b a7, a0 +// CHECK-ASM: psext.h.b a7, a0 # encoding: [0x9b,0x28,0x45,0xe0] psabs.h a1, a2 // CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0] @@ -173,26 +173,26 @@ psabs.b t0, t1 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.hs a0, a1, a2 +// CHECK-ASM: psll.hs 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] +psll.bs a3, a4, a5 +// CHECK-ASM: psll.bs 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.hs t0, t1, t2 +// CHECK-ASM: padd.hs 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] +padd.bs x1, a1, a2 +// CHECK-ASM: padd.bs 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] +pssha.hs a3, a4, a5 +// CHECK-ASM: pssha.hs 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] +psshar.hs a6, a7, a0 +// CHECK-ASM: psshar.hs a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8] sshar x6, a7, a0 // CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa] @@ -227,29 +227,29 @@ psati.h a4, t0 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.hs a6, a7, a1 +// CHECK-ASM: psrl.hs 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] +psrl.bs a1, a2, a3 +// CHECK-ASM: psrl.bs 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.hs a4, a5, a6 +// CHECK-ASM: predsum.hs 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] +predsum.bs a7, a1, a1 +// CHECK-ASM: predsum.bs 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.hs t0, t1, t2 +// CHECK-ASM: predsumu.hs 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] +predsumu.bs t3, t4, t5 +// CHECK-ASM: predsumu.bs 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.hs x1, a1, a2 +// CHECK-ASM: psra.hs 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] +psra.bs x2, a2, a3 +// CHECK-ASM: psra.bs 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] @@ -350,8 +350,8 @@ pasubu.b t0, t1, t2 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] +pmul.h.b01 t3, t4, t5 +// CHECK-ASM: pmul.h.b01 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] @@ -371,8 +371,8 @@ merge t0, t1, t2 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] +pmulu.h.b01 t3, t4, t5 +// CHECK-ASM: pmulu.h.b01 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] @@ -407,23 +407,23 @@ pssh1sadd.h a3, a4, a5 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.b00 s6, t4, s8 +// CHECK-ASM: pmul.h.b00 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] +pmul.h.b11 t0, t4, s4 +// CHECK-ASM: pmul.h.b11 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.b00 t2, s6, s8 +// CHECK-ASM: pmulu.h.b00 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] +pmulu.h.b11 t2, s6, a0 +// CHECK-ASM: pmulu.h.b11 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.b00 s4, a4, s8 +// CHECK-ASM: pmulsu.h.b00 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] +pmulsu.h.b11 s6, a2, s4 +// CHECK-ASM: pmulsu.h.b11 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] @@ -647,29 +647,29 @@ pmhaccu.h a4, t1, t3 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] +pmulh.h.b0 a0, t5, a4 +// CHECK-ASM: pmulh.h.b0 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] +pmulhsu.h.b0 s0, a4, s2 +// CHECK-ASM: pmulhsu.h.b0 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] +pmhaccu.h.b0 s0, a0, t5 +// CHECK-ASM: pmhaccu.h.b0 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] +pmhaccsu.h.b0 t3, s0, a4 +// CHECK-ASM: pmhaccsu.h.b0 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] +pmulh.h.b1 a0, a4, s2 +// CHECK-ASM: pmulh.h.b1 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] +pmulhsu.h.b1 t5, t3, t1 +// CHECK-ASM: pmulhsu.h.b1 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] +pmhacc.h.b1 t1, t5, a2 +// CHECK-ASM: pmhacc.h.b1 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] +pmhaccsu.h.b1 a2, a0, a4 +// CHECK-ASM: pmhaccsu.h.b1 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] @@ -785,20 +785,20 @@ pli.db a2, 0x1 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] +pwslli.bs t3, t1, s0 +// CHECK-ASM: pwslli.bs 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] +pwsll.hs s0, a4, t1 +// CHECK-ASM: pwsll.hs 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.bs s0, s0, s0 +// CHECK-ASM: pwsla.bs 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] +pwsla.hs a4, a2, t5 +// CHECK-ASM: pwsla.hs a4, a2, t5 # encoding: [0x1b,0x2e,0xe6,0x4b] wsla s0, a0, s2 // CHECK-ASM: wsla s0, a0, s2 # encoding: [0x1b,0x28,0x25,0x4f] @@ -974,17 +974,17 @@ pmqrwacc.h a4, t3, a4 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.dhs s0, t3, a0 +// CHECK-ASM: predsum.dhs 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] +predsum.dbs a2, s0, t3 +// CHECK-ASM: predsum.dbs 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.dhs a2, a2, t3 +// CHECK-ASM: predsumu.dhs 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] +predsumu.dbs a2, a0, s0 +// CHECK-ASM: predsumu.dbs a2, a0, s0 # encoding: [0x1b,0x46,0x8a,0x3c] pnsrli.b a2, a0 // CHECK-ASM: pnsrli.b a2, a0 # encoding: [0x1b,0xc6,0x0a,0x01] @@ -1049,65 +1049,65 @@ pnclipri.h s2, t5 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.bs t3, s0, a4 +// CHECK-ASM: pnsrl.bs 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] +pnsrl.hs a2, t1, a4 +// CHECK-ASM: pnsrl.hs 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.bs a4, t5, a2 +// CHECK-ASM: pnclipu.bs 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] +pnclipu.hs t1, a2, a4 +// CHECK-ASM: pnclipu.hs 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.bs t5, s2, s2 +// CHECK-ASM: pnclipru.bs 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] +pnclipru.hs t5, s2, a0 +// CHECK-ASM: pnclipru.hs 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.bs a4, t1, a4 +// CHECK-ASM: pnsra.bs 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] +pnsra.hs s0, s2, t3 +// CHECK-ASM: pnsra.hs 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.bs a2, s0, a4 +// CHECK-ASM: pnsrar.bs 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] +pnsrar.hs s0, a4, a0 +// CHECK-ASM: pnsrar.hs 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.bs t1, t5, t3 +// CHECK-ASM: pnclip.bs 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] +pnclip.hs a0, a2, a0 +// CHECK-ASM: pnclip.hs 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.bs t1, a2, a0 +// CHECK-ASM: pnclipr.bs 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] +pnclipr.hs a4, s2, t3 +// CHECK-ASM: pnclipr.hs a4, s2, t3 # encoding: [0x1b,0xc7,0xc2,0x7b] nclipr t1, t5, a2 // CHECK-ASM: nclipr t1, t5, a2 # encoding: [0x1b,0xc3,0xce,0x7e] @@ -1127,14 +1127,14 @@ psslai.dh t1, a4 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] +psext.dh.b t1, t5 +// CHECK-ASM: psext.dh.b t1, t5 # encoding: [0x1b,0x26,0x4e,0x60] -psextb.dw t5, t5 -// CHECK-ASM: psextb.dw t5, t5 # encoding: [0x1b,0x2e,0x4e,0x62] +psext.dw.b t5, t5 +// CHECK-ASM: psext.dw.b t5, t5 # encoding: [0x1b,0x2e,0x4e,0x62] -psextw.dw s0, t1 -// CHECK-ASM: psextw.dw s0, t1 # encoding: [0x1b,0x28,0x56,0x62] +psext.dw.h s0, t1 +// CHECK-ASM: psext.dw.h s0, t1 # encoding: [0x1b,0x28,0x56,0x62] psabs.dh s0, s2 // CHECK-ASM: psabs.dh s0, s2 # encoding: [0x1b,0x28,0x72,0x60] @@ -1142,35 +1142,35 @@ psabs.dh s0, s2 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.dhs s2, t3, a4 +// CHECK-ASM: psll.dhs 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.dws a2, t1, t3 +// CHECK-ASM: psll.dws 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] +psll.dbs a0, a4, a2 +// CHECK-ASM: psll.dbs 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.dhs t1, a4, s2 +// CHECK-ASM: padd.dhs 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.dws a4, a4, t3 +// CHECK-ASM: padd.dws 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] +padd.dbs a2, a4, t3 +// CHECK-ASM: padd.dbs 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.dhs a0, s0, s2 +// CHECK-ASM: pssha.dhs 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] +pssha.dws a0, t1, s2 +// CHECK-ASM: pssha.dws 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.dhs a2, a4, t3 +// CHECK-ASM: psshar.dhs 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] +psshar.dws s0, t3, s0 +// CHECK-ASM: psshar.dws s0, t3, s0 # encoding: [0x1b,0x68,0x8c,0x7a] psrli.db t5, a2 // CHECK-ASM: psrli.db t5, a2 # encoding: [0x1b,0xce,0x8c,0x00] @@ -1208,23 +1208,23 @@ psati.dh s2, s2 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.dhs a0, t1, t5 +// CHECK-ASM: psrl.dhs 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.dws s0, s2, t1 +// CHECK-ASM: psrl.dws 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] +psrl.dbs a0, s0, t5 +// CHECK-ASM: psrl.dbs 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.dhs a4, t3, t1 +// CHECK-ASM: psra.dhs 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.dws a2, s2, t1 +// CHECK-ASM: psra.dws 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] +psra.dbs s0, t1, t5 +// CHECK-ASM: psra.dbs 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] diff --git a/llvm/test/MC/RISCV/rv64p-valid.s b/llvm/test/MC/RISCV/rv64p-valid.s index b4200e1cfb013..bc650a79ab1c1 100644 --- a/llvm/test/MC/RISCV/rv64p-valid.s +++ b/llvm/test/MC/RISCV/rv64p-valid.s @@ -1,4 +1,4 @@ -// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --llvm-mc-binary ./llvm-mc --tool ./llvm-objdump --version 5 +// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --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 @@ -76,14 +76,14 @@ pli.w a5, 0x5 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] +psext.h.b t3, a2 +// CHECK-ASM: psext.h.b t3, a2 # encoding: [0x1b,0x2e,0x46,0xe0] -psextb.w a2, s0 -// CHECK-ASM: psextb.w a2, s0 # encoding: [0x1b,0x26,0x44,0xe2] +psext.w.b a2, s0 +// CHECK-ASM: psext.w.b a2, s0 # encoding: [0x1b,0x26,0x44,0xe2] -psexth.w t1, t3 -// CHECK-ASM: psexth.w t1, t3 # encoding: [0x1b,0x23,0x5e,0xe2] +psext.w.h t1, t3 +// CHECK-ASM: psext.w.h t1, t3 # encoding: [0x1b,0x23,0x5e,0xe2] psabs.h t1, t5 // CHECK-ASM: psabs.h t1, t5 # encoding: [0x1b,0x23,0x7f,0xe0] @@ -97,35 +97,35 @@ plui.h s2, 0x4 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.hs s0, a2, s2 +// CHECK-ASM: psll.hs 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] +psll.bs a0, t3, t5 +// CHECK-ASM: psll.bs 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.hs t1, a2, s0 +// CHECK-ASM: padd.hs 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] +padd.bs t3, t1, t3 +// CHECK-ASM: padd.bs 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] +pssha.hs s0, t1, a2 +// CHECK-ASM: pssha.hs 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] +psshar.hs s2, t5, t3 +// CHECK-ASM: psshar.hs 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] +psll.ws s0, t1, a0 +// CHECK-ASM: psll.ws 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] +padd.ws s2, a2, a0 +// CHECK-ASM: padd.ws 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] +pssha.ws a4, a2, t1 +// CHECK-ASM: pssha.ws 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] +psshar.ws a2, a0, a4 +// CHECK-ASM: psshar.ws a2, a0, a4 # encoding: [0x1b,0x26,0xe5,0xfa] sha a0, t5, t5 // CHECK-ASM: sha a0, t5, t5 # encoding: [0x1b,0x25,0xef,0xef] @@ -163,41 +163,41 @@ pusati.w t3, a4 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.hs a2, t3, t3 +// CHECK-ASM: psrl.hs 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] +psrl.bs s0, t1, s0 +// CHECK-ASM: psrl.bs 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.hs t5, a0, a2 +// CHECK-ASM: predsum.hs 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] +predsum.bs t5, a4, s2 +// CHECK-ASM: predsum.bs 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.hs a2, s2, a0 +// CHECK-ASM: predsumu.hs 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] +predsumu.bs s2, s0, t1 +// CHECK-ASM: predsumu.bs 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.hs a0, t3, s2 +// CHECK-ASM: psra.hs 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] +psra.bs a4, t5, a4 +// CHECK-ASM: psra.bs 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] +psrl.ws t3, t1, a2 +// CHECK-ASM: psrl.ws 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] +predsum.ws s2, a2, t5 +// CHECK-ASM: predsum.ws 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] +predsumu.ws s2, a0, a2 +// CHECK-ASM: predsumu.ws 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] +psra.ws t5, a0, t5 +// CHECK-ASM: psra.ws 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] @@ -304,8 +304,8 @@ pasubu.w a0, t3, a4 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] +pmul.h.b01 a2, a4, a2 +// CHECK-ASM: pmul.h.b01 a2, a4, a2 # encoding: [0x3b,0x16,0xc7,0x90] mvm s0, t1, a2 // CHECK-ASM: mvm s0, t1, a2 # encoding: [0x3b,0x14,0xc3,0xa8] @@ -319,8 +319,8 @@ merge a4, a2, a2 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] +pmulu.h.b01 s2, a4, a0 +// CHECK-ASM: pmulu.h.b01 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] @@ -328,26 +328,26 @@ pdifsumu.b t3, t5, t3 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] +pmul.w.h01 s2, t5, t3 +// CHECK-ASM: pmul.w.h01 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] +pmacc.w.h01 t1, t1, a0 +// CHECK-ASM: pmacc.w.h01 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] +pmulu.w.h01 t1, a4, a2 +// CHECK-ASM: pmulu.w.h01 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] +pmaccu.w.h01 t5, t5, a4 +// CHECK-ASM: pmaccu.w.h01 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] @@ -388,92 +388,92 @@ zip8hp t5, a0, a2 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.b00 a4, a4, s2 +// CHECK-ASM: pmul.h.b00 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] +pmul.h.b11 t1, s2, s0 +// CHECK-ASM: pmul.h.b11 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.b00 a4, a2, a0 +// CHECK-ASM: pmulu.h.b00 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] +pmulu.h.b11 a4, s0, a4 +// CHECK-ASM: pmulu.h.b11 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.b00 a2, s0, a4 +// CHECK-ASM: pmulsu.h.b00 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] +pmulsu.h.b11 t3, t1, a4 +// CHECK-ASM: pmulsu.h.b11 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] +pmul.w.h00 s2, t1, a2 +// CHECK-ASM: pmul.w.h00 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] +pmacc.w.h00 s2, t5, a2 +// CHECK-ASM: pmacc.w.h00 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] +pmul.w.h11 s0, a4, s0 +// CHECK-ASM: pmul.w.h11 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] +pmacc.w.h11 a4, a4, t1 +// CHECK-ASM: pmacc.w.h11 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] +pmulu.w.h00 a2, t3, t1 +// CHECK-ASM: pmulu.w.h00 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] +pmaccu.w.h00 t3, t3, t5 +// CHECK-ASM: pmaccu.w.h00 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] +pmulu.w.h11 s0, t5, t5 +// CHECK-ASM: pmulu.w.h11 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] +pmaccu.w.h11 a0, s0, t5 +// CHECK-ASM: pmaccu.w.h11 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] +pmulsu.w.h00 t5, t5, t5 +// CHECK-ASM: pmulsu.w.h00 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] +pmaccsu.w.h00 a4, a0, t1 +// CHECK-ASM: pmaccsu.w.h00 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] +pmulsu.w.h11 t1, t3, s2 +// CHECK-ASM: pmulsu.w.h11 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] +pmaccsu.w.h11 a0, a2, t3 +// CHECK-ASM: pmaccsu.w.h11 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] @@ -649,14 +649,14 @@ pm2addasu.w a0, a2, a0 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] +pmqacc.w.h01 t5, t1, a4 +// CHECK-ASM: pmqacc.w.h01 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] +pmqracc.w.h01 a4, t1, s2 +// CHECK-ASM: pmqracc.w.h01 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] @@ -778,29 +778,29 @@ pmhaccu.h t3, a0, t3 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] +pmulh.h.b0 t1, a0, a0 +// CHECK-ASM: pmulh.h.b0 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] +pmulhsu.h.b0 t3, s0, a4 +// CHECK-ASM: pmulhsu.h.b0 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] +pmhaccu.h.b0 t1, a0, a4 +// CHECK-ASM: pmhaccu.h.b0 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] +pmhaccsu.h.b0 s2, t5, t3 +// CHECK-ASM: pmhaccsu.h.b0 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] +pmulh.h.b1 a0, s0, a2 +// CHECK-ASM: pmulh.h.b1 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] +pmulhsu.h.b1 t1, t3, t3 +// CHECK-ASM: pmulhsu.h.b1 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] +pmhacc.h.b1 t3, t5, s2 +// CHECK-ASM: pmhacc.h.b1 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] +pmhaccsu.h.b1 t5, t5, t1 +// CHECK-ASM: pmhaccsu.h.b1 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] @@ -844,29 +844,29 @@ pmhaccu.w a0, s0, a0 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] +pmulh.w.h0 t5, s0, t5 +// CHECK-ASM: pmulh.w.h0 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] +pmulhsu.w.h0 a2, t3, a2 +// CHECK-ASM: pmulhsu.w.h0 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] +pmhacc.w.h0 a2, a0, t1 +// CHECK-ASM: pmhacc.w.h0 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] +pmhaccsu.w.h0 t1, a4, t1 +// CHECK-ASM: pmhaccsu.w.h0 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] +pmulh.w.h1 t1, a0, t3 +// CHECK-ASM: pmulh.w.h1 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] +pmulhsu.w.h1 s2, t3, a4 +// CHECK-ASM: pmulhsu.w.h1 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] +pmhacc.w.h1 s0, t5, a2 +// CHECK-ASM: pmhacc.w.h1 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] +pmhaccsu.w.h1 a0, a0, a0 +// CHECK-ASM: pmhaccsu.w.h1 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] @@ -886,26 +886,26 @@ pmulq.w a2, a2, t5 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] +pmqacc.w.h00 t5, a4, t1 +// CHECK-ASM: pmqacc.w.h00 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] +pmqracc.w.h00 t1, a2, t5 +// CHECK-ASM: pmqracc.w.h00 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] +pmqacc.w.h11 a2, a0, a0 +// CHECK-ASM: pmqacc.w.h11 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] +pmqracc.w.h11 s0, t1, t3 +// CHECK-ASM: pmqracc.w.h11 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] diff --git a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp index 27243baf2dc5a..46f1f37f1b73a 100644 --- a/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp +++ b/llvm/unittests/TargetParser/RISCVISAInfoTest.cpp @@ -1105,7 +1105,7 @@ R"(All available -march extensions for RISC-V xwchc 2.2 Experimental extensions - p 0.12 + p 0.14 zicfilp 1.0 This is a long dummy description zicfiss 1.0 zalasr 0.1 From f84ec86ca19d3bb9d38c7938de69971d865a7fd7 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 14 Feb 2025 19:02:42 +1100 Subject: [PATCH 08/17] remove extra name --- llvm/docs/RISCVUsage.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/docs/RISCVUsage.rst b/llvm/docs/RISCVUsage.rst index 8522f690ab3f6..93b65c7dacf00 100644 --- a/llvm/docs/RISCVUsage.rst +++ b/llvm/docs/RISCVUsage.rst @@ -335,7 +335,7 @@ The primary goal of experimental support is to assist in the process of ratifica ``experimental-svukte`` LLVM implements the `0.3 draft specification `__. -``experimental-p``, ``experimental-p`` +``experimental-p`` LLVM implements the `014 draft specification `__. 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`. From 70412f8c41d6d31c99fe996cd64fc3b3e9c828c0 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 14 Feb 2025 23:18:46 +1100 Subject: [PATCH 09/17] add RVPGPRPairRV32 to encode GPR pairs correctly with 4-bit fields. Fix encoding problems, fix indentation mismatch. --- .../RISCV/Disassembler/RISCVDisassembler.cpp | 10 + .../RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp | 15 + llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 90 +- llvm/test/MC/RISCV/rv32p-valid.s | 1989 +++++++++-------- llvm/test/MC/RISCV/rv64p-valid.s | 1234 +++++----- 5 files changed, 1678 insertions(+), 1660 deletions(-) diff --git a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp index 971ef90c63327..339c5f82d1388 100644 --- a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp +++ b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp @@ -220,6 +220,13 @@ static DecodeStatus DecodeGPRPairRegisterClass(MCInst &Inst, uint32_t RegNo, return MCDisassembler::Success; } +static DecodeStatus decodeRVPGPRPair(MCInst &Inst, uint32_t RegNo, + uint64_t Address, + const MCDisassembler *Decoder) { + RegNo = RegNo << 1; + return DecodeGPRPairRegisterClass(Inst, RegNo, Address, Decoder); +} + static DecodeStatus DecodeSR07RegisterClass(MCInst &Inst, uint32_t RegNo, uint64_t Address, const void *Decoder) { @@ -605,6 +612,9 @@ DecodeStatus RISCVDisassembler::getInstruction32(MCInst &MI, uint64_t &Size, uint32_t Insn = support::endian::read32le(Bytes.data()); + TRY_TO_DECODE_AND_ADD_SP(!STI.hasFeature(RISCV::Feature64Bit), + DecoderTableRISCV32Only_32, + "RISCV32Only_32 table (32-bit Instruction)"); TRY_TO_DECODE(STI.hasFeature(RISCV::FeatureStdExtZdinx) && !STI.hasFeature(RISCV::Feature64Bit), DecoderTableRV32Zdinx32, diff --git a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp index 06d9cce48692a..dcf4ecec38f78 100644 --- a/llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp +++ b/llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp @@ -99,6 +99,10 @@ class RISCVMCCodeEmitter : public MCCodeEmitter { unsigned getRegReg(const MCInst &MI, unsigned OpNo, SmallVectorImpl &Fixups, const MCSubtargetInfo &STI) const; + + unsigned getRVPGPRPair(const MCInst &MI, unsigned OpNo, + SmallVectorImpl &Fixups, + const MCSubtargetInfo &STI) const; }; } // end anonymous namespace @@ -582,4 +586,15 @@ unsigned RISCVMCCodeEmitter::getRegReg(const MCInst &MI, unsigned OpNo, return Op | Op1 << 5; } +unsigned RISCVMCCodeEmitter::getRVPGPRPair(const MCInst &MI, unsigned OpNo, + SmallVectorImpl &Fixups, + const MCSubtargetInfo &STI) const { + const MCOperand &MO = MI.getOperand(OpNo); + assert(MO.isReg() && "Expected a register."); + + unsigned Op = Ctx.getRegisterInfo()->getEncodingValue(MO.getReg()); + + return Op >> 1; +} + #include "RISCVGenMCCodeEmitter.inc" diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 3f678dd10279b..5ed25c629ebc0 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -18,6 +18,12 @@ // Operand and SDNode transformation definitions. //===----------------------------------------------------------------------===// +def RVPGPRPairRV32 : RegisterOperand { + let ParserMatchClass = GPRPairRV32Operand; + let EncoderMethod = "getRVPGPRPair"; + let DecoderMethod = "decodeRVPGPRPair"; +} + def simm10 : RISCVSImmLeafOp<10> { let MCOperandPredicate = [{ int64_t Imm; @@ -38,7 +44,7 @@ class RVPUnary funct5, bits<7> wuimm, : RVInstIBase { let Inst{31-27} = funct5; - let Inst{26-20} = wuimm; + let Inst{26-20} = wuimm; } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in @@ -72,8 +78,8 @@ class RVPUnaryWUF w, bits<5> uf, string opcodestr> let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPUnaryWUFRs1pRdp w, bits<5> uf, string opcodestr> - : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPRPairRV32:$rdp), - (ins GPRPairRV32:$rs1p), opcodestr, "$rdp, $rs1p"> { + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p), opcodestr, "$rdp, $rs1p"> { bits<4> rs1p; bits<4> rdp; @@ -101,7 +107,7 @@ class RVPUnary1F0 f, bits<7> wuimm, string opcodestr> (ins GPR:$rs1), "$rd, $rs1">; class RVPUnary0F0Rdp f, bits<7> wuimm, string opcodestr> - : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp), + : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b010, (outs RVPGPRPairRV32:$rdp), (ins GPR:$rs1), "$rdp, $rs1"> { bits<4> rdp; @@ -111,7 +117,7 @@ class RVPUnary0F0Rdp f, bits<7> wuimm, string opcodestr> class RVPUnary0F0Rs1p f, bits<7> wuimm, string opcodestr> : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd), - (ins GPRPairRV32:$rs1p), "$rd, $rs1p"> { + (ins RVPGPRPairRV32:$rs1p), "$rd, $rs1p"> { bits<4> rs1p; let Inst{19-16} = rs1p; @@ -120,8 +126,8 @@ class RVPUnary0F0Rs1p f, bits<7> wuimm, string opcodestr> class RVPUnary0F0Rs1pRdp f, bits<7> wuimm, string opcodestr, bit aft = 0b0> - : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPRPairRV32:$rdp), - (ins GPRPairRV32:$rs1p), "$rdp, $rs1p"> { + : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b110, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p), "$rdp, $rs1p"> { bits<4> rs1p; bits<4> rdp; @@ -153,7 +159,7 @@ class RVPBinary1F0W f, bits<2> w, string opcodestr, bits<3> funct3, class RVPBinary0F1WRdp f, bits<2> w, string opcodestr, RISCVOpcode Opcode = OPC_OP_IMM_32> - : RVPBinaryFW<0, f, 1, w, opcodestr, 0b010, Opcode, (outs GPRPairRV32:$rdp), + : RVPBinaryFW<0, f, 1, w, opcodestr, 0b010, Opcode, (outs RVPGPRPairRV32:$rdp), (ins GPR:$rs1, GPR:$rs2), "$rdp, $rs1, $rs2"> { bits<4> rdp; @@ -164,7 +170,7 @@ class RVPBinary0F1WRdp f, bits<2> w, string opcodestr, class RVPBinary0F1WRs1p 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"> { + (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rd, $rs1p, $rs2"> { bits<4> rs1p; let Inst{19-16} = rs1p; @@ -173,8 +179,8 @@ class RVPBinary0F1WRs1p f, bits<2> w, string opcodestr, class RVPBinary0F1WRs1pRdp 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"> { + : RVPBinaryFW<0, f, 1, w, opcodestr, 0b110, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rdp, $rs1p, $rs2"> { bits<4> rs1p; bits<4> rdp; @@ -187,8 +193,8 @@ class RVPBinary0F1WRs1pRdp f, bits<2> w, string opcodestr, let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPBinary1FWRs2pRs1pRdp 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), + : RVInstRBase<0b110, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, RVPGPRPairRV32:$rs2p), opcodestr, "$rdp, $rs1p, $rs2p"> { bits<4> rs1p; bits<4> rs2p; @@ -208,8 +214,8 @@ class RVPBinary1FWRs2pRs1pRdp f, bits<2> w, string opcodestr, class RVPBinary1F0WRs2pRs1pRdp 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"> { + : RVPBinaryFW<1, f, 0, w, opcodestr, 0b110, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, RVPGPRPairRV32:$rs2p), "$rdp, $rs1p, $rs2p"> { bits<4> rs1p; bits<4> rs2p; bits<4> rdp; @@ -237,34 +243,14 @@ class RVPBinary1LongFW f, bits<2> w, bits<3> funct3, string opcodestr> (ins GPR:$rs1, GPR:$rs2), "$rd, $rs1, $rs2">; class RVPBinary0LongFW f, bits<2> w, string opcodestr> - : RVPBinaryLongFW<0, f, w, opcodestr, 0b010, (outs GPRPairRV32:$rdp), - (ins GPR:$rs1, GPRPairRV32:$rs2), "$rdp, $rs1, $rs2"> { + : RVPBinaryLongFW<0, f, w, opcodestr, 0b010, (outs RVPGPRPairRV32:$rdp), + (ins GPR:$rs1, RVPGPRPairRV32:$rs2), "$rdp, $rs1, $rs2"> { bits<4> rdp; let Inst{11-8} = rdp; let Inst{7} = 0b1; } -multiclass RVPUnaryBH funct5, string opcodestr> { - def NAME # _B : RVPUnary; - def NAME # _H : RVPUnary; -} - -multiclass RVPUnaryHNonPacked funct5, string opcodestr> { - def P # NAME # _H : RVPUnary; - def NAME: RVPUnary; -} - -multiclass RVPUnaryBHW funct5, string opcodestr> { - defm NAME : RVPUnaryBH; - def NAME # _W: RVPUnary; -} - -multiclass RVPUnaryHW funct5, string opcodestr> { - def NAME # _H : RVPUnary; - def NAME # _W: RVPUnary; -} - //===----------------------------------------------------------------------===// // Instructions //===----------------------------------------------------------------------===// @@ -273,10 +259,8 @@ 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 { +let 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">; @@ -286,15 +270,17 @@ 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 Predicates = [HasStdExtP] in { +def PSLLI_B : RVPUnary<0b10000, 0b0001000, 0b010, OPC_OP_IMM_32, "pslli.b">; +def PSLLI_H : RVPUnary<0b10000, 0b0010000, 0b010, OPC_OP_IMM_32, "pslli.h">; +def PSSLAI_H : RVPUnary<0b11010, 0b0010000, 0b010, OPC_OP_IMM_32, "psslai.h">; +} // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", - Predicates = [HasStdExtP, IsRV32] in { - defm PSLLI_RV32 : RVPUnaryBH<0b10000, "pslli">; - defm SSLAI_RV32 : RVPUnaryHNonPacked<0b11010, "sslai">; -} // Predicates = [HasStdExtP, IsRV32] - + Predicates = [HasStdExtP, IsRV32] in +def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { - defm PSLLI_RV64 : RVPUnaryBHW<0b10000, "pslli">; - defm PSSLAI_RV64 : RVPUnaryHW<0b01010, "psslai">; +def PSLLI_W : RVPUnary<0b10000, 0b0100000, 0b010, OPC_OP_IMM_32, "pslli.w">; +def PSSLAI_W : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "psslai.w">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in @@ -622,8 +608,8 @@ def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, 0b101, "pm4addasu.b">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { -def MQACC_H01 : RVPBinary1LongFW<0b0111, 0b00, 0b101, "mqacc.h01">; -def MQRACC_H01 : RVPBinary1LongFW<0b0111, 0b10, 0b101, "mqracc.h01">; +def MQACC_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "mqacc.h01">; +def MQRACC_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "mqracc.h01">; } // Predicates = [HasStdExtP, IsRV32] let Predicates = [HasStdExtP, IsRV64] in { @@ -809,9 +795,9 @@ 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, "pli.dh", GPRPairRV32>; -def PLI_DB : RVPUnaryImm8<0b00110100, "pli.db", GPRPairRV32>; -def PLUI_DH : RVPUnaryImm9<0b0111000, "plui.dh", GPRPairRV32>; +def PLI_DH : RVPUnaryImm9<0b0011000, "pli.dh", RVPGPRPairRV32>; +def PLI_DB : RVPUnaryImm8<0b00110100, "pli.db", RVPGPRPairRV32>; +def PLUI_DH : RVPUnaryImm9<0b0111000, "plui.dh", RVPGPRPairRV32>; def PWSLLI_BS : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.bs">; diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s index 70d33102cbf18..be8692727268f 100644 --- a/llvm/test/MC/RISCV/rv32p-valid.s +++ b/llvm/test/MC/RISCV/rv32p-valid.s @@ -1,1440 +1,1443 @@ -// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --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 +# RUN: | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s +# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=+experimental-p < %s \ +# RUN: | llvm-objdump --mattr=+experimental-p -M no-aliases -d -r --no-print-imm-hex - \ +# RUN: | FileCheck --check-prefix=CHECK-ASM-AND-OBJ %s +# CHECK-ASM-AND-OBJ: clz a0, a1 +# CHECK-ASM: encoding: [0x13,0x95,0x05,0x60] clz a0, a1 -// CHECK-ASM: clz a0, a1 # encoding: [0x13,0x95,0x05,0x60] - +# CHECK-ASM-AND-OBJ: cls a1, a2 +# CHECK-ASM: encoding: [0x93,0x15,0x36,0x60] cls a1, a2 -// CHECK-ASM: cls a1, a2 # encoding: [0x93,0x15,0x36,0x60] - +# CHECK-ASM-AND-OBJ: sext.b a2, a3 +# CHECK-ASM: encoding: [0x13,0x96,0x46,0x60] sext.b a2, a3 -// CHECK-ASM: sext.b a2, a3 # encoding: [0x13,0x96,0x46,0x60] - +# CHECK-ASM-AND-OBJ: sext.h t0, t1 +# CHECK-ASM: encoding: [0x93,0x12,0x53,0x60] sext.h t0, t1 -// CHECK-ASM: sext.h t0, t1 # encoding: [0x93,0x12,0x53,0x60] - +# CHECK-ASM-AND-OBJ: abs a4, a5 +# CHECK-ASM: encoding: [0x13,0x97,0x77,0x60] abs a4, a5 -// CHECK-ASM: abs a4, a5 # encoding: [0x13,0x97,0x77,0x60] - +# CHECK-ASM-AND-OBJ: rev8 s0, s1 +# CHECK-ASM: encoding: [0x13,0xd4,0x84,0x69] rev8 s0, s1 -// CHECK-ASM: rev8 s0, s1 # encoding: [0x13,0xd4,0x84,0x69] - +# CHECK-ASM-AND-OBJ: rev s2, s3 +# CHECK-ASM: encoding: [0x13,0xd9,0xf9,0x69] rev s2, s3 -// CHECK-ASM: rev s2, s3 # encoding: [0x13,0xd9,0xf9,0x69] - +# CHECK-ASM-AND-OBJ: sh1add a0, a1, a2 +# CHECK-ASM: encoding: [0x33,0xa5,0xc5,0x20] sh1add a0, a1, a2 -// CHECK-ASM: sh1add a0, a1, a2 # encoding: [0x33,0xa5,0xc5,0x20] - +# CHECK-ASM-AND-OBJ: pack s0, s1, s2 +# CHECK-ASM: encoding: [0x33,0xc4,0x24,0x09] pack s0, s1, s2 -// CHECK-ASM: pack s0, s1, s2 # encoding: [0x33,0xc4,0x24,0x09] - +# CHECK-ASM-AND-OBJ: min t0, t1, t2 +# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x0a] 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] - +# CHECK-ASM-AND-OBJ: minu ra, sp, gp +# CHECK-ASM: encoding: [0xb3,0x50,0x31,0x0a] +minu ra, sp, gp +# CHECK-ASM-AND-OBJ: max t3, t4, t5 +# CHECK-ASM: encoding: [0x33,0xee,0xee,0x0b] max t3, t4, t5 -// CHECK-ASM: max t3, t4, t5 # encoding: [0x33,0xee,0xee,0x0b] - +# CHECK-ASM-AND-OBJ: maxu a4, a5, a6 +# CHECK-ASM: encoding: [0x33,0xf7,0x07,0x0b] maxu a4, a5, a6 -// CHECK-ASM: maxu a4, a5, a6 # encoding: [0x33,0xf7,0x07,0x0b] - +# CHECK-ASM-AND-OBJ: pslli.b a6, a7 +# CHECK-ASM: encoding: [0x1b,0xa8,0x88,0x80] 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] - +# CHECK-ASM-AND-OBJ: pslli.h ra, sp +# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x81] +pslli.h ra, sp +# CHECK-ASM-AND-OBJ: psslai.h t0, t1 +# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] psslai.h t0, t1 -// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0xd1] - +# CHECK-ASM-AND-OBJ: sslai a4, a5 +# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] 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] - +# CHECK-ASM-AND-OBJ: pli.h a5, 16 +# CHECK-ASM: encoding: [0x9b,0x27,0x08,0xb0] +pli.h a5, 16 +# CHECK-ASM-AND-OBJ: pli.b a6, 16 +# CHECK-ASM: encoding: [0x1b,0x28,0x10,0xb4] +pli.b a6, 16 +# CHECK-ASM-AND-OBJ: psext.h.b a7, a0 +# CHECK-ASM: encoding: [0x9b,0x28,0x45,0xe0] psext.h.b a7, a0 -// CHECK-ASM: psext.h.b a7, a0 # encoding: [0x9b,0x28,0x45,0xe0] - +# CHECK-ASM-AND-OBJ: psabs.h a1, a2 +# CHECK-ASM: encoding: [0x9b,0x25,0x76,0xe0] psabs.h a1, a2 -// CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0] - +# CHECK-ASM-AND-OBJ: psabs.b t0, t1 +# CHECK-ASM: encoding: [0x9b,0x22,0x73,0xe2] 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] - +# CHECK-ASM-AND-OBJ: plui.h gp, 32 +# CHECK-ASM: encoding: [0x9b,0x21,0x10,0xf0] +plui.h gp, 32 +# CHECK-ASM-AND-OBJ: psll.hs a0, a1, a2 +# CHECK-ASM: encoding: [0x1b,0xa5,0xc5,0x88] psll.hs a0, a1, a2 -// CHECK-ASM: psll.hs a0, a1, a2 # encoding: [0x1b,0xa5,0xc5,0x88] - +# CHECK-ASM-AND-OBJ: psll.bs a3, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0x8c] psll.bs a3, a4, a5 -// CHECK-ASM: psll.bs a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0x8c] - +# CHECK-ASM-AND-OBJ: padd.hs t0, t1, t2 +# CHECK-ASM: encoding: [0x9b,0x22,0x73,0x98] padd.hs t0, t1, t2 -// CHECK-ASM: padd.hs t0, t1, t2 # encoding: [0x9b,0x22,0x73,0x98] - -padd.bs x1, a1, a2 -// CHECK-ASM: padd.bs ra, a1, a2 # encoding: [0x9b,0xa0,0xc5,0x9c] - +# CHECK-ASM-AND-OBJ: padd.bs ra, a1, a2 +# CHECK-ASM: encoding: [0x9b,0xa0,0xc5,0x9c] +padd.bs ra, a1, a2 +# CHECK-ASM-AND-OBJ: pssha.hs a3, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0xe8] pssha.hs a3, a4, a5 -// CHECK-ASM: pssha.hs a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0xe8] - -ssha x3, a4, a5 -// CHECK-ASM: ssha gp, a4, a5 # encoding: [0x9b,0x21,0xf7,0xea] - +# CHECK-ASM-AND-OBJ: ssha gp, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x21,0xf7,0xea] +ssha gp, a4, a5 +# CHECK-ASM-AND-OBJ: psshar.hs a6, a7, a0 +# CHECK-ASM: encoding: [0x1b,0xa8,0xa8,0xf8] psshar.hs a6, a7, a0 -// CHECK-ASM: psshar.hs a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8] - -sshar x6, a7, a0 -// CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa] - +# CHECK-ASM-AND-OBJ: sshar t1, a7, a0 +# CHECK-ASM: encoding: [0x1b,0xa3,0xa8,0xfa] +sshar t1, a7, a0 +# CHECK-ASM-AND-OBJ: psrli.b a1, a2 +# CHECK-ASM: encoding: [0x9b,0x45,0x86,0x80] psrli.b a1, a2 -// CHECK-ASM: psrli.b a1, a2 # encoding: [0x9b,0x45,0x86,0x80] - +# CHECK-ASM-AND-OBJ: psrli.h a0, a1 +# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0x81] psrli.h a0, a1 -// CHECK-ASM: psrli.h a0, a1 # encoding: [0x1b,0xc5,0x05,0x81] - +# CHECK-ASM-AND-OBJ: pusati.h a2, t1 +# CHECK-ASM: encoding: [0x1b,0x46,0x03,0xa1] pusati.h a2, t1 -// CHECK-ASM: pusati.h a2, t1 # encoding: [0x1b,0x46,0x03,0xa1] - +# CHECK-ASM-AND-OBJ: usati a3, t2 +# CHECK-ASM: encoding: [0x9b,0xc6,0x03,0xa2] usati a3, t2 -// CHECK-ASM: usati a3, t2 # encoding: [0x9b,0xc6,0x03,0xa2] - +# CHECK-ASM-AND-OBJ: psrai.b a4, a5 +# CHECK-ASM: encoding: [0x1b,0xc7,0x87,0xc0] psrai.b a4, a5 -// CHECK-ASM: psrai.b a4, a5 # encoding: [0x1b,0xc7,0x87,0xc0] - +# CHECK-ASM-AND-OBJ: psrai.h a6, a7 +# CHECK-ASM: encoding: [0x1b,0xc8,0x08,0xc1] psrai.h a6, a7 -// CHECK-ASM: psrai.h a6, a7 # encoding: [0x1b,0xc8,0x08,0xc1] - +# CHECK-ASM-AND-OBJ: psrari.h a0, a1 +# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0xd1] psrari.h a0, a1 -// CHECK-ASM: psrari.h a0, a1 # encoding: [0x1b,0xc5,0x05,0xd1] - +# CHECK-ASM-AND-OBJ: srari a2, a3 +# CHECK-ASM: encoding: [0x1b,0xc6,0x06,0xd2] srari a2, a3 -// CHECK-ASM: srari a2, a3 # encoding: [0x1b,0xc6,0x06,0xd2] - +# CHECK-ASM-AND-OBJ: psati.h a4, t0 +# CHECK-ASM: encoding: [0x1b,0xc7,0x02,0xe1] psati.h a4, t0 -// CHECK-ASM: psati.h a4, t0 # encoding: [0x1b,0xc7,0x02,0xe1] - +# CHECK-ASM-AND-OBJ: sati a5, t1 +# CHECK-ASM: encoding: [0x9b,0x47,0x03,0xe2] sati a5, t1 -// CHECK-ASM: sati a5, t1 # encoding: [0x9b,0x47,0x03,0xe2] - +# CHECK-ASM-AND-OBJ: psrl.hs a6, a7, a1 +# CHECK-ASM: encoding: [0x1b,0xc8,0xb8,0x88] psrl.hs a6, a7, a1 -// CHECK-ASM: psrl.hs a6, a7, a1 # encoding: [0x1b,0xc8,0xb8,0x88] - +# CHECK-ASM-AND-OBJ: psrl.bs a1, a2, a3 +# CHECK-ASM: encoding: [0x9b,0x45,0xd6,0x8c] psrl.bs a1, a2, a3 -// CHECK-ASM: psrl.bs a1, a2, a3 # encoding: [0x9b,0x45,0xd6,0x8c] - +# CHECK-ASM-AND-OBJ: predsum.hs a4, a5, a6 +# CHECK-ASM: encoding: [0x1b,0xc7,0x07,0x99] predsum.hs a4, a5, a6 -// CHECK-ASM: predsum.hs a4, a5, a6 # encoding: [0x1b,0xc7,0x07,0x99] - +# CHECK-ASM-AND-OBJ: predsum.bs a7, a1, a1 +# CHECK-ASM: encoding: [0x9b,0xc8,0xb5,0x9c] predsum.bs a7, a1, a1 -// CHECK-ASM: predsum.bs a7, a1, a1 # encoding: [0x9b,0xc8,0xb5,0x9c] - +# CHECK-ASM-AND-OBJ: predsumu.hs t0, t1, t2 +# CHECK-ASM: encoding: [0x9b,0x42,0x73,0xb8] predsumu.hs t0, t1, t2 -// CHECK-ASM: predsumu.hs t0, t1, t2 # encoding: [0x9b,0x42,0x73,0xb8] - +# CHECK-ASM-AND-OBJ: predsumu.bs t3, t4, t5 +# CHECK-ASM: encoding: [0x1b,0xce,0xee,0xbd] predsumu.bs t3, t4, t5 -// CHECK-ASM: predsumu.bs t3, t4, t5 # encoding: [0x1b,0xce,0xee,0xbd] - -psra.hs x1, a1, a2 -// CHECK-ASM: psra.hs ra, a1, a2 # encoding: [0x9b,0xc0,0xc5,0xc8] - -psra.bs x2, a2, a3 -// CHECK-ASM: psra.bs sp, a2, a3 # encoding: [0x1b,0x41,0xd6,0xcc] - +# CHECK-ASM-AND-OBJ: psra.hs ra, a1, a2 +# CHECK-ASM: encoding: [0x9b,0xc0,0xc5,0xc8] +psra.hs ra, a1, a2 +# CHECK-ASM-AND-OBJ: psra.bs sp, a2, a3 +# CHECK-ASM: encoding: [0x1b,0x41,0xd6,0xcc] +psra.bs sp, a2, a3 +# CHECK-ASM-AND-OBJ: psslai.h t0, t1 +# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] psslai.h t0, t1 -// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0xd1] - +# CHECK-ASM-AND-OBJ: sslai a4, a5 +# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] 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] - +# CHECK-ASM-AND-OBJ: pli.h a5, 16 +# CHECK-ASM: encoding: [0x9b,0x27,0x08,0xb0] +pli.h a5, 16 +# CHECK-ASM-AND-OBJ: pli.b a6, 16 +# CHECK-ASM: encoding: [0x1b,0x28,0x10,0xb4] +pli.b a6, 16 +# CHECK-ASM-AND-OBJ: psext.h.b a7, a0 +# CHECK-ASM: encoding: [0x9b,0x28,0x45,0xe0] psext.h.b a7, a0 -// CHECK-ASM: psext.h.b a7, a0 # encoding: [0x9b,0x28,0x45,0xe0] - +# CHECK-ASM-AND-OBJ: psabs.h a1, a2 +# CHECK-ASM: encoding: [0x9b,0x25,0x76,0xe0] psabs.h a1, a2 -// CHECK-ASM: psabs.h a1, a2 # encoding: [0x9b,0x25,0x76,0xe0] - +# CHECK-ASM-AND-OBJ: psabs.b t0, t1 +# CHECK-ASM: encoding: [0x9b,0x22,0x73,0xe2] 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] - +# CHECK-ASM-AND-OBJ: plui.h gp, 32 +# CHECK-ASM: encoding: [0x9b,0x21,0x10,0xf0] +plui.h gp, 32 +# CHECK-ASM-AND-OBJ: psll.hs a0, a1, a2 +# CHECK-ASM: encoding: [0x1b,0xa5,0xc5,0x88] psll.hs a0, a1, a2 -// CHECK-ASM: psll.hs a0, a1, a2 # encoding: [0x1b,0xa5,0xc5,0x88] - +# CHECK-ASM-AND-OBJ: psll.bs a3, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0x8c] psll.bs a3, a4, a5 -// CHECK-ASM: psll.bs a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0x8c] - +# CHECK-ASM-AND-OBJ: padd.hs t0, t1, t2 +# CHECK-ASM: encoding: [0x9b,0x22,0x73,0x98] padd.hs t0, t1, t2 -// CHECK-ASM: padd.hs t0, t1, t2 # encoding: [0x9b,0x22,0x73,0x98] - -padd.bs x1, a1, a2 -// CHECK-ASM: padd.bs ra, a1, a2 # encoding: [0x9b,0xa0,0xc5,0x9c] - +# CHECK-ASM-AND-OBJ: padd.bs ra, a1, a2 +# CHECK-ASM: encoding: [0x9b,0xa0,0xc5,0x9c] +padd.bs ra, a1, a2 +# CHECK-ASM-AND-OBJ: pssha.hs a3, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0xe8] pssha.hs a3, a4, a5 -// CHECK-ASM: pssha.hs a3, a4, a5 # encoding: [0x9b,0x26,0xf7,0xe8] - -ssha x3, a4, a5 -// CHECK-ASM: ssha gp, a4, a5 # encoding: [0x9b,0x21,0xf7,0xea] - +# CHECK-ASM-AND-OBJ: ssha gp, a4, a5 +# CHECK-ASM: encoding: [0x9b,0x21,0xf7,0xea] +ssha gp, a4, a5 +# CHECK-ASM-AND-OBJ: psshar.hs a6, a7, a0 +# CHECK-ASM: encoding: [0x1b,0xa8,0xa8,0xf8] psshar.hs a6, a7, a0 -// CHECK-ASM: psshar.hs a6, a7, a0 # encoding: [0x1b,0xa8,0xa8,0xf8] - -sshar x6, a7, a0 -// CHECK-ASM: sshar t1, a7, a0 # encoding: [0x1b,0xa3,0xa8,0xfa] - +# CHECK-ASM-AND-OBJ: sshar t1, a7, a0 +# CHECK-ASM: encoding: [0x1b,0xa3,0xa8,0xfa] +sshar t1, a7, a0 +# CHECK-ASM-AND-OBJ: psrli.b a1, a2 +# CHECK-ASM: encoding: [0x9b,0x45,0x86,0x80] psrli.b a1, a2 -// CHECK-ASM: psrli.b a1, a2 # encoding: [0x9b,0x45,0x86,0x80] - +# CHECK-ASM-AND-OBJ: psrli.h a0, a1 +# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0x81] psrli.h a0, a1 -// CHECK-ASM: psrli.h a0, a1 # encoding: [0x1b,0xc5,0x05,0x81] - +# CHECK-ASM-AND-OBJ: pusati.h a2, t1 +# CHECK-ASM: encoding: [0x1b,0x46,0x03,0xa1] pusati.h a2, t1 -// CHECK-ASM: pusati.h a2, t1 # encoding: [0x1b,0x46,0x03,0xa1] - +# CHECK-ASM-AND-OBJ: usati a3, t2 +# CHECK-ASM: encoding: [0x9b,0xc6,0x03,0xa2] usati a3, t2 -// CHECK-ASM: usati a3, t2 # encoding: [0x9b,0xc6,0x03,0xa2] - +# CHECK-ASM-AND-OBJ: psrai.b a4, a5 +# CHECK-ASM: encoding: [0x1b,0xc7,0x87,0xc0] psrai.b a4, a5 -// CHECK-ASM: psrai.b a4, a5 # encoding: [0x1b,0xc7,0x87,0xc0] - +# CHECK-ASM-AND-OBJ: psrai.h a6, a7 +# CHECK-ASM: encoding: [0x1b,0xc8,0x08,0xc1] psrai.h a6, a7 -// CHECK-ASM: psrai.h a6, a7 # encoding: [0x1b,0xc8,0x08,0xc1] - +# CHECK-ASM-AND-OBJ: psrari.h a0, a1 +# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0xd1] psrari.h a0, a1 -// CHECK-ASM: psrari.h a0, a1 # encoding: [0x1b,0xc5,0x05,0xd1] - +# CHECK-ASM-AND-OBJ: srari a2, a3 +# CHECK-ASM: encoding: [0x1b,0xc6,0x06,0xd2] srari a2, a3 -// CHECK-ASM: srari a2, a3 # encoding: [0x1b,0xc6,0x06,0xd2] - +# CHECK-ASM-AND-OBJ: psati.h a4, t0 +# CHECK-ASM: encoding: [0x1b,0xc7,0x02,0xe1] psati.h a4, t0 -// CHECK-ASM: psati.h a4, t0 # encoding: [0x1b,0xc7,0x02,0xe1] - +# CHECK-ASM-AND-OBJ: sati a5, t1 +# CHECK-ASM: encoding: [0x9b,0x47,0x03,0xe2] sati a5, t1 -// CHECK-ASM: sati a5, t1 # encoding: [0x9b,0x47,0x03,0xe2] - +# CHECK-ASM-AND-OBJ: psrl.hs a6, a7, a1 +# CHECK-ASM: encoding: [0x1b,0xc8,0xb8,0x88] psrl.hs a6, a7, a1 -// CHECK-ASM: psrl.hs a6, a7, a1 # encoding: [0x1b,0xc8,0xb8,0x88] - +# CHECK-ASM-AND-OBJ: psrl.bs a1, a2, a3 +# CHECK-ASM: encoding: [0x9b,0x45,0xd6,0x8c] psrl.bs a1, a2, a3 -// CHECK-ASM: psrl.bs a1, a2, a3 # encoding: [0x9b,0x45,0xd6,0x8c] - +# CHECK-ASM-AND-OBJ: predsum.hs a4, a5, a6 +# CHECK-ASM: encoding: [0x1b,0xc7,0x07,0x99] predsum.hs a4, a5, a6 -// CHECK-ASM: predsum.hs a4, a5, a6 # encoding: [0x1b,0xc7,0x07,0x99] - +# CHECK-ASM-AND-OBJ: predsum.bs a7, a1, a1 +# CHECK-ASM: encoding: [0x9b,0xc8,0xb5,0x9c] predsum.bs a7, a1, a1 -// CHECK-ASM: predsum.bs a7, a1, a1 # encoding: [0x9b,0xc8,0xb5,0x9c] - +# CHECK-ASM-AND-OBJ: predsumu.hs t0, t1, t2 +# CHECK-ASM: encoding: [0x9b,0x42,0x73,0xb8] predsumu.hs t0, t1, t2 -// CHECK-ASM: predsumu.hs t0, t1, t2 # encoding: [0x9b,0x42,0x73,0xb8] - +# CHECK-ASM-AND-OBJ: predsumu.bs t3, t4, t5 +# CHECK-ASM: encoding: [0x1b,0xce,0xee,0xbd] predsumu.bs t3, t4, t5 -// CHECK-ASM: predsumu.bs t3, t4, t5 # encoding: [0x1b,0xce,0xee,0xbd] - -psra.hs x1, a1, a2 -// CHECK-ASM: psra.hs ra, a1, a2 # encoding: [0x9b,0xc0,0xc5,0xc8] - -psra.bs x2, a2, a3 -// CHECK-ASM: psra.bs sp, a2, a3 # encoding: [0x1b,0x41,0xd6,0xcc] - +# CHECK-ASM-AND-OBJ: psra.hs ra, a1, a2 +# CHECK-ASM: encoding: [0x9b,0xc0,0xc5,0xc8] +psra.hs ra, a1, a2 +# CHECK-ASM-AND-OBJ: psra.bs sp, a2, a3 +# CHECK-ASM: encoding: [0x1b,0x41,0xd6,0xcc] +psra.bs sp, a2, a3 +# CHECK-ASM-AND-OBJ: padd.h t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0x80] 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] - +# CHECK-ASM-AND-OBJ: padd.b ra, a1, a2 +# CHECK-ASM: encoding: [0xbb,0x80,0xc5,0x84] +padd.b ra, a1, a2 +# CHECK-ASM-AND-OBJ: psadd.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0x91] 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] - +# CHECK-ASM-AND-OBJ: sadd t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0x92] +sadd t1, a7, a0 +# CHECK-ASM-AND-OBJ: psadd.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0x94] psadd.b t0, t1, t2 -// CHECK-ASM: psadd.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0x94] - +# CHECK-ASM-AND-OBJ: paadd.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0x99] 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] - +# CHECK-ASM-AND-OBJ: aadd t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0x9a] +aadd t1, a7, a0 +# CHECK-ASM-AND-OBJ: paadd.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0x9c] paadd.b t0, t1, t2 -// CHECK-ASM: paadd.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0x9c] - +# CHECK-ASM-AND-OBJ: psaddu.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xb1] 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] - +# CHECK-ASM-AND-OBJ: saddu t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xb2] +saddu t1, a7, a0 +# CHECK-ASM-AND-OBJ: psaddu.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xb4] psaddu.b t0, t1, t2 -// CHECK-ASM: psaddu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xb4] - +# CHECK-ASM-AND-OBJ: paaddu.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xb9] 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] - +# CHECK-ASM-AND-OBJ: aaddu t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xba] +aaddu t1, a7, a0 +# CHECK-ASM-AND-OBJ: paaddu.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xbc] paaddu.b t0, t1, t2 -// CHECK-ASM: paaddu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xbc] - +# CHECK-ASM-AND-OBJ: psub.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xc1] psub.h t3, t4, t5 -// CHECK-ASM: psub.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xc1] - +# CHECK-ASM-AND-OBJ: psub.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xc4] psub.b t0, t1, t2 -// CHECK-ASM: psub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xc4] - +# CHECK-ASM-AND-OBJ: pdif.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xc9] pdif.h t3, t4, t5 -// CHECK-ASM: pdif.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xc9] - +# CHECK-ASM-AND-OBJ: pdif.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xcc] pdif.b t0, t1, t2 -// CHECK-ASM: pdif.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xcc] - +# CHECK-ASM-AND-OBJ: pssub.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xd1] 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] - +# CHECK-ASM-AND-OBJ: ssub t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xd2] +ssub t1, a7, a0 +# CHECK-ASM-AND-OBJ: pssub.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xd4] pssub.b t0, t1, t2 -// CHECK-ASM: pssub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xd4] - +# CHECK-ASM-AND-OBJ: pasub.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xd9] 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] - +# CHECK-ASM-AND-OBJ: asub t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xda] +asub t1, a7, a0 +# CHECK-ASM-AND-OBJ: pasub.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xdc] pasub.b t0, t1, t2 -// CHECK-ASM: pasub.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xdc] - +# CHECK-ASM-AND-OBJ: pdifu.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xe9] pdifu.h t3, t4, t5 -// CHECK-ASM: pdifu.h t3, t4, t5 # encoding: [0x3b,0x8e,0xee,0xe9] - +# CHECK-ASM-AND-OBJ: pdifu.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xec] pdifu.b t0, t1, t2 -// CHECK-ASM: pdifu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xec] - +# CHECK-ASM-AND-OBJ: pssubu.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xf1] 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] - +# CHECK-ASM-AND-OBJ: ssubu t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xf2] +ssubu t1, a7, a0 +# CHECK-ASM-AND-OBJ: pssubu.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xf4] pssubu.b t0, t1, t2 -// CHECK-ASM: pssubu.b t0, t1, t2 # encoding: [0xbb,0x02,0x73,0xf4] - +# CHECK-ASM-AND-OBJ: pasubu.h t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x8e,0xee,0xf9] 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] - +# CHECK-ASM-AND-OBJ: asubu t1, a7, a0 +# CHECK-ASM: encoding: [0x3b,0x83,0xa8,0xfa] +asubu t1, a7, a0 +# CHECK-ASM-AND-OBJ: pasubu.b t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x02,0x73,0xfc] 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] - +# CHECK-ASM-AND-OBJ: slx gp, a4, a5 +# CHECK-ASM: encoding: [0xbb,0x11,0xf7,0x8e] +slx gp, a4, a5 +# CHECK-ASM-AND-OBJ: pmul.h.b01 t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0x91] pmul.h.b01 t3, t4, t5 -// CHECK-ASM: pmul.h.b01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x91] - +# CHECK-ASM-AND-OBJ: mul.h01 t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x12,0x73,0x92] mul.h01 t0, t1, t2 -// CHECK-ASM: mul.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0x92] - +# CHECK-ASM-AND-OBJ: macc.h01 t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0x9b] macc.h01 t3, t4, t5 -// CHECK-ASM: macc.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x9b] - +# CHECK-ASM-AND-OBJ: mvm a0, a1, a2 +# CHECK-ASM: encoding: [0x3b,0x95,0xc5,0xa8] 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] - +# CHECK-ASM-AND-OBJ: mvmn gp, a4, a5 +# CHECK-ASM: encoding: [0xbb,0x11,0xf7,0xaa] +mvmn gp, a4, a5 +# CHECK-ASM-AND-OBJ: merge t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x12,0x73,0xac] 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] - +# CHECK-ASM-AND-OBJ: srx gp, a4, a5 +# CHECK-ASM: encoding: [0xbb,0x11,0xf7,0xae] +srx gp, a4, a5 +# CHECK-ASM-AND-OBJ: pmulu.h.b01 t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0xb1] pmulu.h.b01 t3, t4, t5 -// CHECK-ASM: pmulu.h.b01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xb1] - +# CHECK-ASM-AND-OBJ: mulu.h01 t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x12,0x73,0xb2] mulu.h01 t0, t1, t2 -// CHECK-ASM: mulu.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0xb2] - +# CHECK-ASM-AND-OBJ: pdifsumu.b t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0xb5] pdifsumu.b t3, t4, t5 -// CHECK-ASM: pdifsumu.b t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xb5] - +# CHECK-ASM-AND-OBJ: maccu.h01 t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0xbb] maccu.h01 t3, t4, t5 -// CHECK-ASM: maccu.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xbb] - +# CHECK-ASM-AND-OBJ: pdifsumau.b t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0xbd] pdifsumau.b t3, t4, t5 -// CHECK-ASM: pdifsumau.b t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0xbd] - +# CHECK-ASM-AND-OBJ: mul.h01 t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x12,0x73,0x92] mul.h01 t0, t1, t2 -// CHECK-ASM: mul.h01 t0, t1, t2 # encoding: [0xbb,0x12,0x73,0x92] - +# CHECK-ASM-AND-OBJ: macc.h01 t3, t4, t5 +# CHECK-ASM: encoding: [0x3b,0x9e,0xee,0x9b] macc.h01 t3, t4, t5 -// CHECK-ASM: macc.h01 t3, t4, t5 # encoding: [0x3b,0x9e,0xee,0x9b] - +# CHECK-ASM-AND-OBJ: mulu.h01 a0, a1, a2 +# CHECK-ASM: encoding: [0x3b,0x95,0xc5,0xb2] mulu.h01 a0, a1, a2 -// CHECK-ASM: mulu.h01 a0, a1, a2 # encoding: [0x3b,0x95,0xc5,0xb2] - +# CHECK-ASM-AND-OBJ: maccu.h01 a3, a4, a5 +# CHECK-ASM: encoding: [0xbb,0x16,0xf7,0xba] maccu.h01 a3, a4, a5 -// CHECK-ASM: maccu.h01 a3, a4, a5 # encoding: [0xbb,0x16,0xf7,0xba] - +# CHECK-ASM-AND-OBJ: psh1add.h a0, a1, a2 +# CHECK-ASM: encoding: [0x3b,0xa5,0xc5,0xa0] psh1add.h a0, a1, a2 -// CHECK-ASM: psh1add.h a0, a1, a2 # encoding: [0x3b,0xa5,0xc5,0xa0] - +# CHECK-ASM-AND-OBJ: pssh1sadd.h a3, a4, a5 +# CHECK-ASM: encoding: [0xbb,0x26,0xf7,0xb0] pssh1sadd.h a3, a4, a5 -// CHECK-ASM: pssh1sadd.h a3, a4, a5 # encoding: [0xbb,0x26,0xf7,0xb0] - +# CHECK-ASM-AND-OBJ: ssh1sadd t0, t1, t2 +# CHECK-ASM: encoding: [0xbb,0x22,0x73,0xa2] ssh1sadd t0, t1, t2 -// CHECK-ASM: ssh1sadd t0, t1, t2 # encoding: [0xbb,0x22,0x73,0xa2] - +# CHECK-ASM-AND-OBJ: pmul.h.b00 s6, t4, s8 +# CHECK-ASM: encoding: [0x3b,0xbb,0x8e,0x81] pmul.h.b00 s6, t4, s8 -// CHECK-ASM: pmul.h.b00 s6, t4, s8 # encoding: [0x3b,0xbb,0x8e,0x81] - +# CHECK-ASM-AND-OBJ: pmul.h.b11 t0, t4, s4 +# CHECK-ASM: encoding: [0xbb,0xb2,0x4e,0x91] pmul.h.b11 t0, t4, s4 -// CHECK-ASM: pmul.h.b11 t0, t4, s4 # encoding: [0xbb,0xb2,0x4e,0x91] - +# CHECK-ASM-AND-OBJ: pmulu.h.b00 t2, s6, s8 +# CHECK-ASM: encoding: [0xbb,0x33,0x8b,0xa1] pmulu.h.b00 t2, s6, s8 -// CHECK-ASM: pmulu.h.b00 t2, s6, s8 # encoding: [0xbb,0x33,0x8b,0xa1] - +# CHECK-ASM-AND-OBJ: pmulu.h.b11 t2, s6, a0 +# CHECK-ASM: encoding: [0xbb,0x33,0xab,0xb0] pmulu.h.b11 t2, s6, a0 -// CHECK-ASM: pmulu.h.b11 t2, s6, a0 # encoding: [0xbb,0x33,0xab,0xb0] - +# CHECK-ASM-AND-OBJ: pmulsu.h.b00 s4, a4, s8 +# CHECK-ASM: encoding: [0x3b,0x3a,0x87,0xe1] pmulsu.h.b00 s4, a4, s8 -// CHECK-ASM: pmulsu.h.b00 s4, a4, s8 # encoding: [0x3b,0x3a,0x87,0xe1] - +# CHECK-ASM-AND-OBJ: pmulsu.h.b11 s6, a2, s4 +# CHECK-ASM: encoding: [0x3b,0x3b,0x46,0xf1] pmulsu.h.b11 s6, a2, s4 -// CHECK-ASM: pmulsu.h.b11 s6, a2, s4 # encoding: [0x3b,0x3b,0x46,0xf1] - +# CHECK-ASM-AND-OBJ: mul.h00 a4, t4, s2 +# CHECK-ASM: encoding: [0x3b,0xb7,0x2e,0x83] mul.h00 a4, t4, s2 -// CHECK-ASM: mul.h00 a4, t4, s2 # encoding: [0x3b,0xb7,0x2e,0x83] - +# CHECK-ASM-AND-OBJ: macc.h00 a4, a0, s0 +# CHECK-ASM: encoding: [0x3b,0x37,0x85,0x8a] macc.h00 a4, a0, s0 -// CHECK-ASM: macc.h00 a4, a0, s0 # encoding: [0x3b,0x37,0x85,0x8a] - +# CHECK-ASM-AND-OBJ: mul.h11 a0, a4, a0 +# CHECK-ASM: encoding: [0x3b,0x35,0xa7,0x92] mul.h11 a0, a4, a0 -// CHECK-ASM: mul.h11 a0, a4, a0 # encoding: [0x3b,0x35,0xa7,0x92] - +# CHECK-ASM-AND-OBJ: macc.h11 s6, a4, s4 +# CHECK-ASM: encoding: [0x3b,0x3b,0x47,0x9b] macc.h11 s6, a4, s4 -// CHECK-ASM: macc.h11 s6, a4, s4 # encoding: [0x3b,0x3b,0x47,0x9b] - +# CHECK-ASM-AND-OBJ: mulu.h00 s6, s0, a0 +# CHECK-ASM: encoding: [0x3b,0x3b,0xa4,0xa2] mulu.h00 s6, s0, a0 -// CHECK-ASM: mulu.h00 s6, s0, a0 # encoding: [0x3b,0x3b,0xa4,0xa2] - +# CHECK-ASM-AND-OBJ: maccu.h00 s0, s6, s0 +# CHECK-ASM: encoding: [0x3b,0x34,0x8b,0xaa] maccu.h00 s0, s6, s0 -// CHECK-ASM: maccu.h00 s0, s6, s0 # encoding: [0x3b,0x34,0x8b,0xaa] - +# CHECK-ASM-AND-OBJ: mulu.h11 s0, s4, s6 +# CHECK-ASM: encoding: [0x3b,0x34,0x6a,0xb3] mulu.h11 s0, s4, s6 -// CHECK-ASM: mulu.h11 s0, s4, s6 # encoding: [0x3b,0x34,0x6a,0xb3] - +# CHECK-ASM-AND-OBJ: maccu.h11 s0, t4, t4 +# CHECK-ASM: encoding: [0x3b,0xb4,0xde,0xbb] maccu.h11 s0, t4, t4 -// CHECK-ASM: maccu.h11 s0, t4, t4 # encoding: [0x3b,0xb4,0xde,0xbb] - +# CHECK-ASM-AND-OBJ: mulsu.h00 a4, s4, s6 +# CHECK-ASM: encoding: [0x3b,0x37,0x6a,0xe3] mulsu.h00 a4, s4, s6 -// CHECK-ASM: mulsu.h00 a4, s4, s6 # encoding: [0x3b,0x37,0x6a,0xe3] - +# CHECK-ASM-AND-OBJ: maccsu.h00 s4, s4, s0 +# CHECK-ASM: encoding: [0x3b,0x3a,0x8a,0xea] maccsu.h00 s4, s4, s0 -// CHECK-ASM: maccsu.h00 s4, s4, s0 # encoding: [0x3b,0x3a,0x8a,0xea] - +# CHECK-ASM-AND-OBJ: mulsu.h11 s8, s4, s0 +# CHECK-ASM: encoding: [0x3b,0x3c,0x8a,0xf2] mulsu.h11 s8, s4, s0 -// CHECK-ASM: mulsu.h11 s8, s4, s0 # encoding: [0x3b,0x3c,0x8a,0xf2] - +# CHECK-ASM-AND-OBJ: maccsu.h11 s0, a2, s6 +# CHECK-ASM: encoding: [0x3b,0x34,0x66,0xfb] maccsu.h11 s0, a2, s6 -// CHECK-ASM: maccsu.h11 s0, a2, s6 # encoding: [0x3b,0x34,0x66,0xfb] - +# CHECK-ASM-AND-OBJ: ppack.h t1, a2, t5 +# CHECK-ASM: encoding: [0x3b,0x43,0xe6,0x81] ppack.h t1, a2, t5 -// CHECK-ASM: ppack.h t1, a2, t5 # encoding: [0x3b,0x43,0xe6,0x81] - +# CHECK-ASM-AND-OBJ: ppackbt.h t5, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x4f,0x2e,0x91] ppackbt.h t5, t3, s2 -// CHECK-ASM: ppackbt.h t5, t3, s2 # encoding: [0x3b,0x4f,0x2e,0x91] - +# CHECK-ASM-AND-OBJ: ppacktb.h t1, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x43,0x83,0xa0] ppacktb.h t1, t1, s0 -// CHECK-ASM: ppacktb.h t1, t1, s0 # encoding: [0x3b,0x43,0x83,0xa0] - +# CHECK-ASM-AND-OBJ: ppackt.h t3, s0, s0 +# CHECK-ASM: encoding: [0x3b,0x4e,0x84,0xb0] ppackt.h t3, s0, s0 -// CHECK-ASM: ppackt.h t3, s0, s0 # encoding: [0x3b,0x4e,0x84,0xb0] - +# CHECK-ASM-AND-OBJ: packbt t1, t1, s2 +# CHECK-ASM: encoding: [0x3b,0x43,0x23,0x93] packbt t1, t1, s2 -// CHECK-ASM: packbt t1, t1, s2 # encoding: [0x3b,0x43,0x23,0x93] - +# CHECK-ASM-AND-OBJ: packtb t5, s0, a2 +# CHECK-ASM: encoding: [0x3b,0x4f,0xc4,0xa2] packtb t5, s0, a2 -// CHECK-ASM: packtb t5, s0, a2 # encoding: [0x3b,0x4f,0xc4,0xa2] - +# CHECK-ASM-AND-OBJ: packt a4, t5, t5 +# CHECK-ASM: encoding: [0x3b,0x47,0xef,0xb3] packt a4, t5, t5 -// CHECK-ASM: packt a4, t5, t5 # encoding: [0x3b,0x47,0xef,0xb3] - +# CHECK-ASM-AND-OBJ: pm2add.h t3, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x5e,0x83,0x80] pm2add.h t3, t1, s0 -// CHECK-ASM: pm2add.h t3, t1, s0 # encoding: [0x3b,0x5e,0x83,0x80] - +# CHECK-ASM-AND-OBJ: pm4add.b t1, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x53,0xe9,0x85] pm4add.b t1, s2, t5 -// CHECK-ASM: pm4add.b t1, s2, t5 # encoding: [0x3b,0x53,0xe9,0x85] - +# CHECK-ASM-AND-OBJ: pm2adda.h t1, s2, a4 +# CHECK-ASM: encoding: [0x3b,0x53,0xe9,0x88] pm2adda.h t1, s2, a4 -// CHECK-ASM: pm2adda.h t1, s2, a4 # encoding: [0x3b,0x53,0xe9,0x88] - +# CHECK-ASM-AND-OBJ: pm4adda.b t3, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x5e,0xe5,0x8d] pm4adda.b t3, a0, t5 -// CHECK-ASM: pm4adda.b t3, a0, t5 # encoding: [0x3b,0x5e,0xe5,0x8d] - +# CHECK-ASM-AND-OBJ: pm2add.hx s0, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x54,0xef,0x90] pm2add.hx s0, t5, a4 -// CHECK-ASM: pm2add.hx s0, t5, a4 # encoding: [0x3b,0x54,0xef,0x90] - +# CHECK-ASM-AND-OBJ: pm2adda.hx a0, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x55,0x65,0x98] pm2adda.hx a0, a0, t1 -// CHECK-ASM: pm2adda.hx a0, a0, t1 # encoding: [0x3b,0x55,0x65,0x98] - +# CHECK-ASM-AND-OBJ: pm2addu.h s2, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x59,0xcf,0xa0] pm2addu.h s2, t5, a2 -// CHECK-ASM: pm2addu.h s2, t5, a2 # encoding: [0x3b,0x59,0xcf,0xa0] - +# CHECK-ASM-AND-OBJ: pm4addu.b t5, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x5f,0x64,0xa4] pm4addu.b t5, s0, t1 -// CHECK-ASM: pm4addu.b t5, s0, t1 # encoding: [0x3b,0x5f,0x64,0xa4] - +# CHECK-ASM-AND-OBJ: pm2addau.h t3, t1, t5 +# CHECK-ASM: encoding: [0x3b,0x5e,0xe3,0xa9] pm2addau.h t3, t1, t5 -// CHECK-ASM: pm2addau.h t3, t1, t5 # encoding: [0x3b,0x5e,0xe3,0xa9] - +# CHECK-ASM-AND-OBJ: pm4addau.b a4, t3, a0 +# CHECK-ASM: encoding: [0x3b,0x57,0xae,0xac] pm4addau.b a4, t3, a0 -// CHECK-ASM: pm4addau.b a4, t3, a0 # encoding: [0x3b,0x57,0xae,0xac] - +# CHECK-ASM-AND-OBJ: pmq2add.h t1, a2, t1 +# CHECK-ASM: encoding: [0x3b,0x53,0x66,0xb0] pmq2add.h t1, a2, t1 -// CHECK-ASM: pmq2add.h t1, a2, t1 # encoding: [0x3b,0x53,0x66,0xb0] - +# CHECK-ASM-AND-OBJ: pmqr2add.h a2, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x56,0x27,0xb5] 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] - +# CHECK-ASM-AND-OBJ: pmq2adda.h a2, s2, t1 +# CHECK-ASM: encoding: [0x3b,0x56,0x69,0xb8] +pmq2adda.h a2, s2, t1 +# CHECK-ASM-AND-OBJ: pmqr2adda.h t1, s0, a2 +# CHECK-ASM: encoding: [0x3b,0x53,0xc4,0xbc] pmqr2adda.h t1, s0, a2 -// CHECK-ASM: pmqr2adda.h t1, s0, a2 # encoding: [0x3b,0x53,0xc4,0xbc] - +# CHECK-ASM-AND-OBJ: pm2sub.h t1, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x53,0xe5,0xc0] pm2sub.h t1, a0, a4 -// CHECK-ASM: pm2sub.h t1, a0, a4 # encoding: [0x3b,0x53,0xe5,0xc0] - +# CHECK-ASM-AND-OBJ: pm2sadd.h s2, s2, t3 +# CHECK-ASM: encoding: [0x3b,0x59,0xc9,0xc5] pm2sadd.h s2, s2, t3 -// CHECK-ASM: pm2sadd.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0xc5] - +# CHECK-ASM-AND-OBJ: pm2suba.h s0, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x54,0xc4,0xc9] pm2suba.h s0, s0, t3 -// CHECK-ASM: pm2suba.h s0, s0, t3 # encoding: [0x3b,0x54,0xc4,0xc9] - +# CHECK-ASM-AND-OBJ: pm2sub.hx a2, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x56,0xa6,0xd0] pm2sub.hx a2, a2, a0 -// CHECK-ASM: pm2sub.hx a2, a2, a0 # encoding: [0x3b,0x56,0xa6,0xd0] - +# CHECK-ASM-AND-OBJ: pm2sadd.hx t5, s2, a0 +# CHECK-ASM: encoding: [0x3b,0x5f,0xa9,0xd4] pm2sadd.hx t5, s2, a0 -// CHECK-ASM: pm2sadd.hx t5, s2, a0 # encoding: [0x3b,0x5f,0xa9,0xd4] - +# CHECK-ASM-AND-OBJ: pm2suba.hx a4, a2, t5 +# CHECK-ASM: encoding: [0x3b,0x57,0xe6,0xd9] pm2suba.hx a4, a2, t5 -// CHECK-ASM: pm2suba.hx a4, a2, t5 # encoding: [0x3b,0x57,0xe6,0xd9] - +# CHECK-ASM-AND-OBJ: pm2addsu.h s0, s0, s2 +# CHECK-ASM: encoding: [0x3b,0x54,0x24,0xe1] pm2addsu.h s0, s0, s2 -// CHECK-ASM: pm2addsu.h s0, s0, s2 # encoding: [0x3b,0x54,0x24,0xe1] - +# CHECK-ASM-AND-OBJ: pm4addsu.b a0, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x55,0xc4,0xe5] pm4addsu.b a0, s0, t3 -// CHECK-ASM: pm4addsu.b a0, s0, t3 # encoding: [0x3b,0x55,0xc4,0xe5] - +# CHECK-ASM-AND-OBJ: pm2addasu.h a4, t1, a2 +# CHECK-ASM: encoding: [0x3b,0x57,0xc3,0xe8] pm2addasu.h a4, t1, a2 -// CHECK-ASM: pm2addasu.h a4, t1, a2 # encoding: [0x3b,0x57,0xc3,0xe8] - +# CHECK-ASM-AND-OBJ: pm4addasu.b s2, s0, a2 +# CHECK-ASM: encoding: [0x3b,0x59,0xc4,0xec] pm4addasu.b s2, s0, a2 -// CHECK-ASM: pm4addasu.b s2, s0, a2 # encoding: [0x3b,0x59,0xc4,0xec] - +# CHECK-ASM-AND-OBJ: mqacc.h01 a4, t1, a0 +# CHECK-ASM: encoding: [0x3b,0x57,0xa3,0xf8] mqacc.h01 a4, t1, a0 -// CHECK-ASM: mqacc.h01 a4, t1, a0 # encoding: [0x3b,0x57,0xa3,0xb8] - +# CHECK-ASM-AND-OBJ: mqracc.h01 s0, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x54,0xe5,0xfd] mqracc.h01 s0, a0, t5 -// CHECK-ASM: mqracc.h01 s0, a0, t5 # encoding: [0x3b,0x54,0xe5,0xbd] - +# CHECK-ASM-AND-OBJ: pas.hx t5, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x6f,0xe9,0x81] pas.hx t5, s2, t5 -// CHECK-ASM: pas.hx t5, s2, t5 # encoding: [0x3b,0x6f,0xe9,0x81] - +# CHECK-ASM-AND-OBJ: psa.hx s0, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x64,0xc3,0x85] psa.hx s0, t1, t3 -// CHECK-ASM: psa.hx s0, t1, t3 # encoding: [0x3b,0x64,0xc3,0x85] - +# CHECK-ASM-AND-OBJ: psas.hx t5, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x6f,0xc9,0x90] psas.hx t5, s2, a2 -// CHECK-ASM: psas.hx t5, s2, a2 # encoding: [0x3b,0x6f,0xc9,0x90] - +# CHECK-ASM-AND-OBJ: pssa.hx s2, t3, t5 +# CHECK-ASM: encoding: [0x3b,0x69,0xee,0x95] pssa.hx s2, t3, t5 -// CHECK-ASM: pssa.hx s2, t3, t5 # encoding: [0x3b,0x69,0xee,0x95] - +# CHECK-ASM-AND-OBJ: pmseq.h a0, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x65,0x83,0xc0] pmseq.h a0, t1, s0 -// CHECK-ASM: pmseq.h a0, t1, s0 # encoding: [0x3b,0x65,0x83,0xc0] - +# CHECK-ASM-AND-OBJ: pmseq.b s0, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x64,0x89,0xc4] pmseq.b s0, s2, s0 -// CHECK-ASM: pmseq.b s0, s2, s0 # encoding: [0x3b,0x64,0x89,0xc4] - +# CHECK-ASM-AND-OBJ: pmslt.h t3, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x6e,0xe6,0xd0] pmslt.h t3, a2, a4 -// CHECK-ASM: pmslt.h t3, a2, a4 # encoding: [0x3b,0x6e,0xe6,0xd0] - +# CHECK-ASM-AND-OBJ: pmslt.b t5, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x6f,0x67,0xd4] pmslt.b t5, a4, t1 -// CHECK-ASM: pmslt.b t5, a4, t1 # encoding: [0x3b,0x6f,0x67,0xd4] - +# CHECK-ASM-AND-OBJ: pmsltu.h s2, s0, s2 +# CHECK-ASM: encoding: [0x3b,0x69,0x24,0xd9] pmsltu.h s2, s0, s2 -// CHECK-ASM: pmsltu.h s2, s0, s2 # encoding: [0x3b,0x69,0x24,0xd9] - +# CHECK-ASM-AND-OBJ: pmsltu.b s0, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x64,0xe9,0xdd] pmsltu.b s0, s2, t5 -// CHECK-ASM: pmsltu.b s0, s2, t5 # encoding: [0x3b,0x64,0xe9,0xdd] - +# CHECK-ASM-AND-OBJ: pmin.h s2, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x69,0x2e,0xe1] pmin.h s2, t3, s2 -// CHECK-ASM: pmin.h s2, t3, s2 # encoding: [0x3b,0x69,0x2e,0xe1] - +# CHECK-ASM-AND-OBJ: pmin.b a2, a2, t5 +# CHECK-ASM: encoding: [0x3b,0x66,0xe6,0xe5] pmin.b a2, a2, t5 -// CHECK-ASM: pmin.b a2, a2, t5 # encoding: [0x3b,0x66,0xe6,0xe5] - +# CHECK-ASM-AND-OBJ: pminu.h a0, a4, a2 +# CHECK-ASM: encoding: [0x3b,0x65,0xc7,0xe8] pminu.h a0, a4, a2 -// CHECK-ASM: pminu.h a0, a4, a2 # encoding: [0x3b,0x65,0xc7,0xe8] - +# CHECK-ASM-AND-OBJ: pminu.b a4, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x67,0x2e,0xed] pminu.b a4, t3, s2 -// CHECK-ASM: pminu.b a4, t3, s2 # encoding: [0x3b,0x67,0x2e,0xed] - +# CHECK-ASM-AND-OBJ: pmax.h a4, s2, a0 +# CHECK-ASM: encoding: [0x3b,0x67,0xa9,0xf0] pmax.h a4, s2, a0 -// CHECK-ASM: pmax.h a4, s2, a0 # encoding: [0x3b,0x67,0xa9,0xf0] - +# CHECK-ASM-AND-OBJ: pmax.b t1, s0, s0 +# CHECK-ASM: encoding: [0x3b,0x63,0x84,0xf4] pmax.b t1, s0, s0 -// CHECK-ASM: pmax.b t1, s0, s0 # encoding: [0x3b,0x63,0x84,0xf4] - +# CHECK-ASM-AND-OBJ: pmaxu.h a0, s0, s0 +# CHECK-ASM: encoding: [0x3b,0x65,0x84,0xf8] pmaxu.h a0, s0, s0 -// CHECK-ASM: pmaxu.h a0, s0, s0 # encoding: [0x3b,0x65,0x84,0xf8] - +# CHECK-ASM-AND-OBJ: pmaxu.b t3, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x6e,0x65,0xfc] pmaxu.b t3, a0, t1 -// CHECK-ASM: pmaxu.b t3, a0, t1 # encoding: [0x3b,0x6e,0x65,0xfc] - +# CHECK-ASM-AND-OBJ: mseq a4, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x67,0x83,0xc2] mseq a4, t1, s0 -// CHECK-ASM: mseq a4, t1, s0 # encoding: [0x3b,0x67,0x83,0xc2] - +# CHECK-ASM-AND-OBJ: mslt t5, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x6f,0x6f,0xd2] mslt t5, t5, t1 -// CHECK-ASM: mslt t5, t5, t1 # encoding: [0x3b,0x6f,0x6f,0xd2] - +# CHECK-ASM-AND-OBJ: msltu s2, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x69,0xc5,0xdb] msltu s2, a0, t3 -// CHECK-ASM: msltu s2, a0, t3 # encoding: [0x3b,0x69,0xc5,0xdb] - +# CHECK-ASM-AND-OBJ: pmulh.h s0, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x74,0xce,0x81] pmulh.h s0, t3, t3 -// CHECK-ASM: pmulh.h s0, t3, t3 # encoding: [0x3b,0x74,0xce,0x81] - +# CHECK-ASM-AND-OBJ: pmulhr.h t1, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x73,0x8f,0x84] pmulhr.h t1, t5, s0 -// CHECK-ASM: pmulhr.h t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x84] - +# CHECK-ASM-AND-OBJ: pmhacc.h s0, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x74,0x2f,0x89] pmhacc.h s0, t5, s2 -// CHECK-ASM: pmhacc.h s0, t5, s2 # encoding: [0x3b,0x74,0x2f,0x89] - +# CHECK-ASM-AND-OBJ: pmhracc.h a4, t3, a2 +# CHECK-ASM: encoding: [0x3b,0x77,0xce,0x8c] pmhracc.h a4, t3, a2 -// CHECK-ASM: pmhracc.h a4, t3, a2 # encoding: [0x3b,0x77,0xce,0x8c] - +# CHECK-ASM-AND-OBJ: pmulhu.h a4, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x77,0xcf,0x90] pmulhu.h a4, t5, a2 -// CHECK-ASM: pmulhu.h a4, t5, a2 # encoding: [0x3b,0x77,0xcf,0x90] - +# CHECK-ASM-AND-OBJ: pmulhru.h a4, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x77,0xe6,0x94] pmulhru.h a4, a2, a4 -// CHECK-ASM: pmulhru.h a4, a2, a4 # encoding: [0x3b,0x77,0xe6,0x94] - +# CHECK-ASM-AND-OBJ: pmhaccu.h a4, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x77,0xc3,0x99] pmhaccu.h a4, t1, t3 -// CHECK-ASM: pmhaccu.h a4, t1, t3 # encoding: [0x3b,0x77,0xc3,0x99] - +# CHECK-ASM-AND-OBJ: pmhraccu.h s2, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x79,0x64,0x9c] pmhraccu.h s2, s0, t1 -// CHECK-ASM: pmhraccu.h s2, s0, t1 # encoding: [0x3b,0x79,0x64,0x9c] - +# CHECK-ASM-AND-OBJ: pmulh.h.b0 a0, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x75,0xef,0xa0] pmulh.h.b0 a0, t5, a4 -// CHECK-ASM: pmulh.h.b0 a0, t5, a4 # encoding: [0x3b,0x75,0xef,0xa0] - +# CHECK-ASM-AND-OBJ: pmulhsu.h.b0 s0, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x74,0x27,0xa5] pmulhsu.h.b0 s0, a4, s2 -// CHECK-ASM: pmulhsu.h.b0 s0, a4, s2 # encoding: [0x3b,0x74,0x27,0xa5] - +# CHECK-ASM-AND-OBJ: pmhaccu.h.b0 s0, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x74,0xe5,0xa9] pmhaccu.h.b0 s0, a0, t5 -// CHECK-ASM: pmhaccu.h.b0 s0, a0, t5 # encoding: [0x3b,0x74,0xe5,0xa9] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h.b0 t3, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x7e,0xe4,0xac] pmhaccsu.h.b0 t3, s0, a4 -// CHECK-ASM: pmhaccsu.h.b0 t3, s0, a4 # encoding: [0x3b,0x7e,0xe4,0xac] - +# CHECK-ASM-AND-OBJ: pmulh.h.b1 a0, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x75,0x27,0xb1] pmulh.h.b1 a0, a4, s2 -// CHECK-ASM: pmulh.h.b1 a0, a4, s2 # encoding: [0x3b,0x75,0x27,0xb1] - +# CHECK-ASM-AND-OBJ: pmulhsu.h.b1 t5, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x7f,0x6e,0xb4] pmulhsu.h.b1 t5, t3, t1 -// CHECK-ASM: pmulhsu.h.b1 t5, t3, t1 # encoding: [0x3b,0x7f,0x6e,0xb4] - +# CHECK-ASM-AND-OBJ: pmhacc.h.b1 t1, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x73,0xcf,0xb8] pmhacc.h.b1 t1, t5, a2 -// CHECK-ASM: pmhacc.h.b1 t1, t5, a2 # encoding: [0x3b,0x73,0xcf,0xb8] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h.b1 a2, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x76,0xe5,0xbc] pmhaccsu.h.b1 a2, a0, a4 -// CHECK-ASM: pmhaccsu.h.b1 a2, a0, a4 # encoding: [0x3b,0x76,0xe5,0xbc] - +# CHECK-ASM-AND-OBJ: pmulhsu.h s0, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x74,0x65,0xc0] pmulhsu.h s0, a0, t1 -// CHECK-ASM: pmulhsu.h s0, a0, t1 # encoding: [0x3b,0x74,0x65,0xc0] - +# CHECK-ASM-AND-OBJ: pmulhrsu.h t3, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x7e,0xef,0xc4] pmulhrsu.h t3, t5, a4 -// CHECK-ASM: pmulhrsu.h t3, t5, a4 # encoding: [0x3b,0x7e,0xef,0xc4] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h s0, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x74,0xe4,0xc8] pmhaccsu.h s0, s0, a4 -// CHECK-ASM: pmhaccsu.h s0, s0, a4 # encoding: [0x3b,0x74,0xe4,0xc8] - +# CHECK-ASM-AND-OBJ: pmhraccsu.h a2, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x76,0xa6,0xcc] pmhraccsu.h a2, a2, a0 -// CHECK-ASM: pmhraccsu.h a2, a2, a0 # encoding: [0x3b,0x76,0xa6,0xcc] - +# CHECK-ASM-AND-OBJ: pmulq.h a0, t1, t1 +# CHECK-ASM: encoding: [0x3b,0x75,0x63,0xd0] pmulq.h a0, t1, t1 -// CHECK-ASM: pmulq.h a0, t1, t1 # encoding: [0x3b,0x75,0x63,0xd0] - +# CHECK-ASM-AND-OBJ: pmulqr.h s2, s0, s2 +# CHECK-ASM: encoding: [0x3b,0x79,0x24,0xd5] pmulqr.h s2, s0, s2 -// CHECK-ASM: pmulqr.h s2, s0, s2 # encoding: [0x3b,0x79,0x24,0xd5] - +# CHECK-ASM-AND-OBJ: mulhr a4, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x77,0xe9,0x87] mulhr a4, s2, t5 -// CHECK-ASM: mulhr a4, s2, t5 # encoding: [0x3b,0x77,0xe9,0x87] - +# CHECK-ASM-AND-OBJ: mhacc t1, s0, a2 +# CHECK-ASM: encoding: [0x3b,0x73,0xc4,0x8a] mhacc t1, s0, a2 -// CHECK-ASM: mhacc t1, s0, a2 # encoding: [0x3b,0x73,0xc4,0x8a] - +# CHECK-ASM-AND-OBJ: mhracc t1, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x73,0x8f,0x8e] mhracc t1, t5, s0 -// CHECK-ASM: mhracc t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x8e] - +# CHECK-ASM-AND-OBJ: mulhru t1, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x73,0x8f,0x96] mulhru t1, t5, s0 -// CHECK-ASM: mulhru t1, t5, s0 # encoding: [0x3b,0x73,0x8f,0x96] - +# CHECK-ASM-AND-OBJ: mhaccu t3, a2, s2 +# CHECK-ASM: encoding: [0x3b,0x7e,0x26,0x9b] mhaccu t3, a2, s2 -// CHECK-ASM: mhaccu t3, a2, s2 # encoding: [0x3b,0x7e,0x26,0x9b] - +# CHECK-ASM-AND-OBJ: mhraccu a0, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x75,0xe3,0x9e] mhraccu a0, t1, a4 -// CHECK-ASM: mhraccu a0, t1, a4 # encoding: [0x3b,0x75,0xe3,0x9e] - +# CHECK-ASM-AND-OBJ: mulh.h0 t3, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x7e,0x67,0xa2] mulh.h0 t3, a4, t1 -// CHECK-ASM: mulh.h0 t3, a4, t1 # encoding: [0x3b,0x7e,0x67,0xa2] - +# CHECK-ASM-AND-OBJ: mulhsu.h0 t1, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x73,0xa6,0xa6] mulhsu.h0 t1, a2, a0 -// CHECK-ASM: mulhsu.h0 t1, a2, a0 # encoding: [0x3b,0x73,0xa6,0xa6] - +# CHECK-ASM-AND-OBJ: mhacc.h0 s0, a2, t3 +# CHECK-ASM: encoding: [0x3b,0x74,0xc6,0xab] mhacc.h0 s0, a2, t3 -// CHECK-ASM: mhacc.h0 s0, a2, t3 # encoding: [0x3b,0x74,0xc6,0xab] - +# CHECK-ASM-AND-OBJ: mhaccsu.h0 a2, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x76,0x83,0xae] mhaccsu.h0 a2, t1, s0 -// CHECK-ASM: mhaccsu.h0 a2, t1, s0 # encoding: [0x3b,0x76,0x83,0xae] - +# CHECK-ASM-AND-OBJ: mulh.h1 t1, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x73,0xc3,0xb3] mulh.h1 t1, t1, t3 -// CHECK-ASM: mulh.h1 t1, t1, t3 # encoding: [0x3b,0x73,0xc3,0xb3] - +# CHECK-ASM-AND-OBJ: mulhsu.h1 t3, a2, t1 +# CHECK-ASM: encoding: [0x3b,0x7e,0x66,0xb6] mulhsu.h1 t3, a2, t1 -// CHECK-ASM: mulhsu.h1 t3, a2, t1 # encoding: [0x3b,0x7e,0x66,0xb6] - +# CHECK-ASM-AND-OBJ: mhacc.h1 t3, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x7e,0xa6,0xba] mhacc.h1 t3, a2, a0 -// CHECK-ASM: mhacc.h1 t3, a2, a0 # encoding: [0x3b,0x7e,0xa6,0xba] - +# CHECK-ASM-AND-OBJ: mhaccsu.h1 s0, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x74,0x89,0xbe] mhaccsu.h1 s0, s2, s0 -// CHECK-ASM: mhaccsu.h1 s0, s2, s0 # encoding: [0x3b,0x74,0x89,0xbe] - +# CHECK-ASM-AND-OBJ: mulhrsu.h t5, a4, t5 +# CHECK-ASM: encoding: [0x3b,0x7f,0xe7,0xc7] mulhrsu.h t5, a4, t5 -// CHECK-ASM: mulhrsu.h t5, a4, t5 # encoding: [0x3b,0x7f,0xe7,0xc7] - +# CHECK-ASM-AND-OBJ: mhaccsu a0, a2, s2 +# CHECK-ASM: encoding: [0x3b,0x75,0x26,0xcb] mhaccsu a0, a2, s2 -// CHECK-ASM: mhaccsu a0, a2, s2 # encoding: [0x3b,0x75,0x26,0xcb] - +# CHECK-ASM-AND-OBJ: mhraccsu a0, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x75,0x65,0xce] mhraccsu a0, a0, t1 -// CHECK-ASM: mhraccsu a0, a0, t1 # encoding: [0x3b,0x75,0x65,0xce] - +# CHECK-ASM-AND-OBJ: mulq t1, a2, a2 +# CHECK-ASM: encoding: [0x3b,0x73,0xc6,0xd2] mulq t1, a2, a2 -// CHECK-ASM: mulq t1, a2, a2 # encoding: [0x3b,0x73,0xc6,0xd2] - +# CHECK-ASM-AND-OBJ: mulqr a4, a4, t3 +# CHECK-ASM: encoding: [0x3b,0x77,0xc7,0xd7] mulqr a4, a4, t3 -// CHECK-ASM: mulqr a4, a4, t3 # encoding: [0x3b,0x77,0xc7,0xd7] - +# CHECK-ASM-AND-OBJ: mqacc.h00 a2, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x76,0xce,0xe9] mqacc.h00 a2, t3, t3 -// CHECK-ASM: mqacc.h00 a2, t3, t3 # encoding: [0x3b,0x76,0xce,0xe9] - +# CHECK-ASM-AND-OBJ: mqracc.h00 t5, a4, t3 +# CHECK-ASM: encoding: [0x3b,0x7f,0xc7,0xed] mqracc.h00 t5, a4, t3 -// CHECK-ASM: mqracc.h00 t5, a4, t3 # encoding: [0x3b,0x7f,0xc7,0xed] - +# CHECK-ASM-AND-OBJ: mqacc.h11 t5, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x7f,0x8f,0xf8] mqacc.h11 t5, t5, s0 -// CHECK-ASM: mqacc.h11 t5, t5, s0 # encoding: [0x3b,0x7f,0x8f,0xf8] - +# CHECK-ASM-AND-OBJ: mqracc.h11 s0, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x74,0x2f,0xfd] mqracc.h11 s0, t5, s2 -// CHECK-ASM: mqracc.h11 s0, t5, s2 # encoding: [0x3b,0x74,0x2f,0xfd] - +# CHECK-ASM-AND-OBJ: pwslli.b a0, t1 +# CHECK-ASM: encoding: [0x1b,0x25,0x03,0x01] pwslli.b a0, t1 -// CHECK-ASM: pwslli.b a0, t1 # encoding: [0x1b,0x4a,0x03,0x01] - +# CHECK-ASM-AND-OBJ: pwslli.h s0, a0 +# CHECK-ASM: encoding: [0x1b,0x24,0x05,0x12] pwslli.h s0, a0 -// CHECK-ASM: pwslli.h s0, a0 # encoding: [0x1b,0x48,0x05,0x12] - +# CHECK-ASM-AND-OBJ: wslli s2, t3 +# CHECK-ASM: encoding: [0x1b,0x29,0x0e,0x24] wslli s2, t3 -// CHECK-ASM: wslli s2, t3 # encoding: [0x1b,0x42,0x0e,0x24] - +# CHECK-ASM-AND-OBJ: pwslai.b t5, t5 +# CHECK-ASM: encoding: [0x1b,0x2f,0x0f,0x41] pwslai.b t5, t5 -// CHECK-ASM: pwslai.b t5, t5 # encoding: [0x1b,0x4e,0x0f,0x41] - +# CHECK-ASM-AND-OBJ: pwslai.h t5, a4 +# CHECK-ASM: encoding: [0x1b,0x2f,0x07,0x42] pwslai.h t5, a4 -// CHECK-ASM: pwslai.h t5, a4 # encoding: [0x1b,0x4e,0x07,0x42] - +# CHECK-ASM-AND-OBJ: wslai t1, a2 +# CHECK-ASM: encoding: [0x1b,0x23,0x06,0x44] 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] - +# CHECK-ASM-AND-OBJ: pli.dh s0, 32 +# CHECK-ASM: encoding: [0x1b,0x22,0x10,0x30] +pli.dh s0, 32 +# CHECK-ASM-AND-OBJ: pli.db a2, 1 +# CHECK-ASM: encoding: [0x1b,0x23,0x01,0x34] +pli.db a2, 1 +# CHECK-ASM-AND-OBJ: plui.dh t5, 16 +# CHECK-ASM: encoding: [0x9b,0x27,0x08,0x70] +plui.dh t5, 16 +# CHECK-ASM-AND-OBJ: pwslli.bs t3, t1, s0 +# CHECK-ASM: encoding: [0x1b,0x2e,0x83,0x08] pwslli.bs t3, t1, s0 -// CHECK-ASM: pwslli.bs t3, t1, s0 # encoding: [0x1b,0x2c,0x83,0x08] - +# CHECK-ASM-AND-OBJ: pwsll.hs s0, a4, t1 +# CHECK-ASM: encoding: [0x1b,0x24,0x67,0x0a] pwsll.hs s0, a4, t1 -// CHECK-ASM: pwsll.hs s0, a4, t1 # encoding: [0x1b,0x28,0x67,0x0a] - +# CHECK-ASM-AND-OBJ: wsll a0, s0, s2 +# CHECK-ASM: encoding: [0x1b,0x25,0x24,0x0f] wsll a0, s0, s2 -// CHECK-ASM: wsll a0, s0, s2 # encoding: [0x1b,0x2a,0x24,0x0f] - +# CHECK-ASM-AND-OBJ: pwsla.bs s0, s0, s0 +# CHECK-ASM: encoding: [0x1b,0x24,0x84,0x48] pwsla.bs s0, s0, s0 -// CHECK-ASM: pwsla.bs s0, s0, s0 # encoding: [0x1b,0x28,0x84,0x48] - +# CHECK-ASM-AND-OBJ: pwsla.hs a4, a2, t5 +# CHECK-ASM: encoding: [0x1b,0x27,0xe6,0x4b] pwsla.hs a4, a2, t5 -// CHECK-ASM: pwsla.hs a4, a2, t5 # encoding: [0x1b,0x2e,0xe6,0x4b] - +# CHECK-ASM-AND-OBJ: wsla s0, a0, s2 +# CHECK-ASM: encoding: [0x1b,0x24,0x25,0x4f] wsla s0, a0, s2 -// CHECK-ASM: wsla s0, a0, s2 # encoding: [0x1b,0x28,0x25,0x4f] - +# CHECK-ASM-AND-OBJ: wzip8p t1, s2, a2 +# CHECK-ASM: encoding: [0x1b,0x23,0xc9,0x78] wzip8p t1, s2, a2 -// CHECK-ASM: wzip8p t1, s2, a2 # encoding: [0x1b,0x26,0xc9,0x78] - +# CHECK-ASM-AND-OBJ: wzip16p s2, t3, s2 +# CHECK-ASM: encoding: [0x1b,0x29,0x2e,0x7b] wzip16p s2, t3, s2 -// CHECK-ASM: wzip16p s2, t3, s2 # encoding: [0x1b,0x22,0x2e,0x7b] - +# CHECK-ASM-AND-OBJ: pwadd.h a4, a2, a0 +# CHECK-ASM: encoding: [0xbb,0x27,0x56,0x00] pwadd.h a4, a2, a0 -// CHECK-ASM: pwadd.h a4, a2, a0 # encoding: [0xbb,0x2e,0xa6,0x00] - +# CHECK-ASM-AND-OBJ: wadd t1, t5, t5 +# CHECK-ASM: encoding: [0xbb,0x23,0xff,0x02] wadd t1, t5, t5 -// CHECK-ASM: wadd t1, t5, t5 # encoding: [0xbb,0x26,0xef,0x03] - +# CHECK-ASM-AND-OBJ: pwadd.b s0, t3, a4 +# CHECK-ASM: encoding: [0xbb,0x24,0x7e,0x04] pwadd.b s0, t3, a4 -// CHECK-ASM: pwadd.b s0, t3, a4 # encoding: [0xbb,0x28,0xee,0x04] - +# CHECK-ASM-AND-OBJ: pw2wadd.h t3, t3, a4 +# CHECK-ASM: encoding: [0xbb,0x2e,0x7e,0x06] pw2wadd.h t3, t3, a4 -// CHECK-ASM: pw2wadd.h t3, t3, a4 # encoding: [0xbb,0x2c,0xee,0x06] - +# CHECK-ASM-AND-OBJ: pwadda.h t1, t3, s2 +# CHECK-ASM: encoding: [0xbb,0x23,0x9e,0x08] pwadda.h t1, t3, s2 -// CHECK-ASM: pwadda.h t1, t3, s2 # encoding: [0xbb,0x26,0x2e,0x09] - +# CHECK-ASM-AND-OBJ: wadda s2, t1, a0 +# CHECK-ASM: encoding: [0xbb,0x29,0x53,0x0a] wadda s2, t1, a0 -// CHECK-ASM: wadda s2, t1, a0 # encoding: [0xbb,0x22,0xa3,0x0a] - +# CHECK-ASM-AND-OBJ: pwadda.b a2, a2, s2 +# CHECK-ASM: encoding: [0xbb,0x26,0x96,0x0c] pwadda.b a2, a2, s2 -// CHECK-ASM: pwadda.b a2, a2, s2 # encoding: [0xbb,0x2c,0x26,0x0d] - +# CHECK-ASM-AND-OBJ: pw2wadda.h t3, t1, t1 +# CHECK-ASM: encoding: [0xbb,0x2e,0x33,0x0e] pw2wadda.h t3, t1, t1 -// CHECK-ASM: pw2wadda.h t3, t1, t1 # encoding: [0xbb,0x2c,0x63,0x0e] - +# CHECK-ASM-AND-OBJ: pwaddu.h a2, t1, a4 +# CHECK-ASM: encoding: [0xbb,0x26,0x73,0x10] pwaddu.h a2, t1, a4 -// CHECK-ASM: pwaddu.h a2, t1, a4 # encoding: [0xbb,0x2c,0xe3,0x10] - +# CHECK-ASM-AND-OBJ: waddu t1, s0, t1 +# CHECK-ASM: encoding: [0xbb,0x23,0x34,0x12] waddu t1, s0, t1 -// CHECK-ASM: waddu t1, s0, t1 # encoding: [0xbb,0x26,0x64,0x12] - +# CHECK-ASM-AND-OBJ: pwaddu.b s2, a0, t3 +# CHECK-ASM: encoding: [0xbb,0x29,0xe5,0x14] pwaddu.b s2, a0, t3 -// CHECK-ASM: pwaddu.b s2, a0, t3 # encoding: [0xbb,0x22,0xc5,0x15] - +# CHECK-ASM-AND-OBJ: pw2wadd.hx a0, s0, t1 +# CHECK-ASM: encoding: [0xbb,0x25,0x34,0x16] pw2wadd.hx a0, s0, t1 -// CHECK-ASM: pw2wadd.hx a0, s0, t1 # encoding: [0xbb,0x2a,0x64,0x16] - +# CHECK-ASM-AND-OBJ: pwaddau.h t1, t5, t3 +# CHECK-ASM: encoding: [0xbb,0x23,0xef,0x18] pwaddau.h t1, t5, t3 -// CHECK-ASM: pwaddau.h t1, t5, t3 # encoding: [0xbb,0x26,0xcf,0x19] - +# CHECK-ASM-AND-OBJ: waddau t3, s0, s0 +# CHECK-ASM: encoding: [0xbb,0x2e,0x44,0x1a] waddau t3, s0, s0 -// CHECK-ASM: waddau t3, s0, s0 # encoding: [0xbb,0x2c,0x84,0x1a] - +# CHECK-ASM-AND-OBJ: pwaddau.b a0, a0, t1 +# CHECK-ASM: encoding: [0xbb,0x25,0x35,0x1c] pwaddau.b a0, a0, t1 -// CHECK-ASM: pwaddau.b a0, a0, t1 # encoding: [0xbb,0x2a,0x65,0x1c] - +# CHECK-ASM-AND-OBJ: pw2wadda.hx a4, a2, t3 +# CHECK-ASM: encoding: [0xbb,0x27,0xe6,0x1e] pw2wadda.hx a4, a2, t3 -// CHECK-ASM: pw2wadda.hx a4, a2, t3 # encoding: [0xbb,0x2e,0xc6,0x1f] - +# CHECK-ASM-AND-OBJ: pwmul.h s2, t1, a0 +# CHECK-ASM: encoding: [0xbb,0x29,0x53,0x20] pwmul.h s2, t1, a0 -// CHECK-ASM: pwmul.h s2, t1, a0 # encoding: [0xbb,0x22,0xa3,0x20] - +# CHECK-ASM-AND-OBJ: wmul t3, a2, t5 +# CHECK-ASM: encoding: [0xbb,0x2e,0xf6,0x22] wmul t3, a2, t5 -// CHECK-ASM: wmul t3, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x23] - +# CHECK-ASM-AND-OBJ: pwmul.b a0, s0, s2 +# CHECK-ASM: encoding: [0xbb,0x25,0x94,0x24] pwmul.b a0, s0, s2 -// CHECK-ASM: pwmul.b a0, s0, s2 # encoding: [0xbb,0x2a,0x24,0x25] - +# CHECK-ASM-AND-OBJ: pw2waddu.h s2, s2, a0 +# CHECK-ASM: encoding: [0xbb,0x29,0x59,0x26] pw2waddu.h s2, s2, a0 -// CHECK-ASM: pw2waddu.h s2, s2, a0 # encoding: [0xbb,0x22,0xa9,0x26] - +# CHECK-ASM-AND-OBJ: pwmacc.h s0, a2, a2 +# CHECK-ASM: encoding: [0xbb,0x24,0x66,0x28] pwmacc.h s0, a2, a2 -// CHECK-ASM: pwmacc.h s0, a2, a2 # encoding: [0xbb,0x28,0xc6,0x28] - +# CHECK-ASM-AND-OBJ: wmacc a0, a2, a2 +# CHECK-ASM: encoding: [0xbb,0x25,0x66,0x2a] wmacc a0, a2, a2 -// CHECK-ASM: wmacc a0, a2, a2 # encoding: [0xbb,0x2a,0xc6,0x2a] - +# CHECK-ASM-AND-OBJ: pm2waddau.h t5, a2, t5 +# CHECK-ASM: encoding: [0xbb,0x2f,0xf6,0x2e] pm2waddau.h t5, a2, t5 -// CHECK-ASM: pm2waddau.h t5, a2, t5 # encoding: [0xbb,0x2e,0xe6,0x2f] - +# CHECK-ASM-AND-OBJ: pwmulu.h a2, a0, t5 +# CHECK-ASM: encoding: [0xbb,0x26,0xf5,0x30] pwmulu.h a2, a0, t5 -// CHECK-ASM: pwmulu.h a2, a0, t5 # encoding: [0xbb,0x2c,0xe5,0x31] - +# CHECK-ASM-AND-OBJ: wmulu s2, a0, t3 +# CHECK-ASM: encoding: [0xbb,0x29,0xe5,0x32] wmulu s2, a0, t3 -// CHECK-ASM: wmulu s2, a0, t3 # encoding: [0xbb,0x22,0xc5,0x33] - +# CHECK-ASM-AND-OBJ: pwmulu.b a2, a4, a2 +# CHECK-ASM: encoding: [0xbb,0x26,0x67,0x34] pwmulu.b a2, a4, a2 -// CHECK-ASM: pwmulu.b a2, a4, a2 # encoding: [0xbb,0x2c,0xc7,0x34] - +# CHECK-ASM-AND-OBJ: pwmaccu.h t1, a4, a2 +# CHECK-ASM: encoding: [0xbb,0x23,0x67,0x38] pwmaccu.h t1, a4, a2 -// CHECK-ASM: pwmaccu.h t1, a4, a2 # encoding: [0xbb,0x26,0xc7,0x38] - +# CHECK-ASM-AND-OBJ: wmaccu a2, a0, t1 +# CHECK-ASM: encoding: [0xbb,0x26,0x35,0x3a] wmaccu a2, a0, t1 -// CHECK-ASM: wmaccu a2, a0, t1 # encoding: [0xbb,0x2c,0x65,0x3a] - +# CHECK-ASM-AND-OBJ: pwsub.h s0, s2, t3 +# CHECK-ASM: encoding: [0xbb,0x24,0xe9,0x40] pwsub.h s0, s2, t3 -// CHECK-ASM: pwsub.h s0, s2, t3 # encoding: [0xbb,0x28,0xc9,0x41] - +# CHECK-ASM-AND-OBJ: wsub t1, s2, a4 +# CHECK-ASM: encoding: [0xbb,0x23,0x79,0x42] wsub t1, s2, a4 -// CHECK-ASM: wsub t1, s2, a4 # encoding: [0xbb,0x26,0xe9,0x42] - +# CHECK-ASM-AND-OBJ: pwsub.b a4, s2, s2 +# CHECK-ASM: encoding: [0xbb,0x27,0x99,0x44] pwsub.b a4, s2, s2 -// CHECK-ASM: pwsub.b a4, s2, s2 # encoding: [0xbb,0x2e,0x29,0x45] - +# CHECK-ASM-AND-OBJ: pw2wsub.h t1, a4, t3 +# CHECK-ASM: encoding: [0xbb,0x23,0xe7,0x46] pw2wsub.h t1, a4, t3 -// CHECK-ASM: pw2wsub.h t1, a4, t3 # encoding: [0xbb,0x26,0xc7,0x47] - +# CHECK-ASM-AND-OBJ: pwsuba.h a4, t5, t1 +# CHECK-ASM: encoding: [0xbb,0x27,0x3f,0x48] pwsuba.h a4, t5, t1 -// CHECK-ASM: pwsuba.h a4, t5, t1 # encoding: [0xbb,0x2e,0x6f,0x48] - +# CHECK-ASM-AND-OBJ: wsuba a0, s0, t5 +# CHECK-ASM: encoding: [0xbb,0x25,0xf4,0x4a] wsuba a0, s0, t5 -// CHECK-ASM: wsuba a0, s0, t5 # encoding: [0xbb,0x2a,0xe4,0x4b] - +# CHECK-ASM-AND-OBJ: pwsuba.b a0, a2, s2 +# CHECK-ASM: encoding: [0xbb,0x25,0x96,0x4c] pwsuba.b a0, a2, s2 -// CHECK-ASM: pwsuba.b a0, a2, s2 # encoding: [0xbb,0x2a,0x26,0x4d] - +# CHECK-ASM-AND-OBJ: pw2wsuba.h t5, s0, s2 +# CHECK-ASM: encoding: [0xbb,0x2f,0x94,0x4e] pw2wsuba.h t5, s0, s2 -// CHECK-ASM: pw2wsuba.h t5, s0, s2 # encoding: [0xbb,0x2e,0x24,0x4f] - +# CHECK-ASM-AND-OBJ: pwsubu.h t5, s2, a2 +# CHECK-ASM: encoding: [0xbb,0x2f,0x69,0x50] pwsubu.h t5, s2, a2 -// CHECK-ASM: pwsubu.h t5, s2, a2 # encoding: [0xbb,0x2e,0xc9,0x50] - +# CHECK-ASM-AND-OBJ: wsubu a2, a4, a0 +# CHECK-ASM: encoding: [0xbb,0x26,0x57,0x52] wsubu a2, a4, a0 -// CHECK-ASM: wsubu a2, a4, a0 # encoding: [0xbb,0x2c,0xa7,0x52] - +# CHECK-ASM-AND-OBJ: pwsubu.b a2, a2, t5 +# CHECK-ASM: encoding: [0xbb,0x26,0xf6,0x54] pwsubu.b a2, a2, t5 -// CHECK-ASM: pwsubu.b a2, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x55] - +# CHECK-ASM-AND-OBJ: pw2wsub.hx t5, a2, a0 +# CHECK-ASM: encoding: [0xbb,0x2f,0x56,0x56] pw2wsub.hx t5, a2, a0 -// CHECK-ASM: pw2wsub.hx t5, a2, a0 # encoding: [0xbb,0x2e,0xa6,0x56] - +# CHECK-ASM-AND-OBJ: pwsubau.h t5, s0, s2 +# CHECK-ASM: encoding: [0xbb,0x2f,0x94,0x58] pwsubau.h t5, s0, s2 -// CHECK-ASM: pwsubau.h t5, s0, s2 # encoding: [0xbb,0x2e,0x24,0x59] - +# CHECK-ASM-AND-OBJ: wsubau t5, a0, t1 +# CHECK-ASM: encoding: [0xbb,0x2f,0x35,0x5a] wsubau t5, a0, t1 -// CHECK-ASM: wsubau t5, a0, t1 # encoding: [0xbb,0x2e,0x65,0x5a] - +# CHECK-ASM-AND-OBJ: pwsubau.b a2, a0, a0 +# CHECK-ASM: encoding: [0xbb,0x26,0x55,0x5c] pwsubau.b a2, a0, a0 -// CHECK-ASM: pwsubau.b a2, a0, a0 # encoding: [0xbb,0x2c,0xa5,0x5c] - +# CHECK-ASM-AND-OBJ: pw2wsuba.hx a2, a2, t5 +# CHECK-ASM: encoding: [0xbb,0x26,0xf6,0x5e] pw2wsuba.hx a2, a2, t5 -// CHECK-ASM: pw2wsuba.hx a2, a2, t5 # encoding: [0xbb,0x2c,0xe6,0x5f] - +# CHECK-ASM-AND-OBJ: pwmulsu.h s0, a2, t3 +# CHECK-ASM: encoding: [0xbb,0x24,0xe6,0x60] pwmulsu.h s0, a2, t3 -// CHECK-ASM: pwmulsu.h s0, a2, t3 # encoding: [0xbb,0x28,0xc6,0x61] - +# CHECK-ASM-AND-OBJ: wmulsu a0, s2, a0 +# CHECK-ASM: encoding: [0xbb,0x25,0x59,0x62] wmulsu a0, s2, a0 -// CHECK-ASM: wmulsu a0, s2, a0 # encoding: [0xbb,0x2a,0xa9,0x62] - +# CHECK-ASM-AND-OBJ: pwmulsu.b t3, t5, t1 +# CHECK-ASM: encoding: [0xbb,0x2e,0x3f,0x64] pwmulsu.b t3, t5, t1 -// CHECK-ASM: pwmulsu.b t3, t5, t1 # encoding: [0xbb,0x2c,0x6f,0x64] - +# CHECK-ASM-AND-OBJ: pm2waddsu.h a4, a2, s2 +# CHECK-ASM: encoding: [0xbb,0x27,0x96,0x66] pm2waddsu.h a4, a2, s2 -// CHECK-ASM: pm2waddsu.h a4, a2, s2 # encoding: [0xbb,0x2e,0x26,0x67] - +# CHECK-ASM-AND-OBJ: pwmaccsu.h t5, s2, a2 +# CHECK-ASM: encoding: [0xbb,0x2f,0x69,0x68] pwmaccsu.h t5, s2, a2 -// CHECK-ASM: pwmaccsu.h t5, s2, a2 # encoding: [0xbb,0x2e,0xc9,0x68] - +# CHECK-ASM-AND-OBJ: wmaccsu t3, s0, a4 +# CHECK-ASM: encoding: [0xbb,0x2e,0x74,0x6a] wmaccsu t3, s0, a4 -// CHECK-ASM: wmaccsu t3, s0, a4 # encoding: [0xbb,0x2c,0xe4,0x6a] - +# CHECK-ASM-AND-OBJ: pm2waddasu.h t3, t5, a0 +# CHECK-ASM: encoding: [0xbb,0x2e,0x5f,0x6e] pm2waddasu.h t3, t5, a0 -// CHECK-ASM: pm2waddasu.h t3, t5, a0 # encoding: [0xbb,0x2c,0xaf,0x6e] - +# CHECK-ASM-AND-OBJ: pmqwacc.h t5, t5, a2 +# CHECK-ASM: encoding: [0xbb,0x2f,0x6f,0x78] pmqwacc.h t5, t5, a2 -// CHECK-ASM: pmqwacc.h t5, t5, a2 # encoding: [0xbb,0x2e,0xcf,0x78] - +# CHECK-ASM-AND-OBJ: pmqwacc s2, a4, a2 +# CHECK-ASM: encoding: [0xbb,0x29,0x67,0x7a] pmqwacc s2, a4, a2 -// CHECK-ASM: pmqwacc s2, a4, a2 # encoding: [0xbb,0x22,0xc7,0x7a] - +# CHECK-ASM-AND-OBJ: pmqrwacc.h a4, t3, a4 +# CHECK-ASM: encoding: [0xbb,0x27,0x7e,0x7c] pmqrwacc.h a4, t3, a4 -// CHECK-ASM: pmqrwacc.h a4, t3, a4 # encoding: [0xbb,0x2e,0xee,0x7c] - +# CHECK-ASM-AND-OBJ: pmqrwacc s0, s2, t5 +# CHECK-ASM: encoding: [0xbb,0x24,0xf9,0x7e] pmqrwacc s0, s2, t5 -// CHECK-ASM: pmqrwacc s0, s2, t5 # encoding: [0xbb,0x28,0xe9,0x7f] - +# CHECK-ASM-AND-OBJ: predsum.dhs s0, t3, a0 +# CHECK-ASM: encoding: [0x1b,0x44,0xae,0x08] predsum.dhs s0, t3, a0 -// CHECK-ASM: predsum.dhs s0, t3, a0 # encoding: [0x1b,0x44,0xac,0x08] - +# CHECK-ASM-AND-OBJ: predsum.dbs a2, s0, t3 +# CHECK-ASM: encoding: [0x1b,0x46,0xc4,0x0d] predsum.dbs a2, s0, t3 -// CHECK-ASM: predsum.dbs a2, s0, t3 # encoding: [0x1b,0x46,0xc8,0x0d] - +# CHECK-ASM-AND-OBJ: predsumu.dhs a2, a2, t3 +# CHECK-ASM: encoding: [0x1b,0x46,0xc6,0x39] predsumu.dhs a2, a2, t3 -// CHECK-ASM: predsumu.dhs a2, a2, t3 # encoding: [0x1b,0x46,0xcc,0x39] - +# CHECK-ASM-AND-OBJ: predsumu.dbs a2, a0, s0 +# CHECK-ASM: encoding: [0x1b,0x46,0x85,0x3c] predsumu.dbs a2, a0, s0 -// CHECK-ASM: predsumu.dbs a2, a0, s0 # encoding: [0x1b,0x46,0x8a,0x3c] - +# CHECK-ASM-AND-OBJ: pnsrli.b a2, a0 +# CHECK-ASM: encoding: [0x1b,0xc6,0x05,0x01] pnsrli.b a2, a0 -// CHECK-ASM: pnsrli.b a2, a0 # encoding: [0x1b,0xc6,0x0a,0x01] - +# CHECK-ASM-AND-OBJ: pnsrli.h a0, t3 +# CHECK-ASM: encoding: [0x1b,0xc5,0x0e,0x02] pnsrli.h a0, t3 -// CHECK-ASM: pnsrli.h a0, t3 # encoding: [0x1b,0xc5,0x0c,0x02] - +# CHECK-ASM-AND-OBJ: nsrli a2, a0 +# CHECK-ASM: encoding: [0x1b,0xc6,0x05,0x04] nsrli a2, a0 -// CHECK-ASM: nsrli a2, a0 # encoding: [0x1b,0xc6,0x0a,0x04] - +# CHECK-ASM-AND-OBJ: pnclipiu.b a4, t3 +# CHECK-ASM: encoding: [0x1b,0xc7,0x0e,0x21] pnclipiu.b a4, t3 -// CHECK-ASM: pnclipiu.b a4, t3 # encoding: [0x1b,0xc7,0x0c,0x21] - +# CHECK-ASM-AND-OBJ: pnclipiu.h t1, s2 +# CHECK-ASM: encoding: [0x1b,0xc3,0x09,0x22] pnclipiu.h t1, s2 -// CHECK-ASM: pnclipiu.h t1, s2 # encoding: [0x1b,0xc3,0x02,0x22] - +# CHECK-ASM-AND-OBJ: nclipiu s0, a2 +# CHECK-ASM: encoding: [0x1b,0xc4,0x06,0x24] nclipiu s0, a2 -// CHECK-ASM: nclipiu s0, a2 # encoding: [0x1b,0xc4,0x0c,0x24] - +# CHECK-ASM-AND-OBJ: pnclipriu.b s2, s0 +# CHECK-ASM: encoding: [0x1b,0xc9,0x04,0x31] pnclipriu.b s2, s0 -// CHECK-ASM: pnclipriu.b s2, s0 # encoding: [0x1b,0xc9,0x08,0x31] - +# CHECK-ASM-AND-OBJ: pnclipriu.h s0, s0 +# CHECK-ASM: encoding: [0x1b,0xc4,0x04,0x32] pnclipriu.h s0, s0 -// CHECK-ASM: pnclipriu.h s0, s0 # encoding: [0x1b,0xc4,0x08,0x32] - +# CHECK-ASM-AND-OBJ: nclipriu t3, t3 +# CHECK-ASM: encoding: [0x1b,0xce,0x0e,0x34] nclipriu t3, t3 -// CHECK-ASM: nclipriu t3, t3 # encoding: [0x1b,0xce,0x0c,0x34] - +# CHECK-ASM-AND-OBJ: pnsrai.b s2, t5 +# CHECK-ASM: encoding: [0x1b,0xc9,0x0f,0x41] pnsrai.b s2, t5 -// CHECK-ASM: pnsrai.b s2, t5 # encoding: [0x1b,0xc9,0x0e,0x41] - +# CHECK-ASM-AND-OBJ: pnsrai.h s0, a0 +# CHECK-ASM: encoding: [0x1b,0xc4,0x05,0x42] pnsrai.h s0, a0 -// CHECK-ASM: pnsrai.h s0, a0 # encoding: [0x1b,0xc4,0x0a,0x42] - +# CHECK-ASM-AND-OBJ: nsrai a4, t3 +# CHECK-ASM: encoding: [0x1b,0xc7,0x0e,0x44] nsrai a4, t3 -// CHECK-ASM: nsrai a4, t3 # encoding: [0x1b,0xc7,0x0c,0x44] - +# CHECK-ASM-AND-OBJ: pnsari.b t5, t5 +# CHECK-ASM: encoding: [0x1b,0xcf,0x0f,0x51] pnsari.b t5, t5 -// CHECK-ASM: pnsari.b t5, t5 # encoding: [0x1b,0xcf,0x0e,0x51] - +# CHECK-ASM-AND-OBJ: pnsari.h t1, a4 +# CHECK-ASM: encoding: [0x1b,0xc3,0x07,0x52] pnsari.h t1, a4 -// CHECK-ASM: pnsari.h t1, a4 # encoding: [0x1b,0xc3,0x0e,0x52] - +# CHECK-ASM-AND-OBJ: nsari s0, t1 +# CHECK-ASM: encoding: [0x1b,0xc4,0x03,0x54] nsari s0, t1 -// CHECK-ASM: nsari s0, t1 # encoding: [0x1b,0xc4,0x06,0x54] - +# CHECK-ASM-AND-OBJ: pnclipi.b t1, a4 +# CHECK-ASM: encoding: [0x1b,0xc3,0x07,0x61] pnclipi.b t1, a4 -// CHECK-ASM: pnclipi.b t1, a4 # encoding: [0x1b,0xc3,0x0e,0x61] - +# CHECK-ASM-AND-OBJ: pnclipi.h a0, a4 +# CHECK-ASM: encoding: [0x1b,0xc5,0x07,0x62] pnclipi.h a0, a4 -// CHECK-ASM: pnclipi.h a0, a4 # encoding: [0x1b,0xc5,0x0e,0x62] - +# CHECK-ASM-AND-OBJ: nclipi t5, t5 +# CHECK-ASM: encoding: [0x1b,0xcf,0x0f,0x64] nclipi t5, t5 -// CHECK-ASM: nclipi t5, t5 # encoding: [0x1b,0xcf,0x0e,0x64] - +# CHECK-ASM-AND-OBJ: pnclipri.b a0, s0 +# CHECK-ASM: encoding: [0x1b,0xc5,0x04,0x71] pnclipri.b a0, s0 -// CHECK-ASM: pnclipri.b a0, s0 # encoding: [0x1b,0xc5,0x08,0x71] - +# CHECK-ASM-AND-OBJ: pnclipri.h s2, t5 +# CHECK-ASM: encoding: [0x1b,0xc9,0x0f,0x72] pnclipri.h s2, t5 -// CHECK-ASM: pnclipri.h s2, t5 # encoding: [0x1b,0xc9,0x0e,0x72] - +# CHECK-ASM-AND-OBJ: nclipri t3, s0 +# CHECK-ASM: encoding: [0x1b,0xce,0x04,0x74] nclipri t3, s0 -// CHECK-ASM: nclipri t3, s0 # encoding: [0x1b,0xce,0x08,0x74] - +# CHECK-ASM-AND-OBJ: pnsrl.bs t3, s0, a4 +# CHECK-ASM: encoding: [0x1b,0xce,0xe4,0x08] pnsrl.bs t3, s0, a4 -// CHECK-ASM: pnsrl.bs t3, s0, a4 # encoding: [0x1b,0xce,0xe8,0x08] - +# CHECK-ASM-AND-OBJ: pnsrl.hs a2, t1, a4 +# CHECK-ASM: encoding: [0x1b,0xc6,0xe3,0x0a] pnsrl.hs a2, t1, a4 -// CHECK-ASM: pnsrl.hs a2, t1, a4 # encoding: [0x1b,0xc6,0xe6,0x0a] - +# CHECK-ASM-AND-OBJ: nsrl a2, a2, a0 +# CHECK-ASM: encoding: [0x1b,0xc6,0xa6,0x0e] nsrl a2, a2, a0 -// CHECK-ASM: nsrl a2, a2, a0 # encoding: [0x1b,0xc6,0xac,0x0e] - +# CHECK-ASM-AND-OBJ: pnclipu.bs a4, t5, a2 +# CHECK-ASM: encoding: [0x1b,0xc7,0xcf,0x28] pnclipu.bs a4, t5, a2 -// CHECK-ASM: pnclipu.bs a4, t5, a2 # encoding: [0x1b,0xc7,0xce,0x28] - +# CHECK-ASM-AND-OBJ: pnclipu.hs t1, a2, a4 +# CHECK-ASM: encoding: [0x1b,0xc3,0xe6,0x2a] pnclipu.hs t1, a2, a4 -// CHECK-ASM: pnclipu.hs t1, a2, a4 # encoding: [0x1b,0xc3,0xec,0x2a] - +# CHECK-ASM-AND-OBJ: nclipu t5, s2, t1 +# CHECK-ASM: encoding: [0x1b,0xcf,0x69,0x2e] nclipu t5, s2, t1 -// CHECK-ASM: nclipu t5, s2, t1 # encoding: [0x1b,0xcf,0x62,0x2e] - +# CHECK-ASM-AND-OBJ: pnclipru.bs t5, s2, s2 +# CHECK-ASM: encoding: [0x1b,0xcf,0x29,0x39] pnclipru.bs t5, s2, s2 -// CHECK-ASM: pnclipru.bs t5, s2, s2 # encoding: [0x1b,0xcf,0x22,0x39] - +# CHECK-ASM-AND-OBJ: pnclipru.hs t5, s2, a0 +# CHECK-ASM: encoding: [0x1b,0xcf,0xa9,0x3a] pnclipru.hs t5, s2, a0 -// CHECK-ASM: pnclipru.hs t5, s2, a0 # encoding: [0x1b,0xcf,0xa2,0x3a] - +# CHECK-ASM-AND-OBJ: nclipru a4, t5, t5 +# CHECK-ASM: encoding: [0x1b,0xc7,0xef,0x3f] nclipru a4, t5, t5 -// CHECK-ASM: nclipru a4, t5, t5 # encoding: [0x1b,0xc7,0xee,0x3f] - +# CHECK-ASM-AND-OBJ: pnsra.bs a4, t1, a4 +# CHECK-ASM: encoding: [0x1b,0xc7,0xe3,0x48] pnsra.bs a4, t1, a4 -// CHECK-ASM: pnsra.bs a4, t1, a4 # encoding: [0x1b,0xc7,0xe6,0x48] - +# CHECK-ASM-AND-OBJ: pnsra.hs s0, s2, t3 +# CHECK-ASM: encoding: [0x1b,0xc4,0xc9,0x4b] pnsra.hs s0, s2, t3 -// CHECK-ASM: pnsra.hs s0, s2, t3 # encoding: [0x1b,0xc4,0xc2,0x4b] - +# CHECK-ASM-AND-OBJ: nsra t1, s0, a4 +# CHECK-ASM: encoding: [0x1b,0xc3,0xe4,0x4e] nsra t1, s0, a4 -// CHECK-ASM: nsra t1, s0, a4 # encoding: [0x1b,0xc3,0xe8,0x4e] - +# CHECK-ASM-AND-OBJ: pnsrar.bs a2, s0, a4 +# CHECK-ASM: encoding: [0x1b,0xc6,0xe4,0x58] pnsrar.bs a2, s0, a4 -// CHECK-ASM: pnsrar.bs a2, s0, a4 # encoding: [0x1b,0xc6,0xe8,0x58] - +# CHECK-ASM-AND-OBJ: pnsrar.hs s0, a4, a0 +# CHECK-ASM: encoding: [0x1b,0xc4,0xa7,0x5a] pnsrar.hs s0, a4, a0 -// CHECK-ASM: pnsrar.hs s0, a4, a0 # encoding: [0x1b,0xc4,0xae,0x5a] - +# CHECK-ASM-AND-OBJ: nsrar a4, a4, s0 +# CHECK-ASM: encoding: [0x1b,0xc7,0x87,0x5e] nsrar a4, a4, s0 -// CHECK-ASM: nsrar a4, a4, s0 # encoding: [0x1b,0xc7,0x8e,0x5e] - +# CHECK-ASM-AND-OBJ: pnclip.bs t1, t5, t3 +# CHECK-ASM: encoding: [0x1b,0xc3,0xcf,0x69] pnclip.bs t1, t5, t3 -// CHECK-ASM: pnclip.bs t1, t5, t3 # encoding: [0x1b,0xc3,0xce,0x69] - +# CHECK-ASM-AND-OBJ: pnclip.hs a0, a2, a0 +# CHECK-ASM: encoding: [0x1b,0xc5,0xa6,0x6a] pnclip.hs a0, a2, a0 -// CHECK-ASM: pnclip.hs a0, a2, a0 # encoding: [0x1b,0xc5,0xac,0x6a] - +# CHECK-ASM-AND-OBJ: nclip t3, t5, t3 +# CHECK-ASM: encoding: [0x1b,0xce,0xcf,0x6f] nclip t3, t5, t3 -// CHECK-ASM: nclip t3, t5, t3 # encoding: [0x1b,0xce,0xce,0x6f] - +# CHECK-ASM-AND-OBJ: pnclipr.bs t1, a2, a0 +# CHECK-ASM: encoding: [0x1b,0xc3,0xa6,0x78] pnclipr.bs t1, a2, a0 -// CHECK-ASM: pnclipr.bs t1, a2, a0 # encoding: [0x1b,0xc3,0xac,0x78] - +# CHECK-ASM-AND-OBJ: pnclipr.hs a4, s2, t3 +# CHECK-ASM: encoding: [0x1b,0xc7,0xc9,0x7b] pnclipr.hs a4, s2, t3 -// CHECK-ASM: pnclipr.hs a4, s2, t3 # encoding: [0x1b,0xc7,0xc2,0x7b] - +# CHECK-ASM-AND-OBJ: nclipr t1, t5, a2 +# CHECK-ASM: encoding: [0x1b,0xc3,0xcf,0x7e] nclipr t1, t5, a2 -// CHECK-ASM: nclipr t1, t5, a2 # encoding: [0x1b,0xc3,0xce,0x7e] - +# CHECK-ASM-AND-OBJ: pslli.db a0, s2 +# CHECK-ASM: encoding: [0x1b,0x65,0x89,0x00] pslli.db a0, s2 -// CHECK-ASM: pslli.db a0, s2 # encoding: [0x1b,0x4a,0x82,0x00] - +# CHECK-ASM-AND-OBJ: pslli.dh t3, t1 +# CHECK-ASM: encoding: [0x1b,0x6e,0x03,0x01] pslli.dh t3, t1 -// CHECK-ASM: pslli.dh t3, t1 # encoding: [0x1b,0x4c,0x06,0x01] - +# CHECK-ASM-AND-OBJ: pslli.dw a4, t3 +# CHECK-ASM: encoding: [0x1b,0x67,0x0e,0x02] pslli.dw a4, t3 -// CHECK-ASM: pslli.dw a4, t3 # encoding: [0x1b,0x4e,0x0c,0x02] - +# CHECK-ASM-AND-OBJ: psslai.dh t1, a4 +# CHECK-ASM: encoding: [0x1b,0x63,0x07,0x51] psslai.dh t1, a4 -// CHECK-ASM: psslai.dh t1, a4 # encoding: [0x1b,0x46,0x0e,0x51] - +# CHECK-ASM-AND-OBJ: psslai.dw a0, t3 +# CHECK-ASM: encoding: [0x1b,0x65,0x0e,0x52] psslai.dw a0, t3 -// CHECK-ASM: psslai.dw a0, t3 # encoding: [0x1b,0x4a,0x0c,0x52] - +# CHECK-ASM-AND-OBJ: psext.dh.b t1, t5 +# CHECK-ASM: encoding: [0x1b,0x23,0x4f,0x60] psext.dh.b t1, t5 -// CHECK-ASM: psext.dh.b t1, t5 # encoding: [0x1b,0x26,0x4e,0x60] - +# CHECK-ASM-AND-OBJ: psext.dw.b t5, t5 +# CHECK-ASM: encoding: [0x1b,0x2f,0x4f,0x62] psext.dw.b t5, t5 -// CHECK-ASM: psext.dw.b t5, t5 # encoding: [0x1b,0x2e,0x4e,0x62] - +# CHECK-ASM-AND-OBJ: psext.dw.h s0, t1 +# CHECK-ASM: encoding: [0x1b,0x24,0x53,0x62] psext.dw.h s0, t1 -// CHECK-ASM: psext.dw.h s0, t1 # encoding: [0x1b,0x28,0x56,0x62] - +# CHECK-ASM-AND-OBJ: psabs.dh s0, s2 +# CHECK-ASM: encoding: [0x1b,0x24,0x79,0x60] psabs.dh s0, s2 -// CHECK-ASM: psabs.dh s0, s2 # encoding: [0x1b,0x28,0x72,0x60] - +# CHECK-ASM-AND-OBJ: psabs.db s2, a2 +# CHECK-ASM: encoding: [0x1b,0x29,0x76,0x64] psabs.db s2, a2 -// CHECK-ASM: psabs.db s2, a2 # encoding: [0x1b,0x22,0x7c,0x64] - +# CHECK-ASM-AND-OBJ: psll.dhs s2, t3, a4 +# CHECK-ASM: encoding: [0x1b,0x69,0xee,0x08] psll.dhs s2, t3, a4 -// CHECK-ASM: psll.dhs s2, t3, a4 # encoding: [0x1b,0x62,0xec,0x08] - +# CHECK-ASM-AND-OBJ: psll.dws a2, t1, t3 +# CHECK-ASM: encoding: [0x1b,0x66,0xc3,0x0b] psll.dws a2, t1, t3 -// CHECK-ASM: psll.dws a2, t1, t3 # encoding: [0x1b,0x6c,0xc6,0x0b] - +# CHECK-ASM-AND-OBJ: psll.dbs a0, a4, a2 +# CHECK-ASM: encoding: [0x1b,0x65,0xc7,0x0c] psll.dbs a0, a4, a2 -// CHECK-ASM: psll.dbs a0, a4, a2 # encoding: [0x1b,0x6a,0xce,0x0c] - +# CHECK-ASM-AND-OBJ: padd.dhs t1, a4, s2 +# CHECK-ASM: encoding: [0x1b,0x63,0x27,0x19] padd.dhs t1, a4, s2 -// CHECK-ASM: padd.dhs t1, a4, s2 # encoding: [0x1b,0x66,0x2e,0x19] - +# CHECK-ASM-AND-OBJ: padd.dws a4, a4, t3 +# CHECK-ASM: encoding: [0x1b,0x67,0xc7,0x1b] padd.dws a4, a4, t3 -// CHECK-ASM: padd.dws a4, a4, t3 # encoding: [0x1b,0x6e,0xce,0x1b] - +# CHECK-ASM-AND-OBJ: padd.dbs a2, a4, t3 +# CHECK-ASM: encoding: [0x1b,0x66,0xc7,0x1d] padd.dbs a2, a4, t3 -// CHECK-ASM: padd.dbs a2, a4, t3 # encoding: [0x1b,0x6c,0xce,0x1d] - +# CHECK-ASM-AND-OBJ: pssha.dhs a0, s0, s2 +# CHECK-ASM: encoding: [0x1b,0x65,0x24,0x69] pssha.dhs a0, s0, s2 -// CHECK-ASM: pssha.dhs a0, s0, s2 # encoding: [0x1b,0x6a,0x28,0x69] - +# CHECK-ASM-AND-OBJ: pssha.dws a0, t1, s2 +# CHECK-ASM: encoding: [0x1b,0x65,0x23,0x6b] pssha.dws a0, t1, s2 -// CHECK-ASM: pssha.dws a0, t1, s2 # encoding: [0x1b,0x6a,0x26,0x6b] - +# CHECK-ASM-AND-OBJ: psshar.dhs a2, a4, t3 +# CHECK-ASM: encoding: [0x1b,0x66,0xc7,0x79] psshar.dhs a2, a4, t3 -// CHECK-ASM: psshar.dhs a2, a4, t3 # encoding: [0x1b,0x6c,0xce,0x79] - +# CHECK-ASM-AND-OBJ: psshar.dws s0, t3, s0 +# CHECK-ASM: encoding: [0x1b,0x64,0x8e,0x7a] psshar.dws s0, t3, s0 -// CHECK-ASM: psshar.dws s0, t3, s0 # encoding: [0x1b,0x68,0x8c,0x7a] - +# CHECK-ASM-AND-OBJ: psrli.db t5, a2 +# CHECK-ASM: encoding: [0x1b,0xef,0x86,0x00] psrli.db t5, a2 -// CHECK-ASM: psrli.db t5, a2 # encoding: [0x1b,0xce,0x8c,0x00] - +# CHECK-ASM-AND-OBJ: psrli.dh a2, t3 +# CHECK-ASM: encoding: [0x1b,0xe6,0x0e,0x01] psrli.dh a2, t3 -// CHECK-ASM: psrli.dh a2, t3 # encoding: [0x1b,0xcc,0x0c,0x01] - +# CHECK-ASM-AND-OBJ: psrli.dw s2, t1 +# CHECK-ASM: encoding: [0x1b,0xe9,0x03,0x02] psrli.dw s2, t1 -// CHECK-ASM: psrli.dw s2, t1 # encoding: [0x1b,0xc2,0x06,0x02] - +# CHECK-ASM-AND-OBJ: pusati.dh a0, a4 +# CHECK-ASM: encoding: [0x1b,0xe5,0x07,0x21] pusati.dh a0, a4 -// CHECK-ASM: pusati.dh a0, a4 # encoding: [0x1b,0xca,0x0e,0x21] - +# CHECK-ASM-AND-OBJ: pusati.dw a0, s2 +# CHECK-ASM: encoding: [0x1b,0xe5,0x09,0x22] pusati.dw a0, s2 -// CHECK-ASM: pusati.dw a0, s2 # encoding: [0x1b,0xca,0x02,0x22] - +# CHECK-ASM-AND-OBJ: psrai.db t5, t5 +# CHECK-ASM: encoding: [0x1b,0xef,0x8f,0x40] psrai.db t5, t5 -// CHECK-ASM: psrai.db t5, t5 # encoding: [0x1b,0xce,0x8e,0x40] - +# CHECK-ASM-AND-OBJ: psrai.dh s0, a2 +# CHECK-ASM: encoding: [0x1b,0xe4,0x06,0x41] psrai.dh s0, a2 -// CHECK-ASM: psrai.dh s0, a2 # encoding: [0x1b,0xc8,0x0c,0x41] - +# CHECK-ASM-AND-OBJ: psrai.dw t5, a0 +# CHECK-ASM: encoding: [0x1b,0xef,0x05,0x42] psrai.dw t5, a0 -// CHECK-ASM: psrai.dw t5, a0 # encoding: [0x1b,0xce,0x0a,0x42] - +# CHECK-ASM-AND-OBJ: psrari.dh a2, a2 +# CHECK-ASM: encoding: [0x1b,0xe6,0x06,0x51] psrari.dh a2, a2 -// CHECK-ASM: psrari.dh a2, a2 # encoding: [0x1b,0xcc,0x0c,0x51] - +# CHECK-ASM-AND-OBJ: psrari.dw a4, a0 +# CHECK-ASM: encoding: [0x1b,0xe7,0x05,0x52] psrari.dw a4, a0 -// CHECK-ASM: psrari.dw a4, a0 # encoding: [0x1b,0xce,0x0a,0x52] - +# CHECK-ASM-AND-OBJ: psati.dh s2, s2 +# CHECK-ASM: encoding: [0x1b,0xe9,0x09,0x61] psati.dh s2, s2 -// CHECK-ASM: psati.dh s2, s2 # encoding: [0x1b,0xc2,0x02,0x61] - +# CHECK-ASM-AND-OBJ: psati.dw t5, t3 +# CHECK-ASM: encoding: [0x1b,0xef,0x0e,0x62] psati.dw t5, t3 -// CHECK-ASM: psati.dw t5, t3 # encoding: [0x1b,0xce,0x0c,0x62] - +# CHECK-ASM-AND-OBJ: psrl.dhs a0, t1, t5 +# CHECK-ASM: encoding: [0x1b,0xe5,0xe3,0x09] psrl.dhs a0, t1, t5 -// CHECK-ASM: psrl.dhs a0, t1, t5 # encoding: [0x1b,0xea,0xe6,0x09] - +# CHECK-ASM-AND-OBJ: psrl.dws s0, s2, t1 +# CHECK-ASM: encoding: [0x1b,0xe4,0x69,0x0a] psrl.dws s0, s2, t1 -// CHECK-ASM: psrl.dws s0, s2, t1 # encoding: [0x1b,0xe8,0x62,0x0a] - +# CHECK-ASM-AND-OBJ: psrl.dbs a0, s0, t5 +# CHECK-ASM: encoding: [0x1b,0xe5,0xe4,0x0d] psrl.dbs a0, s0, t5 -// CHECK-ASM: psrl.dbs a0, s0, t5 # encoding: [0x1b,0xea,0xe8,0x0d] - +# CHECK-ASM-AND-OBJ: psra.dhs a4, t3, t1 +# CHECK-ASM: encoding: [0x1b,0xe7,0x6e,0x48] psra.dhs a4, t3, t1 -// CHECK-ASM: psra.dhs a4, t3, t1 # encoding: [0x1b,0xee,0x6c,0x48] - +# CHECK-ASM-AND-OBJ: psra.dws a2, s2, t1 +# CHECK-ASM: encoding: [0x1b,0xe6,0x69,0x4a] psra.dws a2, s2, t1 -// CHECK-ASM: psra.dws a2, s2, t1 # encoding: [0x1b,0xec,0x62,0x4a] - +# CHECK-ASM-AND-OBJ: psra.dbs s0, t1, t5 +# CHECK-ASM: encoding: [0x1b,0xe4,0xe3,0x4d] psra.dbs s0, t1, t5 -// CHECK-ASM: psra.dbs s0, t1, t5 # encoding: [0x1b,0xe8,0xe6,0x4d] - +# CHECK-ASM-AND-OBJ: padd.dh s2, a4, a2 +# CHECK-ASM: encoding: [0x1b,0x69,0xc7,0x80] padd.dh s2, a4, a2 -// CHECK-ASM: padd.dh s2, a4, a2 # encoding: [0x1b,0x62,0x8e,0x81] - +# CHECK-ASM-AND-OBJ: padd.dw a2, s2, a2 +# CHECK-ASM: encoding: [0x1b,0x66,0xc9,0x82] padd.dw a2, s2, a2 -// CHECK-ASM: padd.dw a2, s2, a2 # encoding: [0x1b,0x6c,0x82,0x83] - +# CHECK-ASM-AND-OBJ: padd.db a4, a2, a2 +# CHECK-ASM: encoding: [0x1b,0x67,0xc6,0x84] padd.db a4, a2, a2 -// CHECK-ASM: padd.db a4, a2, a2 # encoding: [0x1b,0x6e,0x8c,0x85] - +# CHECK-ASM-AND-OBJ: addd t1, s2, s0 +# CHECK-ASM: encoding: [0x1b,0x63,0x89,0x86] addd t1, s2, s0 -// CHECK-ASM: addd t1, s2, s0 # encoding: [0x1b,0x66,0x02,0x87] - +# CHECK-ASM-AND-OBJ: psadd.dh t3, s2, t3 +# CHECK-ASM: encoding: [0x1b,0x6e,0xc9,0x91] psadd.dh t3, s2, t3 -// CHECK-ASM: psadd.dh t3, s2, t3 # encoding: [0x1b,0x6c,0x82,0x91] - +# CHECK-ASM-AND-OBJ: psadd.dw a4, t3, t3 +# CHECK-ASM: encoding: [0x1b,0x67,0xce,0x93] psadd.dw a4, t3, t3 -// CHECK-ASM: psadd.dw a4, t3, t3 # encoding: [0x1b,0x6e,0x8c,0x93] - +# CHECK-ASM-AND-OBJ: psadd.db t5, s0, a2 +# CHECK-ASM: encoding: [0x1b,0x6f,0xc4,0x94] psadd.db t5, s0, a2 -// CHECK-ASM: psadd.db t5, s0, a2 # encoding: [0x1b,0x6e,0x88,0x95] - +# CHECK-ASM-AND-OBJ: paadd.dh t1, s2, a0 +# CHECK-ASM: encoding: [0x1b,0x63,0xa9,0x98] paadd.dh t1, s2, a0 -// CHECK-ASM: paadd.dh t1, s2, a0 # encoding: [0x1b,0x66,0x42,0x99] - +# CHECK-ASM-AND-OBJ: paadd.dw a4, a2, s0 +# CHECK-ASM: encoding: [0x1b,0x67,0x86,0x9a] paadd.dw a4, a2, s0 -// CHECK-ASM: paadd.dw a4, a2, s0 # encoding: [0x1b,0x6e,0x0c,0x9b] - +# CHECK-ASM-AND-OBJ: paadd.db t5, t3, s0 +# CHECK-ASM: encoding: [0x1b,0x6f,0x8e,0x9c] paadd.db t5, t3, s0 -// CHECK-ASM: paadd.db t5, t3, s0 # encoding: [0x1b,0x6e,0x0c,0x9d] - +# CHECK-ASM-AND-OBJ: psaddu.dh a4, a2, t5 +# CHECK-ASM: encoding: [0x1b,0x67,0xe6,0xb1] psaddu.dh a4, a2, t5 -// CHECK-ASM: psaddu.dh a4, a2, t5 # encoding: [0x1b,0x6e,0xcc,0xb1] - +# CHECK-ASM-AND-OBJ: psaddu.dw a4, t5, s2 +# CHECK-ASM: encoding: [0x1b,0x67,0x2f,0xb3] psaddu.dw a4, t5, s2 -// CHECK-ASM: psaddu.dw a4, t5, s2 # encoding: [0x1b,0x6e,0x4e,0xb2] - +# CHECK-ASM-AND-OBJ: psaddu.db a4, a0, t1 +# CHECK-ASM: encoding: [0x1b,0x67,0x65,0xb4] psaddu.db a4, a0, t1 -// CHECK-ASM: psaddu.db a4, a0, t1 # encoding: [0x1b,0x6e,0xca,0xb4] - +# CHECK-ASM-AND-OBJ: paaddu.dh a4, a4, s2 +# CHECK-ASM: encoding: [0x1b,0x67,0x27,0xb9] paaddu.dh a4, a4, s2 -// CHECK-ASM: paaddu.dh a4, a4, s2 # encoding: [0x1b,0x6e,0x4e,0xb8] - +# CHECK-ASM-AND-OBJ: paaddu.dw t3, s0, t5 +# CHECK-ASM: encoding: [0x1b,0x6e,0xe4,0xbb] paaddu.dw t3, s0, t5 -// CHECK-ASM: paaddu.dw t3, s0, t5 # encoding: [0x1b,0x6c,0xc8,0xbb] - +# CHECK-ASM-AND-OBJ: paaddu.db a0, s0, s0 +# CHECK-ASM: encoding: [0x1b,0x65,0x84,0xbc] paaddu.db a0, s0, s0 -// CHECK-ASM: paaddu.db a0, s0, s0 # encoding: [0x1b,0x6a,0x08,0xbd] - +# CHECK-ASM-AND-OBJ: psub.dh t5, a4, a4 +# CHECK-ASM: encoding: [0x1b,0x6f,0xe7,0xc0] psub.dh t5, a4, a4 -// CHECK-ASM: psub.dh t5, a4, a4 # encoding: [0x1b,0x6e,0xce,0xc1] - +# CHECK-ASM-AND-OBJ: psub.dw t1, s0, t5 +# CHECK-ASM: encoding: [0x1b,0x63,0xe4,0xc3] psub.dw t1, s0, t5 -// CHECK-ASM: psub.dw t1, s0, t5 # encoding: [0x1b,0x66,0xc8,0xc3] - +# CHECK-ASM-AND-OBJ: psub.db a4, a0, t5 +# CHECK-ASM: encoding: [0x1b,0x67,0xe5,0xc5] psub.db a4, a0, t5 -// CHECK-ASM: psub.db a4, a0, t5 # encoding: [0x1b,0x6e,0xca,0xc5] - +# CHECK-ASM-AND-OBJ: subd a2, a4, t1 +# CHECK-ASM: encoding: [0x1b,0x66,0x67,0xc6] subd a2, a4, t1 -// CHECK-ASM: subd a2, a4, t1 # encoding: [0x1b,0x6c,0xce,0xc6] - +# CHECK-ASM-AND-OBJ: pdif.dh t5, t1, t3 +# CHECK-ASM: encoding: [0x1b,0x6f,0xc3,0xc9] pdif.dh t5, t1, t3 -// CHECK-ASM: pdif.dh t5, t1, t3 # encoding: [0x1b,0x6e,0x86,0xc9] - +# CHECK-ASM-AND-OBJ: pdif.db t1, t5, a0 +# CHECK-ASM: encoding: [0x1b,0x63,0xaf,0xcc] pdif.db t1, t5, a0 -// CHECK-ASM: pdif.db t1, t5, a0 # encoding: [0x1b,0x66,0x4e,0xcd] - +# CHECK-ASM-AND-OBJ: pssub.dh s0, s2, s2 +# CHECK-ASM: encoding: [0x1b,0x64,0x29,0xd1] pssub.dh s0, s2, s2 -// CHECK-ASM: pssub.dh s0, s2, s2 # encoding: [0x1b,0x68,0x42,0xd0] - +# CHECK-ASM-AND-OBJ: pssub.dw t3, a2, t3 +# CHECK-ASM: encoding: [0x1b,0x6e,0xc6,0xd3] pssub.dw t3, a2, t3 -// CHECK-ASM: pssub.dw t3, a2, t3 # encoding: [0x1b,0x6c,0x8c,0xd3] - +# CHECK-ASM-AND-OBJ: pssub.db a0, s0, s2 +# CHECK-ASM: encoding: [0x1b,0x65,0x24,0xd5] pssub.db a0, s0, s2 -// CHECK-ASM: pssub.db a0, s0, s2 # encoding: [0x1b,0x6a,0x48,0xd4] - +# CHECK-ASM-AND-OBJ: pasub.dh t1, a4, s0 +# CHECK-ASM: encoding: [0x1b,0x63,0x87,0xd8] pasub.dh t1, a4, s0 -// CHECK-ASM: pasub.dh t1, a4, s0 # encoding: [0x1b,0x66,0x0e,0xd9] - +# CHECK-ASM-AND-OBJ: pasub.dw t1, s2, s2 +# CHECK-ASM: encoding: [0x1b,0x63,0x29,0xdb] pasub.dw t1, s2, s2 -// CHECK-ASM: pasub.dw t1, s2, s2 # encoding: [0x1b,0x66,0x42,0xda] - +# CHECK-ASM-AND-OBJ: pasub.db a0, a0, a0 +# CHECK-ASM: encoding: [0x1b,0x65,0xa5,0xdc] pasub.db a0, a0, a0 -// CHECK-ASM: pasub.db a0, a0, a0 # encoding: [0x1b,0x6a,0x4a,0xdd] - +# CHECK-ASM-AND-OBJ: pdifu.dh t5, a4, a4 +# CHECK-ASM: encoding: [0x1b,0x6f,0xe7,0xe8] pdifu.dh t5, a4, a4 -// CHECK-ASM: pdifu.dh t5, a4, a4 # encoding: [0x1b,0x6e,0xce,0xe9] - +# CHECK-ASM-AND-OBJ: pdifu.db t1, t1, a4 +# CHECK-ASM: encoding: [0x1b,0x63,0xe3,0xec] pdifu.db t1, t1, a4 -// CHECK-ASM: pdifu.db t1, t1, a4 # encoding: [0x1b,0x66,0xc6,0xed] - +# CHECK-ASM-AND-OBJ: pssubu.dh t5, t1, t5 +# CHECK-ASM: encoding: [0x1b,0x6f,0xe3,0xf1] pssubu.dh t5, t1, t5 -// CHECK-ASM: pssubu.dh t5, t1, t5 # encoding: [0x1b,0x6e,0xc6,0xf1] - +# CHECK-ASM-AND-OBJ: pssubu.dw a4, a4, t1 +# CHECK-ASM: encoding: [0x1b,0x67,0x67,0xf2] pssubu.dw a4, a4, t1 -// CHECK-ASM: pssubu.dw a4, a4, t1 # encoding: [0x1b,0x6e,0xce,0xf2] - +# CHECK-ASM-AND-OBJ: pssubu.db s0, t5, a2 +# CHECK-ASM: encoding: [0x1b,0x64,0xcf,0xf4] pssubu.db s0, t5, a2 -// CHECK-ASM: pssubu.db s0, t5, a2 # encoding: [0x1b,0x68,0x8e,0xf5] - +# CHECK-ASM-AND-OBJ: pasubu.dh t5, a2, a2 +# CHECK-ASM: encoding: [0x1b,0x6f,0xc6,0xf8] pasubu.dh t5, a2, a2 -// CHECK-ASM: pasubu.dh t5, a2, a2 # encoding: [0x1b,0x6e,0x8c,0xf9] - +# CHECK-ASM-AND-OBJ: pasubu.dw a0, a2, a4 +# CHECK-ASM: encoding: [0x1b,0x65,0xe6,0xfa] pasubu.dw a0, a2, a4 -// CHECK-ASM: pasubu.dw a0, a2, a4 # encoding: [0x1b,0x6a,0xcc,0xfb] - +# CHECK-ASM-AND-OBJ: pasubu.db a0, s0, s0 +# CHECK-ASM: encoding: [0x1b,0x65,0x84,0xfc] pasubu.db a0, s0, s0 -// CHECK-ASM: pasubu.db a0, s0, s0 # encoding: [0x1b,0x6a,0x08,0xfd] - +# CHECK-ASM-AND-OBJ: psh1add.dh t5, a4, t5 +# CHECK-ASM: encoding: [0x1b,0x6f,0xf7,0xa1] psh1add.dh t5, a4, t5 -// CHECK-ASM: psh1add.dh t5, a4, t5 # encoding: [0x1b,0x6e,0xde,0xa1] - +# CHECK-ASM-AND-OBJ: psh1add.dw a4, t5, s0 +# CHECK-ASM: encoding: [0x1b,0x67,0x9f,0xa2] psh1add.dw a4, t5, s0 -// CHECK-ASM: psh1add.dw a4, t5, s0 # encoding: [0x1b,0x6e,0x1e,0xa3] - +# CHECK-ASM-AND-OBJ: pssh1sadd.dh t3, a4, a0 +# CHECK-ASM: encoding: [0x1b,0x6e,0xb7,0xb0] pssh1sadd.dh t3, a4, a0 -// CHECK-ASM: pssh1sadd.dh t3, a4, a0 # encoding: [0x1b,0x6c,0x5e,0xb1] - +# CHECK-ASM-AND-OBJ: pssh1sadd.dw t1, t1, a2 +# CHECK-ASM: encoding: [0x1b,0x63,0xd3,0xb2] pssh1sadd.dw t1, t1, a2 -// CHECK-ASM: pssh1sadd.dw t1, t1, a2 # encoding: [0x1b,0x66,0x96,0xb3] - +# CHECK-ASM-AND-OBJ: ppack.dh a2, t1, s2 +# CHECK-ASM: encoding: [0x1b,0xe6,0x23,0x81] ppack.dh a2, t1, s2 -// CHECK-ASM: ppack.dh a2, t1, s2 # encoding: [0x1b,0xec,0x46,0x80] - +# CHECK-ASM-AND-OBJ: ppack.dw t5, t3, a4 +# CHECK-ASM: encoding: [0x1b,0xef,0xee,0x82] ppack.dw t5, t3, a4 -// CHECK-ASM: ppack.dw t5, t3, a4 # encoding: [0x1b,0xee,0xcc,0x83] - +# CHECK-ASM-AND-OBJ: ppackbt.dh t1, t3, t1 +# CHECK-ASM: encoding: [0x1b,0xe3,0x6e,0x90] ppackbt.dh t1, t3, t1 -// CHECK-ASM: ppackbt.dh t1, t3, t1 # encoding: [0x1b,0xe6,0xcc,0x90] - +# CHECK-ASM-AND-OBJ: ppackbt.dw a4, t5, a2 +# CHECK-ASM: encoding: [0x1b,0xe7,0xcf,0x92] ppackbt.dw a4, t5, a2 -// CHECK-ASM: ppackbt.dw a4, t5, a2 # encoding: [0x1b,0xee,0x8e,0x93] - +# CHECK-ASM-AND-OBJ: ppacktb.dh a4, t1, a2 +# CHECK-ASM: encoding: [0x1b,0xe7,0xc3,0xa0] ppacktb.dh a4, t1, a2 -// CHECK-ASM: ppacktb.dh a4, t1, a2 # encoding: [0x1b,0xee,0x86,0xa1] - +# CHECK-ASM-AND-OBJ: ppacktb.dw a2, t5, s0 +# CHECK-ASM: encoding: [0x1b,0xe6,0x8f,0xa2] ppacktb.dw a2, t5, s0 -// CHECK-ASM: ppacktb.dw a2, t5, s0 # encoding: [0x1b,0xec,0x0e,0xa3] - +# CHECK-ASM-AND-OBJ: ppackt.dh a0, a0, s0 +# CHECK-ASM: encoding: [0x1b,0xe5,0x85,0xb0] ppackt.dh a0, a0, s0 -// CHECK-ASM: ppackt.dh a0, a0, s0 # encoding: [0x1b,0xea,0x0a,0xb1] - +# CHECK-ASM-AND-OBJ: ppackt.dw a4, a4, a2 +# CHECK-ASM: encoding: [0x1b,0xe7,0xc7,0xb2] ppackt.dw a4, a4, a2 -// CHECK-ASM: ppackt.dw a4, a4, a2 # encoding: [0x1b,0xee,0x8e,0xb3] - +# CHECK-ASM-AND-OBJ: pas.dhx t3, t3, s2 +# CHECK-ASM: encoding: [0x1b,0xee,0x3e,0x81] pas.dhx t3, t3, s2 -// CHECK-ASM: pas.dhx t3, t3, s2 # encoding: [0x1b,0xec,0x5c,0x80] - +# CHECK-ASM-AND-OBJ: psa.dhx a0, s2, a2 +# CHECK-ASM: encoding: [0x1b,0xe5,0xd9,0x84] psa.dhx a0, s2, a2 -// CHECK-ASM: psa.dhx a0, s2, a2 # encoding: [0x1b,0xea,0x92,0x85] - +# CHECK-ASM-AND-OBJ: psas.dhx a2, a2, s0 +# CHECK-ASM: encoding: [0x1b,0xe6,0x96,0x90] psas.dhx a2, a2, s0 -// CHECK-ASM: psas.dhx a2, a2, s0 # encoding: [0x1b,0xec,0x1c,0x91] - +# CHECK-ASM-AND-OBJ: pssa.dhx t3, t3, t3 +# CHECK-ASM: encoding: [0x1b,0xee,0xde,0x95] pssa.dhx t3, t3, t3 -// CHECK-ASM: pssa.dhx t3, t3, t3 # encoding: [0x1b,0xec,0x9c,0x95] - +# CHECK-ASM-AND-OBJ: paax.dhx t3, t3, a4 +# CHECK-ASM: encoding: [0x1b,0xee,0xfe,0x98] paax.dhx t3, t3, a4 -// CHECK-ASM: paax.dhx t3, t3, a4 # encoding: [0x1b,0xec,0xdc,0x99] - +# CHECK-ASM-AND-OBJ: pasa.dhx a0, t1, t1 +# CHECK-ASM: encoding: [0x1b,0xe5,0x73,0x9c] pasa.dhx a0, t1, t1 -// CHECK-ASM: pasa.dhx a0, t1, t1 # encoding: [0x1b,0xea,0xd6,0x9c] - +# CHECK-ASM-AND-OBJ: pmseq.dh a4, t1, t3 +# CHECK-ASM: encoding: [0x1b,0xe7,0xd3,0xc1] pmseq.dh a4, t1, t3 -// CHECK-ASM: pmseq.dh a4, t1, t3 # encoding: [0x1b,0xee,0x96,0xc1] - +# CHECK-ASM-AND-OBJ: pmseq.dw t1, s0, a2 +# CHECK-ASM: encoding: [0x1b,0xe3,0xd4,0xc2] pmseq.dw t1, s0, a2 -// CHECK-ASM: pmseq.dw t1, s0, a2 # encoding: [0x1b,0xe6,0x98,0xc3] - +# CHECK-ASM-AND-OBJ: pmseq.db a2, a2, t5 +# CHECK-ASM: encoding: [0x1b,0xe6,0xf6,0xc5] pmseq.db a2, a2, t5 -// CHECK-ASM: pmseq.db a2, a2, t5 # encoding: [0x1b,0xec,0xdc,0xc5] - +# CHECK-ASM-AND-OBJ: pmslt.dh s2, t5, s2 +# CHECK-ASM: encoding: [0x1b,0xe9,0x3f,0xd1] pmslt.dh s2, t5, s2 -// CHECK-ASM: pmslt.dh s2, t5, s2 # encoding: [0x1b,0xe2,0x5e,0xd0] - +# CHECK-ASM-AND-OBJ: pmslt.dw t1, t1, a2 +# CHECK-ASM: encoding: [0x1b,0xe3,0xd3,0xd2] pmslt.dw t1, t1, a2 -// CHECK-ASM: pmslt.dw t1, t1, a2 # encoding: [0x1b,0xe6,0x96,0xd3] - +# CHECK-ASM-AND-OBJ: pmslt.db t5, s0, s2 +# CHECK-ASM: encoding: [0x1b,0xef,0x34,0xd5] pmslt.db t5, s0, s2 -// CHECK-ASM: pmslt.db t5, s0, s2 # encoding: [0x1b,0xee,0x58,0xd4] - +# CHECK-ASM-AND-OBJ: pmsltu.dh s2, a0, s2 +# CHECK-ASM: encoding: [0x1b,0xe9,0x35,0xd9] pmsltu.dh s2, a0, s2 -// CHECK-ASM: pmsltu.dh s2, a0, s2 # encoding: [0x1b,0xe2,0x5a,0xd8] - +# CHECK-ASM-AND-OBJ: pmsltu.dw s0, t3, a0 +# CHECK-ASM: encoding: [0x1b,0xe4,0xbe,0xda] pmsltu.dw s0, t3, a0 -// CHECK-ASM: pmsltu.dw s0, t3, a0 # encoding: [0x1b,0xe8,0x5c,0xdb] - +# CHECK-ASM-AND-OBJ: pmsltu.db s0, t3, t3 +# CHECK-ASM: encoding: [0x1b,0xe4,0xde,0xdd] pmsltu.db s0, t3, t3 -// CHECK-ASM: pmsltu.db s0, t3, t3 # encoding: [0x1b,0xe8,0x9c,0xdd] - +# CHECK-ASM-AND-OBJ: pmin.dh a2, s0, t3 +# CHECK-ASM: encoding: [0x1b,0xe6,0xd4,0xe1] pmin.dh a2, s0, t3 -// CHECK-ASM: pmin.dh a2, s0, t3 # encoding: [0x1b,0xec,0x98,0xe1] - +# CHECK-ASM-AND-OBJ: pmin.db t3, s2, t3 +# CHECK-ASM: encoding: [0x1b,0xee,0xd9,0xe5] pmin.db t3, s2, t3 -// CHECK-ASM: pmin.db t3, s2, t3 # encoding: [0x1b,0xec,0x92,0xe5] - +# CHECK-ASM-AND-OBJ: pminu.dh t1, t3, t5 +# CHECK-ASM: encoding: [0x1b,0xe3,0xfe,0xe9] pminu.dh t1, t3, t5 -// CHECK-ASM: pminu.dh t1, t3, t5 # encoding: [0x1b,0xe6,0xdc,0xe9] - +# CHECK-ASM-AND-OBJ: pminu.db t1, s0, a2 +# CHECK-ASM: encoding: [0x1b,0xe3,0xd4,0xec] pminu.db t1, s0, a2 -// CHECK-ASM: pminu.db t1, s0, a2 # encoding: [0x1b,0xe6,0x98,0xed] - +# CHECK-ASM-AND-OBJ: pmax.dh a0, a0, a0 +# CHECK-ASM: encoding: [0x1b,0xe5,0xb5,0xf0] pmax.dh a0, a0, a0 -// CHECK-ASM: pmax.dh a0, a0, a0 # encoding: [0x1b,0xea,0x5a,0xf1] - +# CHECK-ASM-AND-OBJ: pmax.db a2, a2, s2 +# CHECK-ASM: encoding: [0x1b,0xe6,0x36,0xf5] pmax.db a2, a2, s2 -// CHECK-ASM: pmax.db a2, a2, s2 # encoding: [0x1b,0xec,0x5c,0xf4] - +# CHECK-ASM-AND-OBJ: pmaxu.dh a4, t3, s0 +# CHECK-ASM: encoding: [0x1b,0xe7,0x9e,0xf8] pmaxu.dh a4, t3, s0 -// CHECK-ASM: pmaxu.dh a4, t3, s0 # encoding: [0x1b,0xee,0x1c,0xf9] - +# CHECK-ASM-AND-OBJ: pmaxu.db a4, t5, a0 +# CHECK-ASM: encoding: [0x1b,0xe7,0xbf,0xfc] 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-valid.s b/llvm/test/MC/RISCV/rv64p-valid.s index bc650a79ab1c1..7ca3c4159ddd3 100644 --- a/llvm/test/MC/RISCV/rv64p-valid.s +++ b/llvm/test/MC/RISCV/rv64p-valid.s @@ -1,911 +1,915 @@ -// NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --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] +# RUN: | FileCheck -check-prefixes=CHECK-ASM,CHECK-ASM-AND-OBJ %s +# RUN: llvm-mc -filetype=obj --triple=riscv64 -mattr=+experimental-p < %s \ +# RUN: | llvm-objdump --triple=riscv64 --mattr=+experimental-p -M no-aliases --no-print-imm-hex -d -r - \ +# RUN: | FileCheck --check-prefix=CHECK-ASM-AND-OBJ %s +# CHECK-ASM-AND-OBJ: clz a0, a1 +# CHECK-ASM: encoding: [0x13,0x95,0x05,0x60] +clz a0, a1 +# CHECK-ASM-AND-OBJ: cls a1, a2 +# CHECK-ASM: encoding: [0x93,0x15,0x36,0x60] cls a1, a2 -// CHECK-ASM: cls a1, a2 # encoding: [0x93,0x15,0x36,0x60] - +# CHECK-ASM-AND-OBJ: sext.b a2, a3 +# CHECK-ASM: encoding: [0x13,0x96,0x46,0x60] sext.b a2, a3 -// CHECK-ASM: sext.b a2, a3 # encoding: [0x13,0x96,0x46,0x60] - +# CHECK-ASM-AND-OBJ: sext.h t0, t1 +# CHECK-ASM: encoding: [0x93,0x12,0x53,0x60] sext.h t0, t1 -// CHECK-ASM: sext.h t0, t1 # encoding: [0x93,0x12,0x53,0x60] - +# CHECK-ASM-AND-OBJ: abs a4, a5 +# CHECK-ASM: encoding: [0x13,0x97,0x77,0x60] abs a4, a5 -// CHECK-ASM: abs a4, a5 # encoding: [0x13,0x97,0x77,0x60] - +# CHECK-ASM-AND-OBJ: rev16 s0, s1 +# CHECK-ASM: encoding: [0x13,0xd4,0x04,0x6b] rev16 s0, s1 -// CHECK-ASM: rev16 s0, s1 # encoding: [0x13,0xd4,0x04,0x6b] - +# CHECK-ASM-AND-OBJ: rev8 s0, s1 +# CHECK-ASM: encoding: [0x13,0xd4,0x84,0x6b] rev8 s0, s1 -// CHECK-ASM: rev8 s0, s1 # encoding: [0x13,0xd4,0x84,0x6b] - +# CHECK-ASM-AND-OBJ: rev s2, s3 +# CHECK-ASM: encoding: [0x13,0xd9,0xf9,0x7b] rev s2, s3 -// CHECK-ASM: rev s2, s3 # encoding: [0x13,0xd9,0xf9,0x7b] - +# CHECK-ASM-AND-OBJ: clzw s0, s1 +# CHECK-ASM: encoding: [0x1b,0x94,0x04,0x60] clzw s0, s1 -// CHECK-ASM: clzw s0, s1 # encoding: [0x1b,0x94,0x04,0x60] - +# CHECK-ASM-AND-OBJ: clsw s2, s3 +# CHECK-ASM: encoding: [0x1b,0x99,0x39,0x60] clsw s2, s3 -// CHECK-ASM: clsw s2, s3 # encoding: [0x1b,0x99,0x39,0x60] - +# CHECK-ASM-AND-OBJ: absw s2, s3 +# CHECK-ASM: encoding: [0x1b,0x99,0x79,0x60] absw s2, s3 -// CHECK-ASM: absw s2, s3 # encoding: [0x1b,0x99,0x79,0x60] - +# CHECK-ASM-AND-OBJ: sh1add a0, a1, a2 +# CHECK-ASM: encoding: [0x33,0xa5,0xc5,0x20] sh1add a0, a1, a2 -// CHECK-ASM: sh1add a0, a1, a2 # encoding: [0x33,0xa5,0xc5,0x20] - +# CHECK-ASM-AND-OBJ: pack s0, s1, s2 +# CHECK-ASM: encoding: [0x33,0xc4,0x24,0x09] pack s0, s1, s2 -// CHECK-ASM: pack s0, s1, s2 # encoding: [0x33,0xc4,0x24,0x09] - +# CHECK-ASM-AND-OBJ: min t0, t1, t2 +# CHECK-ASM: encoding: [0xb3,0x42,0x73,0x0a] 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] - +# CHECK-ASM-AND-OBJ: minu ra, sp, gp +# CHECK-ASM: encoding: [0xb3,0x50,0x31,0x0a] +minu ra, sp, gp +# CHECK-ASM-AND-OBJ: max t3, t4, t5 +# CHECK-ASM: encoding: [0x33,0xee,0xee,0x0b] max t3, t4, t5 -// CHECK-ASM: max t3, t4, t5 # encoding: [0x33,0xee,0xee,0x0b] - +# CHECK-ASM-AND-OBJ: maxu a4, a5, a6 +# CHECK-ASM: encoding: [0x33,0xf7,0x07,0x0b] maxu a4, a5, a6 -// CHECK-ASM: maxu a4, a5, a6 # encoding: [0x33,0xf7,0x07,0x0b] - +# CHECK-ASM-AND-OBJ: pslli.b a6, a7 +# CHECK-ASM: encoding: [0x1b,0xa8,0x88,0x80] 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] - +# CHECK-ASM-AND-OBJ: pslli.h ra, sp +# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x81] +pslli.h ra, sp +# CHECK-ASM-AND-OBJ: pslli.w ra, sp +# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x82] +pslli.w ra, sp +# CHECK-ASM-AND-OBJ: psslai.h t0, t1 +# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] psslai.h t0, t1 -// CHECK-ASM: psslai.h t0, t1 # encoding: [0x9b,0x22,0x03,0x51] - +# CHECK-ASM-AND-OBJ: psslai.w a4, a5 +# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] 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] - +# CHECK-ASM-AND-OBJ: pli.h a5, 5 +# CHECK-ASM: encoding: [0x9b,0xa7,0x02,0xb0] +pli.h a5, 5 +# CHECK-ASM-AND-OBJ: pli.w a5, 5 +# CHECK-ASM: encoding: [0x9b,0xa7,0x02,0xb2] +pli.w a5, 5 +# CHECK-ASM-AND-OBJ: pli.b a6, 6 +# CHECK-ASM: encoding: [0x1b,0x28,0x06,0xb4] +pli.b a6, 6 +# CHECK-ASM-AND-OBJ: psext.h.b t3, a2 +# CHECK-ASM: encoding: [0x1b,0x2e,0x46,0xe0] psext.h.b t3, a2 -// CHECK-ASM: psext.h.b t3, a2 # encoding: [0x1b,0x2e,0x46,0xe0] - +# CHECK-ASM-AND-OBJ: psext.w.b a2, s0 +# CHECK-ASM: encoding: [0x1b,0x26,0x44,0xe2] psext.w.b a2, s0 -// CHECK-ASM: psext.w.b a2, s0 # encoding: [0x1b,0x26,0x44,0xe2] - +# CHECK-ASM-AND-OBJ: psext.w.h t1, t3 +# CHECK-ASM: encoding: [0x1b,0x23,0x5e,0xe2] psext.w.h t1, t3 -// CHECK-ASM: psext.w.h t1, t3 # encoding: [0x1b,0x23,0x5e,0xe2] - +# CHECK-ASM-AND-OBJ: psabs.h t1, t5 +# CHECK-ASM: encoding: [0x1b,0x23,0x7f,0xe0] psabs.h t1, t5 -// CHECK-ASM: psabs.h t1, t5 # encoding: [0x1b,0x23,0x7f,0xe0] - +# CHECK-ASM-AND-OBJ: psabs.b a0, s2 +# CHECK-ASM: encoding: [0x1b,0x25,0x79,0xe4] 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] - +# CHECK-ASM-AND-OBJ: plui.h s2, 4 +# CHECK-ASM: encoding: [0x1b,0x29,0x02,0xf0] +plui.h s2, 4 +# CHECK-ASM-AND-OBJ: plui.w a2, 1 +# CHECK-ASM: encoding: [0x1b,0xa6,0x00,0xf2] +plui.w a2, 1 +# CHECK-ASM-AND-OBJ: psll.hs s0, a2, s2 +# CHECK-ASM: encoding: [0x1b,0x24,0x26,0x89] psll.hs s0, a2, s2 -// CHECK-ASM: psll.hs s0, a2, s2 # encoding: [0x1b,0x24,0x26,0x89] - +# CHECK-ASM-AND-OBJ: psll.bs a0, t3, t5 +# CHECK-ASM: encoding: [0x1b,0x25,0xee,0x8d] psll.bs a0, t3, t5 -// CHECK-ASM: psll.bs a0, t3, t5 # encoding: [0x1b,0x25,0xee,0x8d] - +# CHECK-ASM-AND-OBJ: padd.hs t1, a2, s0 +# CHECK-ASM: encoding: [0x1b,0x23,0x86,0x98] padd.hs t1, a2, s0 -// CHECK-ASM: padd.hs t1, a2, s0 # encoding: [0x1b,0x23,0x86,0x98] - +# CHECK-ASM-AND-OBJ: padd.bs t3, t1, t3 +# CHECK-ASM: encoding: [0x1b,0x2e,0xc3,0x9d] padd.bs t3, t1, t3 -// CHECK-ASM: padd.bs t3, t1, t3 # encoding: [0x1b,0x2e,0xc3,0x9d] - +# CHECK-ASM-AND-OBJ: pssha.hs s0, t1, a2 +# CHECK-ASM: encoding: [0x1b,0x24,0xc3,0xe8] pssha.hs s0, t1, a2 -// CHECK-ASM: pssha.hs s0, t1, a2 # encoding: [0x1b,0x24,0xc3,0xe8] - +# CHECK-ASM-AND-OBJ: psshar.hs s2, t5, t3 +# CHECK-ASM: encoding: [0x1b,0x29,0xcf,0xf9] psshar.hs s2, t5, t3 -// CHECK-ASM: psshar.hs s2, t5, t3 # encoding: [0x1b,0x29,0xcf,0xf9] - +# CHECK-ASM-AND-OBJ: psll.ws s0, t1, a0 +# CHECK-ASM: encoding: [0x1b,0x24,0xa3,0x8a] psll.ws s0, t1, a0 -// CHECK-ASM: psll.ws s0, t1, a0 # encoding: [0x1b,0x24,0xa3,0x8a] - +# CHECK-ASM-AND-OBJ: padd.ws s2, a2, a0 +# CHECK-ASM: encoding: [0x1b,0x29,0xa6,0x9a] padd.ws s2, a2, a0 -// CHECK-ASM: padd.ws s2, a2, a0 # encoding: [0x1b,0x29,0xa6,0x9a] - +# CHECK-ASM-AND-OBJ: pssha.ws a4, a2, t1 +# CHECK-ASM: encoding: [0x1b,0x27,0x66,0xea] pssha.ws a4, a2, t1 -// CHECK-ASM: pssha.ws a4, a2, t1 # encoding: [0x1b,0x27,0x66,0xea] - +# CHECK-ASM-AND-OBJ: psshar.ws a2, a0, a4 +# CHECK-ASM: encoding: [0x1b,0x26,0xe5,0xfa] psshar.ws a2, a0, a4 -// CHECK-ASM: psshar.ws a2, a0, a4 # encoding: [0x1b,0x26,0xe5,0xfa] - +# CHECK-ASM-AND-OBJ: sha a0, t5, t5 +# CHECK-ASM: encoding: [0x1b,0x25,0xef,0xef] sha a0, t5, t5 -// CHECK-ASM: sha a0, t5, t5 # encoding: [0x1b,0x25,0xef,0xef] - +# CHECK-ASM-AND-OBJ: shar t5, t5, t3 +# CHECK-ASM: encoding: [0x1b,0x2f,0xcf,0xff] shar t5, t5, t3 -// CHECK-ASM: shar t5, t5, t3 # encoding: [0x1b,0x2f,0xcf,0xff] - +# CHECK-ASM-AND-OBJ: psrli.b t1, a0 +# CHECK-ASM: encoding: [0x1b,0x43,0x85,0x80] psrli.b t1, a0 -// CHECK-ASM: psrli.b t1, a0 # encoding: [0x1b,0x43,0x85,0x80] - +# CHECK-ASM-AND-OBJ: psrli.h a4, s0 +# CHECK-ASM: encoding: [0x1b,0x47,0x04,0x81] psrli.h a4, s0 -// CHECK-ASM: psrli.h a4, s0 # encoding: [0x1b,0x47,0x04,0x81] - +# CHECK-ASM-AND-OBJ: pusati.h t3, s0 +# CHECK-ASM: encoding: [0x1b,0x4e,0x04,0xa1] pusati.h t3, s0 -// CHECK-ASM: pusati.h t3, s0 # encoding: [0x1b,0x4e,0x04,0xa1] - +# CHECK-ASM-AND-OBJ: psrai.b t1, t1 +# CHECK-ASM: encoding: [0x1b,0x43,0x83,0xc0] psrai.b t1, t1 -// CHECK-ASM: psrai.b t1, t1 # encoding: [0x1b,0x43,0x83,0xc0] - +# CHECK-ASM-AND-OBJ: psrai.h a2, t5 +# CHECK-ASM: encoding: [0x1b,0x46,0x0f,0xc1] psrai.h a2, t5 -// CHECK-ASM: psrai.h a2, t5 # encoding: [0x1b,0x46,0x0f,0xc1] - +# CHECK-ASM-AND-OBJ: psrari.h t1, t5 +# CHECK-ASM: encoding: [0x1b,0x43,0x0f,0xd1] psrari.h t1, t5 -// CHECK-ASM: psrari.h t1, t5 # encoding: [0x1b,0x43,0x0f,0xd1] - +# CHECK-ASM-AND-OBJ: psati.h a2, s2 +# CHECK-ASM: encoding: [0x1b,0x46,0x09,0xe1] psati.h a2, s2 -// CHECK-ASM: psati.h a2, s2 # encoding: [0x1b,0x46,0x09,0xe1] - +# CHECK-ASM-AND-OBJ: psrli.w s2, a0 +# CHECK-ASM: encoding: [0x1b,0x49,0x05,0x82] psrli.w s2, a0 -// CHECK-ASM: psrli.w s2, a0 # encoding: [0x1b,0x49,0x05,0x82] - +# CHECK-ASM-AND-OBJ: pusati.w t3, a4 +# CHECK-ASM: encoding: [0x1b,0x4e,0x07,0xa2] pusati.w t3, a4 -// CHECK-ASM: pusati.w t3, a4 # encoding: [0x1b,0x4e,0x07,0xa2] - +# CHECK-ASM-AND-OBJ: usati s0, a2 +# CHECK-ASM: encoding: [0x1b,0x44,0x06,0xa4] usati s0, a2 -// CHECK-ASM: usati s0, a2 # encoding: [0x1b,0x44,0x06,0xa4] - +# CHECK-ASM-AND-OBJ: psrl.hs a2, t3, t3 +# CHECK-ASM: encoding: [0x1b,0x46,0xce,0x89] psrl.hs a2, t3, t3 -// CHECK-ASM: psrl.hs a2, t3, t3 # encoding: [0x1b,0x46,0xce,0x89] - +# CHECK-ASM-AND-OBJ: psrl.bs s0, t1, s0 +# CHECK-ASM: encoding: [0x1b,0x44,0x83,0x8c] psrl.bs s0, t1, s0 -// CHECK-ASM: psrl.bs s0, t1, s0 # encoding: [0x1b,0x44,0x83,0x8c] - +# CHECK-ASM-AND-OBJ: predsum.hs t5, a0, a2 +# CHECK-ASM: encoding: [0x1b,0x4f,0xc5,0x98] predsum.hs t5, a0, a2 -// CHECK-ASM: predsum.hs t5, a0, a2 # encoding: [0x1b,0x4f,0xc5,0x98] - +# CHECK-ASM-AND-OBJ: predsum.bs t5, a4, s2 +# CHECK-ASM: encoding: [0x1b,0x4f,0x27,0x9d] predsum.bs t5, a4, s2 -// CHECK-ASM: predsum.bs t5, a4, s2 # encoding: [0x1b,0x4f,0x27,0x9d] - +# CHECK-ASM-AND-OBJ: predsumu.hs a2, s2, a0 +# CHECK-ASM: encoding: [0x1b,0x46,0xa9,0xb8] predsumu.hs a2, s2, a0 -// CHECK-ASM: predsumu.hs a2, s2, a0 # encoding: [0x1b,0x46,0xa9,0xb8] - +# CHECK-ASM-AND-OBJ: predsumu.bs s2, s0, t1 +# CHECK-ASM: encoding: [0x1b,0x49,0x64,0xbc] predsumu.bs s2, s0, t1 -// CHECK-ASM: predsumu.bs s2, s0, t1 # encoding: [0x1b,0x49,0x64,0xbc] - +# CHECK-ASM-AND-OBJ: psra.hs a0, t3, s2 +# CHECK-ASM: encoding: [0x1b,0x45,0x2e,0xc9] psra.hs a0, t3, s2 -// CHECK-ASM: psra.hs a0, t3, s2 # encoding: [0x1b,0x45,0x2e,0xc9] - +# CHECK-ASM-AND-OBJ: psra.bs a4, t5, a4 +# CHECK-ASM: encoding: [0x1b,0x47,0xef,0xcc] psra.bs a4, t5, a4 -// CHECK-ASM: psra.bs a4, t5, a4 # encoding: [0x1b,0x47,0xef,0xcc] - +# CHECK-ASM-AND-OBJ: psrl.ws t3, t1, a2 +# CHECK-ASM: encoding: [0x1b,0x4e,0xc3,0x8a] psrl.ws t3, t1, a2 -// CHECK-ASM: psrl.ws t3, t1, a2 # encoding: [0x1b,0x4e,0xc3,0x8a] - +# CHECK-ASM-AND-OBJ: predsum.ws s2, a2, t5 +# CHECK-ASM: encoding: [0x1b,0x49,0xe6,0x9b] predsum.ws s2, a2, t5 -// CHECK-ASM: predsum.ws s2, a2, t5 # encoding: [0x1b,0x49,0xe6,0x9b] - +# CHECK-ASM-AND-OBJ: predsumu.ws s2, a0, a2 +# CHECK-ASM: encoding: [0x1b,0x49,0xc5,0xba] predsumu.ws s2, a0, a2 -// CHECK-ASM: predsumu.ws s2, a0, a2 # encoding: [0x1b,0x49,0xc5,0xba] - +# CHECK-ASM-AND-OBJ: psra.ws t5, a0, t5 +# CHECK-ASM: encoding: [0x1b,0x4f,0xe5,0xcb] psra.ws t5, a0, t5 -// CHECK-ASM: psra.ws t5, a0, t5 # encoding: [0x1b,0x4f,0xe5,0xcb] - +# CHECK-ASM-AND-OBJ: padd.h t1, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x03,0x2f,0x81] padd.h t1, t5, s2 -// CHECK-ASM: padd.h t1, t5, s2 # encoding: [0x3b,0x03,0x2f,0x81] - +# CHECK-ASM-AND-OBJ: padd.b t5, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x0f,0x64,0x84] padd.b t5, s0, t1 -// CHECK-ASM: padd.b t5, s0, t1 # encoding: [0x3b,0x0f,0x64,0x84] - +# CHECK-ASM-AND-OBJ: psadd.h a2, a2, s2 +# CHECK-ASM: encoding: [0x3b,0x06,0x26,0x91] psadd.h a2, a2, s2 -// CHECK-ASM: psadd.h a2, a2, s2 # encoding: [0x3b,0x06,0x26,0x91] - +# CHECK-ASM-AND-OBJ: psadd.b t1, a0, s0 +# CHECK-ASM: encoding: [0x3b,0x03,0x85,0x94] psadd.b t1, a0, s0 -// CHECK-ASM: psadd.b t1, a0, s0 # encoding: [0x3b,0x03,0x85,0x94] - +# CHECK-ASM-AND-OBJ: paadd.h t5, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x0f,0xc4,0x99] paadd.h t5, s0, t3 -// CHECK-ASM: paadd.h t5, s0, t3 # encoding: [0x3b,0x0f,0xc4,0x99] - +# CHECK-ASM-AND-OBJ: paadd.b a4, s2, a4 +# CHECK-ASM: encoding: [0x3b,0x07,0xe9,0x9c] paadd.b a4, s2, a4 -// CHECK-ASM: paadd.b a4, s2, a4 # encoding: [0x3b,0x07,0xe9,0x9c] - +# CHECK-ASM-AND-OBJ: psaddu.h a0, t1, t1 +# CHECK-ASM: encoding: [0x3b,0x05,0x63,0xb0] psaddu.h a0, t1, t1 -// CHECK-ASM: psaddu.h a0, t1, t1 # encoding: [0x3b,0x05,0x63,0xb0] - +# CHECK-ASM-AND-OBJ: psaddu.b t3, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x0e,0xe6,0xb4] psaddu.b t3, a2, a4 -// CHECK-ASM: psaddu.b t3, a2, a4 # encoding: [0x3b,0x0e,0xe6,0xb4] - +# CHECK-ASM-AND-OBJ: paaddu.h t3, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x0e,0xc9,0xb8] paaddu.h t3, s2, a2 -// CHECK-ASM: paaddu.h t3, s2, a2 # encoding: [0x3b,0x0e,0xc9,0xb8] - +# CHECK-ASM-AND-OBJ: paaddu.b t3, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x0e,0xc5,0xbd] paaddu.b t3, a0, t3 -// CHECK-ASM: paaddu.b t3, a0, t3 # encoding: [0x3b,0x0e,0xc5,0xbd] - +# CHECK-ASM-AND-OBJ: psub.h s0, s2, t3 +# CHECK-ASM: encoding: [0x3b,0x04,0xc9,0xc1] psub.h s0, s2, t3 -// CHECK-ASM: psub.h s0, s2, t3 # encoding: [0x3b,0x04,0xc9,0xc1] - +# CHECK-ASM-AND-OBJ: psub.b t5, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x0f,0xe3,0xc4] psub.b t5, t1, a4 -// CHECK-ASM: psub.b t5, t1, a4 # encoding: [0x3b,0x0f,0xe3,0xc4] - +# CHECK-ASM-AND-OBJ: pdif.h t1, a4, a2 +# CHECK-ASM: encoding: [0x3b,0x03,0xc7,0xc8] pdif.h t1, a4, a2 -// CHECK-ASM: pdif.h t1, a4, a2 # encoding: [0x3b,0x03,0xc7,0xc8] - +# CHECK-ASM-AND-OBJ: pdif.b t3, t1, t5 +# CHECK-ASM: encoding: [0x3b,0x0e,0xe3,0xcd] pdif.b t3, t1, t5 -// CHECK-ASM: pdif.b t3, t1, t5 # encoding: [0x3b,0x0e,0xe3,0xcd] - +# CHECK-ASM-AND-OBJ: pssub.h a0, a2, t3 +# CHECK-ASM: encoding: [0x3b,0x05,0xc6,0xd1] pssub.h a0, a2, t3 -// CHECK-ASM: pssub.h a0, a2, t3 # encoding: [0x3b,0x05,0xc6,0xd1] - +# CHECK-ASM-AND-OBJ: pssub.b a2, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x06,0xef,0xd4] pssub.b a2, t5, a4 -// CHECK-ASM: pssub.b a2, t5, a4 # encoding: [0x3b,0x06,0xef,0xd4] - +# CHECK-ASM-AND-OBJ: pasub.h t5, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x0f,0xce,0xd9] pasub.h t5, t3, t3 -// CHECK-ASM: pasub.h t5, t3, t3 # encoding: [0x3b,0x0f,0xce,0xd9] - +# CHECK-ASM-AND-OBJ: pasub.b s0, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x04,0x2e,0xdd] pasub.b s0, t3, s2 -// CHECK-ASM: pasub.b s0, t3, s2 # encoding: [0x3b,0x04,0x2e,0xdd] - +# CHECK-ASM-AND-OBJ: pdifu.h t5, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x0f,0xe4,0xe8] pdifu.h t5, s0, a4 -// CHECK-ASM: pdifu.h t5, s0, a4 # encoding: [0x3b,0x0f,0xe4,0xe8] - +# CHECK-ASM-AND-OBJ: pdifu.b t3, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x0e,0xe5,0xed] pdifu.b t3, a0, t5 -// CHECK-ASM: pdifu.b t3, a0, t5 # encoding: [0x3b,0x0e,0xe5,0xed] - +# CHECK-ASM-AND-OBJ: pssubu.h t3, s2, a0 +# CHECK-ASM: encoding: [0x3b,0x0e,0xa9,0xf0] pssubu.h t3, s2, a0 -// CHECK-ASM: pssubu.h t3, s2, a0 # encoding: [0x3b,0x0e,0xa9,0xf0] - +# CHECK-ASM-AND-OBJ: pssubu.b t3, a4, t3 +# CHECK-ASM: encoding: [0x3b,0x0e,0xc7,0xf5] pssubu.b t3, a4, t3 -// CHECK-ASM: pssubu.b t3, a4, t3 # encoding: [0x3b,0x0e,0xc7,0xf5] - +# CHECK-ASM-AND-OBJ: pasubu.h a2, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x06,0xe4,0xf9] pasubu.h a2, s0, t5 -// CHECK-ASM: pasubu.h a2, s0, t5 # encoding: [0x3b,0x06,0xe4,0xf9] - +# CHECK-ASM-AND-OBJ: pasubu.b s0, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x04,0xef,0xfc] pasubu.b s0, t5, a4 -// CHECK-ASM: pasubu.b s0, t5, a4 # encoding: [0x3b,0x04,0xef,0xfc] - +# CHECK-ASM-AND-OBJ: padd.w t3, s0, a0 +# CHECK-ASM: encoding: [0x3b,0x0e,0xa4,0x82] padd.w t3, s0, a0 -// CHECK-ASM: padd.w t3, s0, a0 # encoding: [0x3b,0x0e,0xa4,0x82] - +# CHECK-ASM-AND-OBJ: psadd.w t3, t1, s2 +# CHECK-ASM: encoding: [0x3b,0x0e,0x23,0x93] psadd.w t3, t1, s2 -// CHECK-ASM: psadd.w t3, t1, s2 # encoding: [0x3b,0x0e,0x23,0x93] - +# CHECK-ASM-AND-OBJ: paadd.w t5, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x0f,0xe3,0x9a] paadd.w t5, t1, a4 -// CHECK-ASM: paadd.w t5, t1, a4 # encoding: [0x3b,0x0f,0xe3,0x9a] - +# CHECK-ASM-AND-OBJ: psaddu.w s0, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x04,0xe9,0xb3] psaddu.w s0, s2, t5 -// CHECK-ASM: psaddu.w s0, s2, t5 # encoding: [0x3b,0x04,0xe9,0xb3] - +# CHECK-ASM-AND-OBJ: paaddu.w s0, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x04,0x83,0xba] paaddu.w s0, t1, s0 -// CHECK-ASM: paaddu.w s0, t1, s0 # encoding: [0x3b,0x04,0x83,0xba] - +# CHECK-ASM-AND-OBJ: psub.w t3, a0, s0 +# CHECK-ASM: encoding: [0x3b,0x0e,0x85,0xc2] psub.w t3, a0, s0 -// CHECK-ASM: psub.w t3, a0, s0 # encoding: [0x3b,0x0e,0x85,0xc2] - +# CHECK-ASM-AND-OBJ: pssub.w t3, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x0e,0x67,0xd2] pssub.w t3, a4, t1 -// CHECK-ASM: pssub.w t3, a4, t1 # encoding: [0x3b,0x0e,0x67,0xd2] - +# CHECK-ASM-AND-OBJ: pasub.w t3, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x0e,0xe6,0xda] pasub.w t3, a2, a4 -// CHECK-ASM: pasub.w t3, a2, a4 # encoding: [0x3b,0x0e,0xe6,0xda] - +# CHECK-ASM-AND-OBJ: pssubu.w a0, a4, t3 +# CHECK-ASM: encoding: [0x3b,0x05,0xc7,0xf3] pssubu.w a0, a4, t3 -// CHECK-ASM: pssubu.w a0, a4, t3 # encoding: [0x3b,0x05,0xc7,0xf3] - +# CHECK-ASM-AND-OBJ: pasubu.w a0, t3, a4 +# CHECK-ASM: encoding: [0x3b,0x05,0xee,0xfa] pasubu.w a0, t3, a4 -// CHECK-ASM: pasubu.w a0, t3, a4 # encoding: [0x3b,0x05,0xee,0xfa] - +# CHECK-ASM-AND-OBJ: slx a0, a2, s2 +# CHECK-ASM: encoding: [0x3b,0x15,0x26,0x8f] slx a0, a2, s2 -// CHECK-ASM: slx a0, a2, s2 # encoding: [0x3b,0x15,0x26,0x8f] - +# CHECK-ASM-AND-OBJ: pmul.h.b01 a2, a4, a2 +# CHECK-ASM: encoding: [0x3b,0x16,0xc7,0x90] pmul.h.b01 a2, a4, a2 -// CHECK-ASM: pmul.h.b01 a2, a4, a2 # encoding: [0x3b,0x16,0xc7,0x90] - +# CHECK-ASM-AND-OBJ: mvm s0, t1, a2 +# CHECK-ASM: encoding: [0x3b,0x14,0xc3,0xa8] mvm s0, t1, a2 -// CHECK-ASM: mvm s0, t1, a2 # encoding: [0x3b,0x14,0xc3,0xa8] - +# CHECK-ASM-AND-OBJ: mvmn a2, a4, a0 +# CHECK-ASM: encoding: [0x3b,0x16,0xa7,0xaa] mvmn a2, a4, a0 -// CHECK-ASM: mvmn a2, a4, a0 # encoding: [0x3b,0x16,0xa7,0xaa] - +# CHECK-ASM-AND-OBJ: merge a4, a2, a2 +# CHECK-ASM: encoding: [0x3b,0x17,0xc6,0xac] merge a4, a2, a2 -// CHECK-ASM: merge a4, a2, a2 # encoding: [0x3b,0x17,0xc6,0xac] - +# CHECK-ASM-AND-OBJ: srx t1, t3, a4 +# CHECK-ASM: encoding: [0x3b,0x13,0xee,0xae] srx t1, t3, a4 -// CHECK-ASM: srx t1, t3, a4 # encoding: [0x3b,0x13,0xee,0xae] - +# CHECK-ASM-AND-OBJ: pmulu.h.b01 s2, a4, a0 +# CHECK-ASM: encoding: [0x3b,0x19,0xa7,0xb0] pmulu.h.b01 s2, a4, a0 -// CHECK-ASM: pmulu.h.b01 s2, a4, a0 # encoding: [0x3b,0x19,0xa7,0xb0] - +# CHECK-ASM-AND-OBJ: pdifsumu.b t3, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x1e,0xcf,0xb5] pdifsumu.b t3, t5, t3 -// CHECK-ASM: pdifsumu.b t3, t5, t3 # encoding: [0x3b,0x1e,0xcf,0xb5] - +# CHECK-ASM-AND-OBJ: pdifsumau.b s2, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x19,0xa6,0xbc] pdifsumau.b s2, a2, a0 -// CHECK-ASM: pdifsumau.b s2, a2, a0 # encoding: [0x3b,0x19,0xa6,0xbc] - +# CHECK-ASM-AND-OBJ: pmul.w.h01 s2, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x19,0xcf,0x93] pmul.w.h01 s2, t5, t3 -// CHECK-ASM: pmul.w.h01 s2, t5, t3 # encoding: [0x3b,0x19,0xcf,0x93] - +# CHECK-ASM-AND-OBJ: mul.w01 t5, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x1f,0x67,0x96] mul.w01 t5, a4, t1 -// CHECK-ASM: mul.w01 t5, a4, t1 # encoding: [0x3b,0x1f,0x67,0x96] - +# CHECK-ASM-AND-OBJ: pmacc.w.h01 t1, t1, a0 +# CHECK-ASM: encoding: [0x3b,0x13,0xa3,0x9a] pmacc.w.h01 t1, t1, a0 -// CHECK-ASM: pmacc.w.h01 t1, t1, a0 # encoding: [0x3b,0x13,0xa3,0x9a] - +# CHECK-ASM-AND-OBJ: macc.w01 s2, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x19,0xc5,0x9f] macc.w01 s2, a0, t3 -// CHECK-ASM: macc.w01 s2, a0, t3 # encoding: [0x3b,0x19,0xc5,0x9f] - +# CHECK-ASM-AND-OBJ: pmulu.w.h01 t1, a4, a2 +# CHECK-ASM: encoding: [0x3b,0x13,0xc7,0xb2] pmulu.w.h01 t1, a4, a2 -// CHECK-ASM: pmulu.w.h01 t1, a4, a2 # encoding: [0x3b,0x13,0xc7,0xb2] - +# CHECK-ASM-AND-OBJ: mulu.w01 t5, t1, t5 +# CHECK-ASM: encoding: [0x3b,0x1f,0xe3,0xb7] mulu.w01 t5, t1, t5 -// CHECK-ASM: mulu.w01 t5, t1, t5 # encoding: [0x3b,0x1f,0xe3,0xb7] - +# CHECK-ASM-AND-OBJ: pmaccu.w.h01 t5, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x1f,0xef,0xba] pmaccu.w.h01 t5, t5, a4 -// CHECK-ASM: pmaccu.w.h01 t5, t5, a4 # encoding: [0x3b,0x1f,0xef,0xba] - +# CHECK-ASM-AND-OBJ: maccu.w01 a0, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x15,0x65,0xbe] maccu.w01 a0, a0, t1 -// CHECK-ASM: maccu.w01 a0, a0, t1 # encoding: [0x3b,0x15,0x65,0xbe] - +# CHECK-ASM-AND-OBJ: psh1add.h a2, a2, t3 +# CHECK-ASM: encoding: [0x3b,0x26,0xc6,0xa1] psh1add.h a2, a2, t3 -// CHECK-ASM: psh1add.h a2, a2, t3 # encoding: [0x3b,0x26,0xc6,0xa1] - +# CHECK-ASM-AND-OBJ: pssh1sadd.h a2, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x26,0xce,0xb1] pssh1sadd.h a2, t3, t3 -// CHECK-ASM: pssh1sadd.h a2, t3, t3 # encoding: [0x3b,0x26,0xce,0xb1] - +# CHECK-ASM-AND-OBJ: psh1add.w s2, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x29,0xcf,0xa2] psh1add.w s2, t5, a2 -// CHECK-ASM: psh1add.w s2, t5, a2 # encoding: [0x3b,0x29,0xcf,0xa2] - +# CHECK-ASM-AND-OBJ: pssh1sadd.w a4, t3, s0 +# CHECK-ASM: encoding: [0x3b,0x27,0x8e,0xb2] pssh1sadd.w a4, t3, s0 -// CHECK-ASM: pssh1sadd.w a4, t3, s0 # encoding: [0x3b,0x27,0x8e,0xb2] - +# CHECK-ASM-AND-OBJ: unzip8p a4, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x27,0x6e,0xe0] unzip8p a4, t3, t1 -// CHECK-ASM: unzip8p a4, t3, t1 # encoding: [0x3b,0x27,0x6e,0xe0] - +# CHECK-ASM-AND-OBJ: unzip16p t5, a4, t3 +# CHECK-ASM: encoding: [0x3b,0x2f,0xc7,0xe3] unzip16p t5, a4, t3 -// CHECK-ASM: unzip16p t5, a4, t3 # encoding: [0x3b,0x2f,0xc7,0xe3] - +# CHECK-ASM-AND-OBJ: unzip8hp s0, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x24,0x65,0xe4] unzip8hp s0, a0, t1 -// CHECK-ASM: unzip8hp s0, a0, t1 # encoding: [0x3b,0x24,0x65,0xe4] - +# CHECK-ASM-AND-OBJ: unzip16hp a0, a0, a2 +# CHECK-ASM: encoding: [0x3b,0x25,0xc5,0xe6] unzip16hp a0, a0, a2 -// CHECK-ASM: unzip16hp a0, a0, a2 # encoding: [0x3b,0x25,0xc5,0xe6] - +# CHECK-ASM-AND-OBJ: zip8p t5, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x2f,0xce,0xf1] zip8p t5, t3, t3 -// CHECK-ASM: zip8p t5, t3, t3 # encoding: [0x3b,0x2f,0xce,0xf1] - +# CHECK-ASM-AND-OBJ: zip16p a0, t5, a0 +# CHECK-ASM: encoding: [0x3b,0x25,0xaf,0xf2] zip16p a0, t5, a0 -// CHECK-ASM: zip16p a0, t5, a0 # encoding: [0x3b,0x25,0xaf,0xf2] - +# CHECK-ASM-AND-OBJ: zip8hp t5, a0, a2 +# CHECK-ASM: encoding: [0x3b,0x2f,0xc5,0xf4] zip8hp t5, a0, a2 -// CHECK-ASM: zip8hp t5, a0, a2 # encoding: [0x3b,0x2f,0xc5,0xf4] - +# CHECK-ASM-AND-OBJ: zip16hp t1, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x23,0xef,0xf6] zip16hp t1, t5, a4 -// CHECK-ASM: zip16hp t1, t5, a4 # encoding: [0x3b,0x23,0xef,0xf6] - +# CHECK-ASM-AND-OBJ: pmul.h.b00 a4, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x37,0x27,0x81] pmul.h.b00 a4, a4, s2 -// CHECK-ASM: pmul.h.b00 a4, a4, s2 # encoding: [0x3b,0x37,0x27,0x81] - +# CHECK-ASM-AND-OBJ: pmul.h.b11 t1, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x33,0x89,0x90] pmul.h.b11 t1, s2, s0 -// CHECK-ASM: pmul.h.b11 t1, s2, s0 # encoding: [0x3b,0x33,0x89,0x90] - +# CHECK-ASM-AND-OBJ: pmulu.h.b00 a4, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x37,0xa6,0xa0] pmulu.h.b00 a4, a2, a0 -// CHECK-ASM: pmulu.h.b00 a4, a2, a0 # encoding: [0x3b,0x37,0xa6,0xa0] - +# CHECK-ASM-AND-OBJ: pmulu.h.b11 a4, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x37,0xe4,0xb0] pmulu.h.b11 a4, s0, a4 -// CHECK-ASM: pmulu.h.b11 a4, s0, a4 # encoding: [0x3b,0x37,0xe4,0xb0] - +# CHECK-ASM-AND-OBJ: pmulsu.h.b00 a2, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x36,0xe4,0xe0] pmulsu.h.b00 a2, s0, a4 -// CHECK-ASM: pmulsu.h.b00 a2, s0, a4 # encoding: [0x3b,0x36,0xe4,0xe0] - +# CHECK-ASM-AND-OBJ: pmulsu.h.b11 t3, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x3e,0xe3,0xf0] pmulsu.h.b11 t3, t1, a4 -// CHECK-ASM: pmulsu.h.b11 t3, t1, a4 # encoding: [0x3b,0x3e,0xe3,0xf0] - +# CHECK-ASM-AND-OBJ: pmul.w.h00 s2, t1, a2 +# CHECK-ASM: encoding: [0x3b,0x39,0xc3,0x82] pmul.w.h00 s2, t1, a2 -// CHECK-ASM: pmul.w.h00 s2, t1, a2 # encoding: [0x3b,0x39,0xc3,0x82] - +# CHECK-ASM-AND-OBJ: mul.w00 a4, a0, a2 +# CHECK-ASM: encoding: [0x3b,0x37,0xc5,0x86] mul.w00 a4, a0, a2 -// CHECK-ASM: mul.w00 a4, a0, a2 # encoding: [0x3b,0x37,0xc5,0x86] - +# CHECK-ASM-AND-OBJ: pmacc.w.h00 s2, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x39,0xcf,0x8a] pmacc.w.h00 s2, t5, a2 -// CHECK-ASM: pmacc.w.h00 s2, t5, a2 # encoding: [0x3b,0x39,0xcf,0x8a] - +# CHECK-ASM-AND-OBJ: macc.w00 t1, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x33,0xe5,0x8f] macc.w00 t1, a0, t5 -// CHECK-ASM: macc.w00 t1, a0, t5 # encoding: [0x3b,0x33,0xe5,0x8f] - +# CHECK-ASM-AND-OBJ: pmul.w.h11 s0, a4, s0 +# CHECK-ASM: encoding: [0x3b,0x34,0x87,0x92] pmul.w.h11 s0, a4, s0 -// CHECK-ASM: pmul.w.h11 s0, a4, s0 # encoding: [0x3b,0x34,0x87,0x92] - +# CHECK-ASM-AND-OBJ: mul.w11 a0, t3, a0 +# CHECK-ASM: encoding: [0x3b,0x35,0xae,0x96] mul.w11 a0, t3, a0 -// CHECK-ASM: mul.w11 a0, t3, a0 # encoding: [0x3b,0x35,0xae,0x96] - +# CHECK-ASM-AND-OBJ: pmacc.w.h11 a4, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x37,0x67,0x9a] pmacc.w.h11 a4, a4, t1 -// CHECK-ASM: pmacc.w.h11 a4, a4, t1 # encoding: [0x3b,0x37,0x67,0x9a] - +# CHECK-ASM-AND-OBJ: macc.w11 t3, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x3e,0xc9,0x9e] macc.w11 t3, s2, a2 -// CHECK-ASM: macc.w11 t3, s2, a2 # encoding: [0x3b,0x3e,0xc9,0x9e] - +# CHECK-ASM-AND-OBJ: pmulu.w.h00 a2, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x36,0x6e,0xa2] pmulu.w.h00 a2, t3, t1 -// CHECK-ASM: pmulu.w.h00 a2, t3, t1 # encoding: [0x3b,0x36,0x6e,0xa2] - +# CHECK-ASM-AND-OBJ: mulu.w00 a0, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x35,0x2f,0xa7] mulu.w00 a0, t5, s2 -// CHECK-ASM: mulu.w00 a0, t5, s2 # encoding: [0x3b,0x35,0x2f,0xa7] - +# CHECK-ASM-AND-OBJ: pmaccu.w.h00 t3, t3, t5 +# CHECK-ASM: encoding: [0x3b,0x3e,0xee,0xab] pmaccu.w.h00 t3, t3, t5 -// CHECK-ASM: pmaccu.w.h00 t3, t3, t5 # encoding: [0x3b,0x3e,0xee,0xab] - +# CHECK-ASM-AND-OBJ: maccu.w00 s2, t1, s2 +# CHECK-ASM: encoding: [0x3b,0x39,0x23,0xaf] maccu.w00 s2, t1, s2 -// CHECK-ASM: maccu.w00 s2, t1, s2 # encoding: [0x3b,0x39,0x23,0xaf] - +# CHECK-ASM-AND-OBJ: pmulu.w.h11 s0, t5, t5 +# CHECK-ASM: encoding: [0x3b,0x34,0xef,0xb3] pmulu.w.h11 s0, t5, t5 -// CHECK-ASM: pmulu.w.h11 s0, t5, t5 # encoding: [0x3b,0x34,0xef,0xb3] - +# CHECK-ASM-AND-OBJ: mulu.w11 s0, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x34,0xe3,0xb6] mulu.w11 s0, t1, a4 -// CHECK-ASM: mulu.w11 s0, t1, a4 # encoding: [0x3b,0x34,0xe3,0xb6] - +# CHECK-ASM-AND-OBJ: pmaccu.w.h11 a0, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x35,0xe4,0xbb] pmaccu.w.h11 a0, s0, t5 -// CHECK-ASM: pmaccu.w.h11 a0, s0, t5 # encoding: [0x3b,0x35,0xe4,0xbb] - +# CHECK-ASM-AND-OBJ: maccu.w11 s2, t3, t5 +# CHECK-ASM: encoding: [0x3b,0x39,0xee,0xbf] maccu.w11 s2, t3, t5 -// CHECK-ASM: maccu.w11 s2, t3, t5 # encoding: [0x3b,0x39,0xee,0xbf] - +# CHECK-ASM-AND-OBJ: pmulsu.w.h00 t5, t5, t5 +# CHECK-ASM: encoding: [0x3b,0x3f,0xef,0xe3] pmulsu.w.h00 t5, t5, t5 -// CHECK-ASM: pmulsu.w.h00 t5, t5, t5 # encoding: [0x3b,0x3f,0xef,0xe3] - +# CHECK-ASM-AND-OBJ: mulsu.w00 t1, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x33,0xe4,0xe6] mulsu.w00 t1, s0, a4 -// CHECK-ASM: mulsu.w00 t1, s0, a4 # encoding: [0x3b,0x33,0xe4,0xe6] - +# CHECK-ASM-AND-OBJ: pmaccsu.w.h00 a4, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x37,0x65,0xea] pmaccsu.w.h00 a4, a0, t1 -// CHECK-ASM: pmaccsu.w.h00 a4, a0, t1 # encoding: [0x3b,0x37,0x65,0xea] - +# CHECK-ASM-AND-OBJ: maccsu.w00 a4, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x37,0x89,0xee] maccsu.w00 a4, s2, s0 -// CHECK-ASM: maccsu.w00 a4, s2, s0 # encoding: [0x3b,0x37,0x89,0xee] - +# CHECK-ASM-AND-OBJ: pmulsu.w.h11 t1, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x33,0x2e,0xf3] pmulsu.w.h11 t1, t3, s2 -// CHECK-ASM: pmulsu.w.h11 t1, t3, s2 # encoding: [0x3b,0x33,0x2e,0xf3] - +# CHECK-ASM-AND-OBJ: mulsu.w11 a2, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x36,0xc9,0xf6] mulsu.w11 a2, s2, a2 -// CHECK-ASM: mulsu.w11 a2, s2, a2 # encoding: [0x3b,0x36,0xc9,0xf6] - +# CHECK-ASM-AND-OBJ: pmaccsu.w.h11 a0, a2, t3 +# CHECK-ASM: encoding: [0x3b,0x35,0xc6,0xfb] pmaccsu.w.h11 a0, a2, t3 -// CHECK-ASM: pmaccsu.w.h11 a0, a2, t3 # encoding: [0x3b,0x35,0xc6,0xfb] - +# CHECK-ASM-AND-OBJ: maccsu.w11 t5, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x3f,0x27,0xff] maccsu.w11 t5, a4, s2 -// CHECK-ASM: maccsu.w11 t5, a4, s2 # encoding: [0x3b,0x3f,0x27,0xff] - +# CHECK-ASM-AND-OBJ: ppack.h s0, s0, s2 +# CHECK-ASM: encoding: [0x3b,0x44,0x24,0x81] ppack.h s0, s0, s2 -// CHECK-ASM: ppack.h s0, s0, s2 # encoding: [0x3b,0x44,0x24,0x81] - +# CHECK-ASM-AND-OBJ: ppackbt.h a4, s2, t3 +# CHECK-ASM: encoding: [0x3b,0x47,0xc9,0x91] ppackbt.h a4, s2, t3 -// CHECK-ASM: ppackbt.h a4, s2, t3 # encoding: [0x3b,0x47,0xc9,0x91] - +# CHECK-ASM-AND-OBJ: ppacktb.h t3, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x4e,0xc4,0xa1] ppacktb.h t3, s0, t3 -// CHECK-ASM: ppacktb.h t3, s0, t3 # encoding: [0x3b,0x4e,0xc4,0xa1] - +# CHECK-ASM-AND-OBJ: ppackt.h a0, t1, t5 +# CHECK-ASM: encoding: [0x3b,0x45,0xe3,0xb1] ppackt.h a0, t1, t5 -// CHECK-ASM: ppackt.h a0, t1, t5 # encoding: [0x3b,0x45,0xe3,0xb1] - +# CHECK-ASM-AND-OBJ: ppack.w t5, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x4f,0xe6,0x82] ppack.w t5, a2, a4 -// CHECK-ASM: ppack.w t5, a2, a4 # encoding: [0x3b,0x4f,0xe6,0x82] - +# CHECK-ASM-AND-OBJ: ppackbt.w t5, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x4f,0xe4,0x93] ppackbt.w t5, s0, t5 -// CHECK-ASM: ppackbt.w t5, s0, t5 # encoding: [0x3b,0x4f,0xe4,0x93] - +# CHECK-ASM-AND-OBJ: ppackbt a0, t5, a0 +# CHECK-ASM: encoding: [0x3b,0x45,0xaf,0x96] ppackbt a0, t5, a0 -// CHECK-ASM: ppackbt a0, t5, a0 # encoding: [0x3b,0x45,0xaf,0x96] - +# CHECK-ASM-AND-OBJ: ppacktb.w t5, t1, t1 +# CHECK-ASM: encoding: [0x3b,0x4f,0x63,0xa2] ppacktb.w t5, t1, t1 -// CHECK-ASM: ppacktb.w t5, t1, t1 # encoding: [0x3b,0x4f,0x63,0xa2] - +# CHECK-ASM-AND-OBJ: ppacktb t5, a4, a4 +# CHECK-ASM: encoding: [0x3b,0x4f,0xe7,0xa6] ppacktb t5, a4, a4 -// CHECK-ASM: ppacktb t5, a4, a4 # encoding: [0x3b,0x4f,0xe7,0xa6] - +# CHECK-ASM-AND-OBJ: ppackt.w t3, a0, s2 +# CHECK-ASM: encoding: [0x3b,0x4e,0x25,0xb3] ppackt.w t3, a0, s2 -// CHECK-ASM: ppackt.w t3, a0, s2 # encoding: [0x3b,0x4e,0x25,0xb3] - +# CHECK-ASM-AND-OBJ: ppackt a2, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x46,0x6e,0xb6] ppackt a2, t3, t1 -// CHECK-ASM: ppackt a2, t3, t1 # encoding: [0x3b,0x46,0x6e,0xb6] - +# CHECK-ASM-AND-OBJ: pm2add.h a4, t3, t5 +# CHECK-ASM: encoding: [0x3b,0x57,0xee,0x81] pm2add.h a4, t3, t5 -// CHECK-ASM: pm2add.h a4, t3, t5 # encoding: [0x3b,0x57,0xee,0x81] - +# CHECK-ASM-AND-OBJ: pm4add.b t1, s2, s2 +# CHECK-ASM: encoding: [0x3b,0x53,0x29,0x85] pm4add.b t1, s2, s2 -// CHECK-ASM: pm4add.b t1, s2, s2 # encoding: [0x3b,0x53,0x29,0x85] - +# CHECK-ASM-AND-OBJ: pm2adda.h a0, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x55,0x8f,0x88] pm2adda.h a0, t5, s0 -// CHECK-ASM: pm2adda.h a0, t5, s0 # encoding: [0x3b,0x55,0x8f,0x88] - +# CHECK-ASM-AND-OBJ: pm4adda.b a0, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x55,0xcf,0x8c] pm4adda.b a0, t5, a2 -// CHECK-ASM: pm4adda.b a0, t5, a2 # encoding: [0x3b,0x55,0xcf,0x8c] - +# CHECK-ASM-AND-OBJ: pm2add.hx a0, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x55,0xc4,0x91] pm2add.hx a0, s0, t3 -// CHECK-ASM: pm2add.hx a0, s0, t3 # encoding: [0x3b,0x55,0xc4,0x91] - +# CHECK-ASM-AND-OBJ: pm2adda.hx s0, a0, s2 +# CHECK-ASM: encoding: [0x3b,0x54,0x25,0x99] pm2adda.hx s0, a0, s2 -// CHECK-ASM: pm2adda.hx s0, a0, s2 # encoding: [0x3b,0x54,0x25,0x99] - +# CHECK-ASM-AND-OBJ: pm2addu.h t1, a4, a0 +# CHECK-ASM: encoding: [0x3b,0x53,0xa7,0xa0] pm2addu.h t1, a4, a0 -// CHECK-ASM: pm2addu.h t1, a4, a0 # encoding: [0x3b,0x53,0xa7,0xa0] - +# CHECK-ASM-AND-OBJ: pm4addu.b a0, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x55,0xc3,0xa5] pm4addu.b a0, t1, t3 -// CHECK-ASM: pm4addu.b a0, t1, t3 # encoding: [0x3b,0x55,0xc3,0xa5] - +# CHECK-ASM-AND-OBJ: pm2addau.h s2, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x59,0xa6,0xa8] pm2addau.h s2, a2, a0 -// CHECK-ASM: pm2addau.h s2, a2, a0 # encoding: [0x3b,0x59,0xa6,0xa8] - +# CHECK-ASM-AND-OBJ: pm4addau.b s2, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x59,0xe9,0xad] pm4addau.b s2, s2, t5 -// CHECK-ASM: pm4addau.b s2, s2, t5 # encoding: [0x3b,0x59,0xe9,0xad] - +# CHECK-ASM-AND-OBJ: pmq2add.h s2, s2, t3 +# CHECK-ASM: encoding: [0x3b,0x59,0xc9,0xb1] pmq2add.h s2, s2, t3 -// CHECK-ASM: pmq2add.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0xb1] - +# CHECK-ASM-AND-OBJ: pmqr2add.h a4, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x57,0xa6,0xb4] pmqr2add.h a4, a2, a0 -// CHECK-ASM: pmqr2add.h a4, a2, a0 # encoding: [0x3b,0x57,0xa6,0xb4] - +# CHECK-ASM-AND-OBJ: pmq2adda.h a2, s2, t1 +# CHECK-ASM: encoding: [0x3b,0x56,0x69,0xb8] pmq2adda.h a2, s2, t1 -// CHECK-ASM: pmq2adda.h a2, s2, t1 # encoding: [0x3b,0x56,0x69,0xb8] - +# CHECK-ASM-AND-OBJ: pmqr2adda.h a2, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x56,0xa5,0xbc] pmqr2adda.h a2, a0, a0 -// CHECK-ASM: pmqr2adda.h a2, a0, a0 # encoding: [0x3b,0x56,0xa5,0xbc] - +# CHECK-ASM-AND-OBJ: pm2sub.h t5, s0, s0 +# CHECK-ASM: encoding: [0x3b,0x5f,0x84,0xc0] pm2sub.h t5, s0, s0 -// CHECK-ASM: pm2sub.h t5, s0, s0 # encoding: [0x3b,0x5f,0x84,0xc0] - +# CHECK-ASM-AND-OBJ: pm2sadd.h a0, t5, a0 +# CHECK-ASM: encoding: [0x3b,0x55,0xaf,0xc4] pm2sadd.h a0, t5, a0 -// CHECK-ASM: pm2sadd.h a0, t5, a0 # encoding: [0x3b,0x55,0xaf,0xc4] - +# CHECK-ASM-AND-OBJ: pm2suba.h s0, a4, t5 +# CHECK-ASM: encoding: [0x3b,0x54,0xe7,0xc9] pm2suba.h s0, a4, t5 -// CHECK-ASM: pm2suba.h s0, a4, t5 # encoding: [0x3b,0x54,0xe7,0xc9] - +# CHECK-ASM-AND-OBJ: pm2sub.hx t3, t5, a0 +# CHECK-ASM: encoding: [0x3b,0x5e,0xaf,0xd0] pm2sub.hx t3, t5, a0 -// CHECK-ASM: pm2sub.hx t3, t5, a0 # encoding: [0x3b,0x5e,0xaf,0xd0] - +# CHECK-ASM-AND-OBJ: pm2sadd.hx t1, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x53,0xc5,0xd5] pm2sadd.hx t1, a0, t3 -// CHECK-ASM: pm2sadd.hx t1, a0, t3 # encoding: [0x3b,0x53,0xc5,0xd5] - +# CHECK-ASM-AND-OBJ: pm2suba.hx t3, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x5e,0xe5,0xd8] pm2suba.hx t3, a0, a4 -// CHECK-ASM: pm2suba.hx t3, a0, a4 # encoding: [0x3b,0x5e,0xe5,0xd8] - +# CHECK-ASM-AND-OBJ: pm2addsu.h t3, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x5e,0xc5,0xe1] pm2addsu.h t3, a0, t3 -// CHECK-ASM: pm2addsu.h t3, a0, t3 # encoding: [0x3b,0x5e,0xc5,0xe1] - +# CHECK-ASM-AND-OBJ: pm4addsu.b t1, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x53,0x8f,0xe4] pm4addsu.b t1, t5, s0 -// CHECK-ASM: pm4addsu.b t1, t5, s0 # encoding: [0x3b,0x53,0x8f,0xe4] - +# CHECK-ASM-AND-OBJ: pm2addasu.h t1, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x53,0xce,0xe9] pm2addasu.h t1, t3, t3 -// CHECK-ASM: pm2addasu.h t1, t3, t3 # encoding: [0x3b,0x53,0xce,0xe9] - +# CHECK-ASM-AND-OBJ: pm4addasu.b t3, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x5e,0xa5,0xec] pm4addasu.b t3, a0, a0 -// CHECK-ASM: pm4addasu.b t3, a0, a0 # encoding: [0x3b,0x5e,0xa5,0xec] - +# CHECK-ASM-AND-OBJ: pm2add.w t3, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x5e,0xe4,0x83] pm2add.w t3, s0, t5 -// CHECK-ASM: pm2add.w t3, s0, t5 # encoding: [0x3b,0x5e,0xe4,0x83] - +# CHECK-ASM-AND-OBJ: pm4add.h s2, s2, t3 +# CHECK-ASM: encoding: [0x3b,0x59,0xc9,0x87] pm4add.h s2, s2, t3 -// CHECK-ASM: pm4add.h s2, s2, t3 # encoding: [0x3b,0x59,0xc9,0x87] - +# CHECK-ASM-AND-OBJ: pm2adda.w a2, a0, s0 +# CHECK-ASM: encoding: [0x3b,0x56,0x85,0x8a] pm2adda.w a2, a0, s0 -// CHECK-ASM: pm2adda.w a2, a0, s0 # encoding: [0x3b,0x56,0x85,0x8a] - +# CHECK-ASM-AND-OBJ: pm4adda.h s2, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x59,0x64,0x8e] pm4adda.h s2, s0, t1 -// CHECK-ASM: pm4adda.h s2, s0, t1 # encoding: [0x3b,0x59,0x64,0x8e] - +# CHECK-ASM-AND-OBJ: pm2add.wx t1, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x53,0xe4,0x92] pm2add.wx t1, s0, a4 -// CHECK-ASM: pm2add.wx t1, s0, a4 # encoding: [0x3b,0x53,0xe4,0x92] - +# CHECK-ASM-AND-OBJ: pm2adda.wx t5, t3, s0 +# CHECK-ASM: encoding: [0x3b,0x5f,0x8e,0x9a] pm2adda.wx t5, t3, s0 -// CHECK-ASM: pm2adda.wx t5, t3, s0 # encoding: [0x3b,0x5f,0x8e,0x9a] - +# CHECK-ASM-AND-OBJ: pm2addu.w s2, a0, s2 +# CHECK-ASM: encoding: [0x3b,0x59,0x25,0xa3] pm2addu.w s2, a0, s2 -// CHECK-ASM: pm2addu.w s2, a0, s2 # encoding: [0x3b,0x59,0x25,0xa3] - +# CHECK-ASM-AND-OBJ: pm4addu.h a4, a2, a2 +# CHECK-ASM: encoding: [0x3b,0x57,0xc6,0xa6] pm4addu.h a4, a2, a2 -// CHECK-ASM: pm4addu.h a4, a2, a2 # encoding: [0x3b,0x57,0xc6,0xa6] - +# CHECK-ASM-AND-OBJ: pm2addau.w s0, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x54,0xe4,0xaa] pm2addau.w s0, s0, a4 -// CHECK-ASM: pm2addau.w s0, s0, a4 # encoding: [0x3b,0x54,0xe4,0xaa] - +# CHECK-ASM-AND-OBJ: pm4addau.h a2, a4, t5 +# CHECK-ASM: encoding: [0x3b,0x56,0xe7,0xaf] pm4addau.h a2, a4, t5 -// CHECK-ASM: pm4addau.h a2, a4, t5 # encoding: [0x3b,0x56,0xe7,0xaf] - +# CHECK-ASM-AND-OBJ: pmq2add.w t5, t1, t1 +# CHECK-ASM: encoding: [0x3b,0x5f,0x63,0xb2] pmq2add.w t5, t1, t1 -// CHECK-ASM: pmq2add.w t5, t1, t1 # encoding: [0x3b,0x5f,0x63,0xb2] - +# CHECK-ASM-AND-OBJ: pmqr2add.w s0, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x54,0xe3,0xb6] pmqr2add.w s0, t1, a4 -// CHECK-ASM: pmqr2add.w s0, t1, a4 # encoding: [0x3b,0x54,0xe3,0xb6] - +# CHECK-ASM-AND-OBJ: pmq2adda.w a4, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x57,0x64,0xba] pmq2adda.w a4, s0, t1 -// CHECK-ASM: pmq2adda.w a4, s0, t1 # encoding: [0x3b,0x57,0x64,0xba] - +# CHECK-ASM-AND-OBJ: pmqr2adda.w a4, t5, s0 +# CHECK-ASM: encoding: [0x3b,0x57,0x8f,0xbe] pmqr2adda.w a4, t5, s0 -// CHECK-ASM: pmqr2adda.w a4, t5, s0 # encoding: [0x3b,0x57,0x8f,0xbe] - +# CHECK-ASM-AND-OBJ: pm2sub.w t3, a2, t1 +# CHECK-ASM: encoding: [0x3b,0x5e,0x66,0xc2] pm2sub.w t3, a2, t1 -// CHECK-ASM: pm2sub.w t3, a2, t1 # encoding: [0x3b,0x5e,0x66,0xc2] - +# CHECK-ASM-AND-OBJ: pm2suba.w t5, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x5f,0xcf,0xcb] pm2suba.w t5, t5, t3 -// CHECK-ASM: pm2suba.w t5, t5, t3 # encoding: [0x3b,0x5f,0xcf,0xcb] - +# CHECK-ASM-AND-OBJ: pm2sub.wx t5, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x5f,0x89,0xd2] pm2sub.wx t5, s2, s0 -// CHECK-ASM: pm2sub.wx t5, s2, s0 # encoding: [0x3b,0x5f,0x89,0xd2] - +# CHECK-ASM-AND-OBJ: pm2suba.wx a2, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x56,0xe5,0xda] pm2suba.wx a2, a0, a4 -// CHECK-ASM: pm2suba.wx a2, a0, a4 # encoding: [0x3b,0x56,0xe5,0xda] - +# CHECK-ASM-AND-OBJ: pm2addsu.w s0, s0, s2 +# CHECK-ASM: encoding: [0x3b,0x54,0x24,0xe3] pm2addsu.w s0, s0, s2 -// CHECK-ASM: pm2addsu.w s0, s0, s2 # encoding: [0x3b,0x54,0x24,0xe3] - +# CHECK-ASM-AND-OBJ: pm4addsu.h a2, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x56,0x89,0xe6] pm4addsu.h a2, s2, s0 -// CHECK-ASM: pm4addsu.h a2, s2, s0 # encoding: [0x3b,0x56,0x89,0xe6] - +# CHECK-ASM-AND-OBJ: pm2addasu.w a0, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x55,0xa6,0xea] pm2addasu.w a0, a2, a0 -// CHECK-ASM: pm2addasu.w a0, a2, a0 # encoding: [0x3b,0x55,0xa6,0xea] - +# CHECK-ASM-AND-OBJ: pm4addasu.h a0, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x55,0xe4,0xef] pm4addasu.h a0, s0, t5 -// CHECK-ASM: pm4addasu.h a0, s0, t5 # encoding: [0x3b,0x55,0xe4,0xef] - +# CHECK-ASM-AND-OBJ: pmqacc.w.h01 t5, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x5f,0xe3,0xf8] pmqacc.w.h01 t5, t1, a4 -// CHECK-ASM: pmqacc.w.h01 t5, t1, a4 # encoding: [0x3b,0x5f,0xe3,0xf8] - +# CHECK-ASM-AND-OBJ: mqacc.w01 a0, a2, t3 +# CHECK-ASM: encoding: [0x3b,0x55,0xc6,0xfb] mqacc.w01 a0, a2, t3 -// CHECK-ASM: mqacc.w01 a0, a2, t3 # encoding: [0x3b,0x55,0xc6,0xfb] - +# CHECK-ASM-AND-OBJ: pmqracc.w.h01 a4, t1, s2 +# CHECK-ASM: encoding: [0x3b,0x57,0x23,0xfd] pmqracc.w.h01 a4, t1, s2 -// CHECK-ASM: pmqracc.w.h01 a4, t1, s2 # encoding: [0x3b,0x57,0x23,0xfd] - +# CHECK-ASM-AND-OBJ: mqracc.w01 s0, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x54,0xef,0xfe] mqracc.w01 s0, t5, a4 -// CHECK-ASM: mqracc.w01 s0, t5, a4 # encoding: [0x3b,0x54,0xef,0xfe] - +# CHECK-ASM-AND-OBJ: pas.hx a0, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x65,0x6f,0x80] pas.hx a0, t5, t1 -// CHECK-ASM: pas.hx a0, t5, t1 # encoding: [0x3b,0x65,0x6f,0x80] - +# CHECK-ASM-AND-OBJ: psa.hx a2, t3, a0 +# CHECK-ASM: encoding: [0x3b,0x66,0xae,0x84] psa.hx a2, t3, a0 -// CHECK-ASM: psa.hx a2, t3, a0 # encoding: [0x3b,0x66,0xae,0x84] - +# CHECK-ASM-AND-OBJ: psas.hx s0, a0, a2 +# CHECK-ASM: encoding: [0x3b,0x64,0xc5,0x90] psas.hx s0, a0, a2 -// CHECK-ASM: psas.hx s0, a0, a2 # encoding: [0x3b,0x64,0xc5,0x90] - +# CHECK-ASM-AND-OBJ: pssa.hx a0, t1, t5 +# CHECK-ASM: encoding: [0x3b,0x65,0xe3,0x95] pssa.hx a0, t1, t5 -// CHECK-ASM: pssa.hx a0, t1, t5 # encoding: [0x3b,0x65,0xe3,0x95] - +# CHECK-ASM-AND-OBJ: pmseq.h t3, s0, t1 +# CHECK-ASM: encoding: [0x3b,0x6e,0x64,0xc0] pmseq.h t3, s0, t1 -// CHECK-ASM: pmseq.h t3, s0, t1 # encoding: [0x3b,0x6e,0x64,0xc0] - +# CHECK-ASM-AND-OBJ: pmseq.b t5, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x6f,0xc9,0xc4] pmseq.b t5, s2, a2 -// CHECK-ASM: pmseq.b t5, s2, a2 # encoding: [0x3b,0x6f,0xc9,0xc4] - +# CHECK-ASM-AND-OBJ: pmslt.h t1, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x63,0xe5,0xd0] pmslt.h t1, a0, a4 -// CHECK-ASM: pmslt.h t1, a0, a4 # encoding: [0x3b,0x63,0xe5,0xd0] - +# CHECK-ASM-AND-OBJ: pmslt.b s2, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x69,0x6e,0xd4] pmslt.b s2, t3, t1 -// CHECK-ASM: pmslt.b s2, t3, t1 # encoding: [0x3b,0x69,0x6e,0xd4] - +# CHECK-ASM-AND-OBJ: pmsltu.h t1, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x63,0xe5,0xd9] pmsltu.h t1, a0, t5 -// CHECK-ASM: pmsltu.h t1, a0, t5 # encoding: [0x3b,0x63,0xe5,0xd9] - +# CHECK-ASM-AND-OBJ: pmsltu.b t3, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x6e,0x27,0xdd] pmsltu.b t3, a4, s2 -// CHECK-ASM: pmsltu.b t3, a4, s2 # encoding: [0x3b,0x6e,0x27,0xdd] - +# CHECK-ASM-AND-OBJ: pmin.h a2, a2, s2 +# CHECK-ASM: encoding: [0x3b,0x66,0x26,0xe1] pmin.h a2, a2, s2 -// CHECK-ASM: pmin.h a2, a2, s2 # encoding: [0x3b,0x66,0x26,0xe1] - +# CHECK-ASM-AND-OBJ: pmin.b t3, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x6e,0xa6,0xe4] pmin.b t3, a2, a0 -// CHECK-ASM: pmin.b t3, a2, a0 # encoding: [0x3b,0x6e,0xa6,0xe4] - +# CHECK-ASM-AND-OBJ: pminu.h a2, s2, t1 +# CHECK-ASM: encoding: [0x3b,0x66,0x69,0xe8] pminu.h a2, s2, t1 -// CHECK-ASM: pminu.h a2, s2, t1 # encoding: [0x3b,0x66,0x69,0xe8] - +# CHECK-ASM-AND-OBJ: pminu.b a0, t1, a0 +# CHECK-ASM: encoding: [0x3b,0x65,0xa3,0xec] pminu.b a0, t1, a0 -// CHECK-ASM: pminu.b a0, t1, a0 # encoding: [0x3b,0x65,0xa3,0xec] - +# CHECK-ASM-AND-OBJ: pmax.h a0, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x65,0xe4,0xf0] pmax.h a0, s0, a4 -// CHECK-ASM: pmax.h a0, s0, a4 # encoding: [0x3b,0x65,0xe4,0xf0] - +# CHECK-ASM-AND-OBJ: pmax.b t1, t3, a2 +# CHECK-ASM: encoding: [0x3b,0x63,0xce,0xf4] pmax.b t1, t3, a2 -// CHECK-ASM: pmax.b t1, t3, a2 # encoding: [0x3b,0x63,0xce,0xf4] - +# CHECK-ASM-AND-OBJ: pmaxu.h t1, a0, s2 +# CHECK-ASM: encoding: [0x3b,0x63,0x25,0xf9] pmaxu.h t1, a0, s2 -// CHECK-ASM: pmaxu.h t1, a0, s2 # encoding: [0x3b,0x63,0x25,0xf9] - +# CHECK-ASM-AND-OBJ: pmaxu.b t1, t3, s2 +# CHECK-ASM: encoding: [0x3b,0x63,0x2e,0xfd] pmaxu.b t1, t3, s2 -// CHECK-ASM: pmaxu.b t1, t3, s2 # encoding: [0x3b,0x63,0x2e,0xfd] - +# CHECK-ASM-AND-OBJ: pas.wx t1, a2, s0 +# CHECK-ASM: encoding: [0x3b,0x63,0x86,0x82] pas.wx t1, a2, s0 -// CHECK-ASM: pas.wx t1, a2, s0 # encoding: [0x3b,0x63,0x86,0x82] - +# CHECK-ASM-AND-OBJ: psa.wx t3, t3, a2 +# CHECK-ASM: encoding: [0x3b,0x6e,0xce,0x86] psa.wx t3, t3, a2 -// CHECK-ASM: psa.wx t3, t3, a2 # encoding: [0x3b,0x6e,0xce,0x86] - +# CHECK-ASM-AND-OBJ: psas.wx a4, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x67,0x27,0x93] psas.wx a4, a4, s2 -// CHECK-ASM: psas.wx a4, a4, s2 # encoding: [0x3b,0x67,0x27,0x93] - +# CHECK-ASM-AND-OBJ: pssa.wx a0, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x65,0xa6,0x96] pssa.wx a0, a2, a0 -// CHECK-ASM: pssa.wx a0, a2, a0 # encoding: [0x3b,0x65,0xa6,0x96] - +# CHECK-ASM-AND-OBJ: paas.wx s0, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x64,0x67,0x9a] paas.wx s0, a4, t1 -// CHECK-ASM: paas.wx s0, a4, t1 # encoding: [0x3b,0x64,0x67,0x9a] - +# CHECK-ASM-AND-OBJ: pasa.wx t1, s2, s2 +# CHECK-ASM: encoding: [0x3b,0x63,0x29,0x9f] pasa.wx t1, s2, s2 -// CHECK-ASM: pasa.wx t1, s2, s2 # encoding: [0x3b,0x63,0x29,0x9f] - +# CHECK-ASM-AND-OBJ: pmseq.w t1, a4, s2 +# CHECK-ASM: encoding: [0x3b,0x63,0x27,0xc3] pmseq.w t1, a4, s2 -// CHECK-ASM: pmseq.w t1, a4, s2 # encoding: [0x3b,0x63,0x27,0xc3] - +# CHECK-ASM-AND-OBJ: pmslt.w t5, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x6f,0xcf,0xd3] pmslt.w t5, t5, t3 -// CHECK-ASM: pmslt.w t5, t5, t3 # encoding: [0x3b,0x6f,0xcf,0xd3] - +# CHECK-ASM-AND-OBJ: pmsltu.w s2, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x69,0x67,0xda] pmsltu.w s2, a4, t1 -// CHECK-ASM: pmsltu.w s2, a4, t1 # encoding: [0x3b,0x69,0x67,0xda] - +# CHECK-ASM-AND-OBJ: pmin.w t5, a4, t5 +# CHECK-ASM: encoding: [0x3b,0x6f,0xe7,0xe3] pmin.w t5, a4, t5 -// CHECK-ASM: pmin.w t5, a4, t5 # encoding: [0x3b,0x6f,0xe7,0xe3] - +# CHECK-ASM-AND-OBJ: pminu.w a0, a2, a0 +# CHECK-ASM: encoding: [0x3b,0x65,0xa6,0xea] pminu.w a0, a2, a0 -// CHECK-ASM: pminu.w a0, a2, a0 # encoding: [0x3b,0x65,0xa6,0xea] - +# CHECK-ASM-AND-OBJ: pmax.w a0, s2, t1 +# CHECK-ASM: encoding: [0x3b,0x65,0x69,0xf2] pmax.w a0, s2, t1 -// CHECK-ASM: pmax.w a0, s2, t1 # encoding: [0x3b,0x65,0x69,0xf2] - +# CHECK-ASM-AND-OBJ: pmaxu.w a0, a4, a4 +# CHECK-ASM: encoding: [0x3b,0x65,0xe7,0xfa] pmaxu.w a0, a4, a4 -// CHECK-ASM: pmaxu.w a0, a4, a4 # encoding: [0x3b,0x65,0xe7,0xfa] - +# CHECK-ASM-AND-OBJ: pmulh.h a0, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x75,0x6f,0x80] pmulh.h a0, t5, t1 -// CHECK-ASM: pmulh.h a0, t5, t1 # encoding: [0x3b,0x75,0x6f,0x80] - +# CHECK-ASM-AND-OBJ: pmulhr.h s2, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x79,0xcf,0x85] pmulhr.h s2, t5, t3 -// CHECK-ASM: pmulhr.h s2, t5, t3 # encoding: [0x3b,0x79,0xcf,0x85] - +# CHECK-ASM-AND-OBJ: pmhacc.h t5, t3, a4 +# CHECK-ASM: encoding: [0x3b,0x7f,0xee,0x88] pmhacc.h t5, t3, a4 -// CHECK-ASM: pmhacc.h t5, t3, a4 # encoding: [0x3b,0x7f,0xee,0x88] - +# CHECK-ASM-AND-OBJ: pmhracc.h s2, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x79,0x2f,0x8d] pmhracc.h s2, t5, s2 -// CHECK-ASM: pmhracc.h s2, t5, s2 # encoding: [0x3b,0x79,0x2f,0x8d] - +# CHECK-ASM-AND-OBJ: pmulhu.h t3, t1, t1 +# CHECK-ASM: encoding: [0x3b,0x7e,0x63,0x90] pmulhu.h t3, t1, t1 -// CHECK-ASM: pmulhu.h t3, t1, t1 # encoding: [0x3b,0x7e,0x63,0x90] - +# CHECK-ASM-AND-OBJ: pmulhru.h s0, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x74,0x6f,0x94] pmulhru.h s0, t5, t1 -// CHECK-ASM: pmulhru.h s0, t5, t1 # encoding: [0x3b,0x74,0x6f,0x94] - +# CHECK-ASM-AND-OBJ: pmhaccu.h t3, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x7e,0xc5,0x99] pmhaccu.h t3, a0, t3 -// CHECK-ASM: pmhaccu.h t3, a0, t3 # encoding: [0x3b,0x7e,0xc5,0x99] - +# CHECK-ASM-AND-OBJ: pmhraccu.h t5, t3, a2 +# CHECK-ASM: encoding: [0x3b,0x7f,0xce,0x9c] pmhraccu.h t5, t3, a2 -// CHECK-ASM: pmhraccu.h t5, t3, a2 # encoding: [0x3b,0x7f,0xce,0x9c] - +# CHECK-ASM-AND-OBJ: pmulh.h.b0 t1, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x73,0xa5,0xa0] pmulh.h.b0 t1, a0, a0 -// CHECK-ASM: pmulh.h.b0 t1, a0, a0 # encoding: [0x3b,0x73,0xa5,0xa0] - +# CHECK-ASM-AND-OBJ: pmulhsu.h.b0 t3, s0, a4 +# CHECK-ASM: encoding: [0x3b,0x7e,0xe4,0xa4] pmulhsu.h.b0 t3, s0, a4 -// CHECK-ASM: pmulhsu.h.b0 t3, s0, a4 # encoding: [0x3b,0x7e,0xe4,0xa4] - +# CHECK-ASM-AND-OBJ: pmhaccu.h.b0 t1, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x73,0xe5,0xa8] pmhaccu.h.b0 t1, a0, a4 -// CHECK-ASM: pmhaccu.h.b0 t1, a0, a4 # encoding: [0x3b,0x73,0xe5,0xa8] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h.b0 s2, t5, t3 +# CHECK-ASM: encoding: [0x3b,0x79,0xcf,0xad] pmhaccsu.h.b0 s2, t5, t3 -// CHECK-ASM: pmhaccsu.h.b0 s2, t5, t3 # encoding: [0x3b,0x79,0xcf,0xad] - +# CHECK-ASM-AND-OBJ: pmulh.h.b1 a0, s0, a2 +# CHECK-ASM: encoding: [0x3b,0x75,0xc4,0xb0] pmulh.h.b1 a0, s0, a2 -// CHECK-ASM: pmulh.h.b1 a0, s0, a2 # encoding: [0x3b,0x75,0xc4,0xb0] - +# CHECK-ASM-AND-OBJ: pmulhsu.h.b1 t1, t3, t3 +# CHECK-ASM: encoding: [0x3b,0x73,0xce,0xb5] pmulhsu.h.b1 t1, t3, t3 -// CHECK-ASM: pmulhsu.h.b1 t1, t3, t3 # encoding: [0x3b,0x73,0xce,0xb5] - +# CHECK-ASM-AND-OBJ: pmhacc.h.b1 t3, t5, s2 +# CHECK-ASM: encoding: [0x3b,0x7e,0x2f,0xb9] pmhacc.h.b1 t3, t5, s2 -// CHECK-ASM: pmhacc.h.b1 t3, t5, s2 # encoding: [0x3b,0x7e,0x2f,0xb9] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h.b1 t5, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x7f,0x6f,0xbc] pmhaccsu.h.b1 t5, t5, t1 -// CHECK-ASM: pmhaccsu.h.b1 t5, t5, t1 # encoding: [0x3b,0x7f,0x6f,0xbc] - +# CHECK-ASM-AND-OBJ: pmulhsu.h s2, t3, a4 +# CHECK-ASM: encoding: [0x3b,0x79,0xee,0xc0] pmulhsu.h s2, t3, a4 -// CHECK-ASM: pmulhsu.h s2, t3, a4 # encoding: [0x3b,0x79,0xee,0xc0] - +# CHECK-ASM-AND-OBJ: pmulhrsu.h a0, a0, t5 +# CHECK-ASM: encoding: [0x3b,0x75,0xe5,0xc5] pmulhrsu.h a0, a0, t5 -// CHECK-ASM: pmulhrsu.h a0, a0, t5 # encoding: [0x3b,0x75,0xe5,0xc5] - +# CHECK-ASM-AND-OBJ: pmhaccsu.h s0, t3, t1 +# CHECK-ASM: encoding: [0x3b,0x74,0x6e,0xc8] pmhaccsu.h s0, t3, t1 -// CHECK-ASM: pmhaccsu.h s0, t3, t1 # encoding: [0x3b,0x74,0x6e,0xc8] - +# CHECK-ASM-AND-OBJ: pmhraccsu.h s0, t5, a4 +# CHECK-ASM: encoding: [0x3b,0x74,0xef,0xcc] pmhraccsu.h s0, t5, a4 -// CHECK-ASM: pmhraccsu.h s0, t5, a4 # encoding: [0x3b,0x74,0xef,0xcc] - +# CHECK-ASM-AND-OBJ: pmulq.h t3, t1, s0 +# CHECK-ASM: encoding: [0x3b,0x7e,0x83,0xd0] pmulq.h t3, t1, s0 -// CHECK-ASM: pmulq.h t3, t1, s0 # encoding: [0x3b,0x7e,0x83,0xd0] - +# CHECK-ASM-AND-OBJ: pmulqr.h t1, s2, s0 +# CHECK-ASM: encoding: [0x3b,0x73,0x89,0xd4] pmulqr.h t1, s2, s0 -// CHECK-ASM: pmulqr.h t1, s2, s0 # encoding: [0x3b,0x73,0x89,0xd4] - +# CHECK-ASM-AND-OBJ: pmulh.w t5, a4, a4 +# CHECK-ASM: encoding: [0x3b,0x7f,0xe7,0x82] pmulh.w t5, a4, a4 -// CHECK-ASM: pmulh.w t5, a4, a4 # encoding: [0x3b,0x7f,0xe7,0x82] - +# CHECK-ASM-AND-OBJ: pmulhr.w t1, t5, t1 +# CHECK-ASM: encoding: [0x3b,0x73,0x6f,0x86] pmulhr.w t1, t5, t1 -// CHECK-ASM: pmulhr.w t1, t5, t1 # encoding: [0x3b,0x73,0x6f,0x86] - +# CHECK-ASM-AND-OBJ: pmhacc.w t5, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x7f,0xe4,0x8b] pmhacc.w t5, s0, t5 -// CHECK-ASM: pmhacc.w t5, s0, t5 # encoding: [0x3b,0x7f,0xe4,0x8b] - +# CHECK-ASM-AND-OBJ: pmhracc.w s0, s2, t5 +# CHECK-ASM: encoding: [0x3b,0x74,0xe9,0x8f] pmhracc.w s0, s2, t5 -// CHECK-ASM: pmhracc.w s0, s2, t5 # encoding: [0x3b,0x74,0xe9,0x8f] - +# CHECK-ASM-AND-OBJ: pmulhu.w a2, a0, a4 +# CHECK-ASM: encoding: [0x3b,0x76,0xe5,0x92] pmulhu.w a2, a0, a4 -// CHECK-ASM: pmulhu.w a2, a0, a4 # encoding: [0x3b,0x76,0xe5,0x92] - +# CHECK-ASM-AND-OBJ: pmulhru.w t1, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x73,0xe3,0x96] pmulhru.w t1, t1, a4 -// CHECK-ASM: pmulhru.w t1, t1, a4 # encoding: [0x3b,0x73,0xe3,0x96] - +# CHECK-ASM-AND-OBJ: pmhaccu.w a0, s0, a0 +# CHECK-ASM: encoding: [0x3b,0x75,0xa4,0x9a] pmhaccu.w a0, s0, a0 -// CHECK-ASM: pmhaccu.w a0, s0, a0 # encoding: [0x3b,0x75,0xa4,0x9a] - +# CHECK-ASM-AND-OBJ: pmhraccu.w s2, s0, t3 +# CHECK-ASM: encoding: [0x3b,0x79,0xc4,0x9f] pmhraccu.w s2, s0, t3 -// CHECK-ASM: pmhraccu.w s2, s0, t3 # encoding: [0x3b,0x79,0xc4,0x9f] - +# CHECK-ASM-AND-OBJ: pmulh.w.h0 t5, s0, t5 +# CHECK-ASM: encoding: [0x3b,0x7f,0xe4,0xa3] pmulh.w.h0 t5, s0, t5 -// CHECK-ASM: pmulh.w.h0 t5, s0, t5 # encoding: [0x3b,0x7f,0xe4,0xa3] - +# CHECK-ASM-AND-OBJ: pmulhsu.w.h0 a2, t3, a2 +# CHECK-ASM: encoding: [0x3b,0x76,0xce,0xa6] pmulhsu.w.h0 a2, t3, a2 -// CHECK-ASM: pmulhsu.w.h0 a2, t3, a2 # encoding: [0x3b,0x76,0xce,0xa6] - +# CHECK-ASM-AND-OBJ: pmhacc.w.h0 a2, a0, t1 +# CHECK-ASM: encoding: [0x3b,0x76,0x65,0xaa] pmhacc.w.h0 a2, a0, t1 -// CHECK-ASM: pmhacc.w.h0 a2, a0, t1 # encoding: [0x3b,0x76,0x65,0xaa] - +# CHECK-ASM-AND-OBJ: pmhaccsu.w.h0 t1, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x73,0x67,0xae] pmhaccsu.w.h0 t1, a4, t1 -// CHECK-ASM: pmhaccsu.w.h0 t1, a4, t1 # encoding: [0x3b,0x73,0x67,0xae] - +# CHECK-ASM-AND-OBJ: pmulh.w.h1 t1, a0, t3 +# CHECK-ASM: encoding: [0x3b,0x73,0xc5,0xb3] pmulh.w.h1 t1, a0, t3 -// CHECK-ASM: pmulh.w.h1 t1, a0, t3 # encoding: [0x3b,0x73,0xc5,0xb3] - +# CHECK-ASM-AND-OBJ: pmulhsu.w.h1 s2, t3, a4 +# CHECK-ASM: encoding: [0x3b,0x79,0xee,0xb6] pmulhsu.w.h1 s2, t3, a4 -// CHECK-ASM: pmulhsu.w.h1 s2, t3, a4 # encoding: [0x3b,0x79,0xee,0xb6] - +# CHECK-ASM-AND-OBJ: pmhacc.w.h1 s0, t5, a2 +# CHECK-ASM: encoding: [0x3b,0x74,0xcf,0xba] pmhacc.w.h1 s0, t5, a2 -// CHECK-ASM: pmhacc.w.h1 s0, t5, a2 # encoding: [0x3b,0x74,0xcf,0xba] - +# CHECK-ASM-AND-OBJ: pmhaccsu.w.h1 a0, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x75,0xa5,0xbe] pmhaccsu.w.h1 a0, a0, a0 -// CHECK-ASM: pmhaccsu.w.h1 a0, a0, a0 # encoding: [0x3b,0x75,0xa5,0xbe] - +# CHECK-ASM-AND-OBJ: pmulhsu.w t3, a2, a4 +# CHECK-ASM: encoding: [0x3b,0x7e,0xe6,0xc2] pmulhsu.w t3, a2, a4 -// CHECK-ASM: pmulhsu.w t3, a2, a4 # encoding: [0x3b,0x7e,0xe6,0xc2] - +# CHECK-ASM-AND-OBJ: pmulhrsu.w t5, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x7f,0xa5,0xc6] pmulhrsu.w t5, a0, a0 -// CHECK-ASM: pmulhrsu.w t5, a0, a0 # encoding: [0x3b,0x7f,0xa5,0xc6] - +# CHECK-ASM-AND-OBJ: pmhaccsu.w a4, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x77,0xa5,0xca] pmhaccsu.w a4, a0, a0 -// CHECK-ASM: pmhaccsu.w a4, a0, a0 # encoding: [0x3b,0x77,0xa5,0xca] - +# CHECK-ASM-AND-OBJ: pmhraccsu.w t5, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x7f,0xc3,0xcf] pmhraccsu.w t5, t1, t3 -// CHECK-ASM: pmhraccsu.w t5, t1, t3 # encoding: [0x3b,0x7f,0xc3,0xcf] - +# CHECK-ASM-AND-OBJ: pmulq.w a2, a2, t5 +# CHECK-ASM: encoding: [0x3b,0x76,0xe6,0xd3] pmulq.w a2, a2, t5 -// CHECK-ASM: pmulq.w a2, a2, t5 # encoding: [0x3b,0x76,0xe6,0xd3] - +# CHECK-ASM-AND-OBJ: pmulqr.w a0, t3, t5 +# CHECK-ASM: encoding: [0x3b,0x75,0xee,0xd7] pmulqr.w a0, t3, t5 -// CHECK-ASM: pmulqr.w a0, t3, t5 # encoding: [0x3b,0x75,0xee,0xd7] - +# CHECK-ASM-AND-OBJ: pmqacc.w.h00 t5, a4, t1 +# CHECK-ASM: encoding: [0x3b,0x7f,0x67,0xe8] pmqacc.w.h00 t5, a4, t1 -// CHECK-ASM: pmqacc.w.h00 t5, a4, t1 # encoding: [0x3b,0x7f,0x67,0xe8] - +# CHECK-ASM-AND-OBJ: mqacc.w00 t1, t1, a0 +# CHECK-ASM: encoding: [0x3b,0x73,0xa3,0xea] mqacc.w00 t1, t1, a0 -// CHECK-ASM: mqacc.w00 t1, t1, a0 # encoding: [0x3b,0x73,0xa3,0xea] - +# CHECK-ASM-AND-OBJ: pmqracc.w.h00 t1, a2, t5 +# CHECK-ASM: encoding: [0x3b,0x73,0xe6,0xed] pmqracc.w.h00 t1, a2, t5 -// CHECK-ASM: pmqracc.w.h00 t1, a2, t5 # encoding: [0x3b,0x73,0xe6,0xed] - +# CHECK-ASM-AND-OBJ: mqracc.w00 s2, s2, a2 +# CHECK-ASM: encoding: [0x3b,0x79,0xc9,0xee] mqracc.w00 s2, s2, a2 -// CHECK-ASM: mqracc.w00 s2, s2, a2 # encoding: [0x3b,0x79,0xc9,0xee] - +# CHECK-ASM-AND-OBJ: pmqacc.w.h11 a2, a0, a0 +# CHECK-ASM: encoding: [0x3b,0x76,0xa5,0xf8] pmqacc.w.h11 a2, a0, a0 -// CHECK-ASM: pmqacc.w.h11 a2, a0, a0 # encoding: [0x3b,0x76,0xa5,0xf8] - +# CHECK-ASM-AND-OBJ: mqacc.w11 a4, a2, a2 +# CHECK-ASM: encoding: [0x3b,0x77,0xc6,0xfa] mqacc.w11 a4, a2, a2 -// CHECK-ASM: mqacc.w11 a4, a2, a2 # encoding: [0x3b,0x77,0xc6,0xfa] - +# CHECK-ASM-AND-OBJ: pmqracc.w.h11 s0, t1, t3 +# CHECK-ASM: encoding: [0x3b,0x74,0xc3,0xfd] pmqracc.w.h11 s0, t1, t3 -// CHECK-ASM: pmqracc.w.h11 s0, t1, t3 # encoding: [0x3b,0x74,0xc3,0xfd] - +# CHECK-ASM-AND-OBJ: mqracc.w11 s2, t1, a4 +# CHECK-ASM: encoding: [0x3b,0x79,0xe3,0xfe] mqracc.w11 s2, t1, a4 -// CHECK-ASM: mqracc.w11 s2, t1, a4 # encoding: [0x3b,0x79,0xe3,0xfe] From cba5a9045390e241147752ab00b6ff72f263da65 Mon Sep 17 00:00:00 2001 From: realqhc Date: Fri, 28 Feb 2025 10:01:22 +1100 Subject: [PATCH 10/17] Update llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp Co-authored-by: Min-Yih Hsu --- llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp index a32cbd58f30f2..465093d4f9161 100644 --- a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp +++ b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp @@ -227,8 +227,7 @@ static DecodeStatus DecodeGPRPairRegisterClass(MCInst &Inst, uint32_t RegNo, static DecodeStatus decodeRVPGPRPair(MCInst &Inst, uint32_t RegNo, uint64_t Address, const MCDisassembler *Decoder) { - RegNo = RegNo << 1; - return DecodeGPRPairRegisterClass(Inst, RegNo, Address, Decoder); + return DecodeGPRPairRegisterClass(Inst, RegNo << 1, Address, Decoder); } static DecodeStatus DecodeSR07RegisterClass(MCInst &Inst, uint32_t RegNo, From a7a744802d74cf90f7fdb47afcecac50bf7049ac Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 28 Feb 2025 11:06:41 +1100 Subject: [PATCH 11/17] fix code indentation, move opcodestr after funct3 --- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 212 +++++++++++------------ 1 file changed, 106 insertions(+), 106 deletions(-) diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 5ed25c629ebc0..c3de1ee545d58 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -138,8 +138,8 @@ class RVPUnary0F0Rs1pRdp f, bits<7> wuimm, string opcodestr, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPBinaryFW f, bit aft, bits<2> w, string opcodestr, - bits<3> funct3, RISCVOpcode Opcode = OPC_OP_32, +class RVPBinaryFW f, bit aft, bits<2> w, bits<3> funct3, + string opcodestr, RISCVOpcode Opcode = OPC_OP_32, dag outs = (outs GPR:$rd), dag ins = (ins GPR:$rs1, GPR:$rs2), string argstr = "$rd, $rs1, $rs2"> : RVInstRBase { @@ -149,17 +149,17 @@ class RVPBinaryFW f, bit aft, bits<2> w, string opcodestr, let Inst{26-25} = w; } -class RVPBinary1F1W f, bits<2> w, string opcodestr, bits<3> funct3, +class RVPBinary1F1W f, bits<2> w, bits<3> funct3, string opcodestr, RISCVOpcode Opcode = OPC_OP_IMM_32> - : RVPBinaryFW<1, f, 1, w, opcodestr, funct3, Opcode>; + : RVPBinaryFW<1, f, 1, w, funct3, opcodestr, Opcode>; -class RVPBinary1F0W f, bits<2> w, string opcodestr, bits<3> funct3, +class RVPBinary1F0W f, bits<2> w, bits<3> funct3, string opcodestr, RISCVOpcode Opcode = OPC_OP_32> - : RVPBinaryFW<1, f, 0, w, opcodestr, funct3, Opcode>; + : RVPBinaryFW<1, f, 0, w, funct3, opcodestr, Opcode>; class RVPBinary0F1WRdp f, bits<2> w, string opcodestr, RISCVOpcode Opcode = OPC_OP_IMM_32> - : RVPBinaryFW<0, f, 1, w, opcodestr, 0b010, Opcode, (outs RVPGPRPairRV32:$rdp), + : RVPBinaryFW<0, f, 1, w, 0b010, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), (ins GPR:$rs1, GPR:$rs2), "$rdp, $rs1, $rs2"> { bits<4> rdp; @@ -169,7 +169,7 @@ class RVPBinary0F1WRdp f, bits<2> w, string opcodestr, class RVPBinary0F1WRs1p 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), + : RVPBinaryFW<0, f, 1, w, 0b100, opcodestr, Opcode, (outs GPR:$rd), (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rd, $rs1p, $rs2"> { bits<4> rs1p; @@ -179,7 +179,7 @@ class RVPBinary0F1WRs1p f, bits<2> w, string opcodestr, class RVPBinary0F1WRs1pRdp f, bits<2> w, string opcodestr, bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32> - : RVPBinaryFW<0, f, 1, w, opcodestr, 0b110, Opcode, (outs RVPGPRPairRV32:$rdp), + : RVPBinaryFW<0, f, 1, w, 0b110, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rdp, $rs1p, $rs2"> { bits<4> rs1p; bits<4> rdp; @@ -214,7 +214,7 @@ class RVPBinary1FWRs2pRs1pRdp f, bits<2> w, string opcodestr, class RVPBinary1F0WRs2pRs1pRdp 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 RVPGPRPairRV32:$rdp), + : RVPBinaryFW<1, f, 0, w, 0b110, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), (ins RVPGPRPairRV32:$rs1p, RVPGPRPairRV32:$rs2p), "$rdp, $rs1p, $rs2p"> { bits<4> rs1p; bits<4> rs2p; @@ -229,8 +229,8 @@ class RVPBinary1F0WRs2pRs1pRdp f, bits<2> w, string opcodestr, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPBinaryLongFW f, bits<2> w, string opcodestr, - bits<3> funct3, dag outs, dag ins, string argstr> +class RVPBinaryLongFW f, bits<2> w, bits<3> funct3, + string opcodestr, dag outs, dag ins, string argstr> : RVInstRBase { let Inst{31} = bfr; @@ -239,11 +239,11 @@ class RVPBinaryLongFW f, bits<2> w, string opcodestr, } class RVPBinary1LongFW f, bits<2> w, bits<3> funct3, string opcodestr> - : RVPBinaryLongFW<1, f, w, opcodestr, funct3, (outs GPR:$rd), + : RVPBinaryLongFW<1, f, w, funct3, opcodestr, (outs GPR:$rd), (ins GPR:$rs1, GPR:$rs2), "$rd, $rs1, $rs2">; class RVPBinary0LongFW f, bits<2> w, string opcodestr> - : RVPBinaryLongFW<0, f, w, opcodestr, 0b010, (outs RVPGPRPairRV32:$rdp), + : RVPBinaryLongFW<0, f, w, 0b010, opcodestr, (outs RVPGPRPairRV32:$rdp), (ins GPR:$rs1, RVPGPRPairRV32:$rs2), "$rdp, $rs1, $rs2"> { bits<4> rdp; @@ -311,26 +311,26 @@ let Predicates = [HasStdExtP, IsRV64] in def PLUI_W : RVPUnaryImm9<0b1111001, "plui.w">; let Predicates = [HasStdExtP] in { -def PSLL_HS : RVPBinary1F1W<0b000, 0b00, "psll.hs", 0b010>; -def PSLL_BS : RVPBinary1F1W<0b000, 0b10, "psll.bs", 0b010>; -def PADD_HS : RVPBinary1F1W<0b001, 0b00, "padd.hs", 0b010>; -def PADD_BS : RVPBinary1F1W<0b001, 0b10, "padd.bs", 0b010>; -def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, "pssha.hs", 0b010>; -def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, "psshar.hs", 0b010>; +def PSLL_HS : RVPBinary1F1W<0b000, 0b00, 0b010, "psll.hs">; +def PSLL_BS : RVPBinary1F1W<0b000, 0b10, 0b010, "psll.bs">; +def PADD_HS : RVPBinary1F1W<0b001, 0b00, 0b010, "padd.hs">; +def PADD_BS : RVPBinary1F1W<0b001, 0b10, 0b010, "padd.bs">; +def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, 0b010, "pssha.hs">; +def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, 0b010, "psshar.hs">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { -def SSHA : RVPBinary1F1W<0b110, 0b01, "ssha", 0b010>; -def SSHAR : RVPBinary1F1W<0b111, 0b01, "sshar", 0b010>; +def SSHA : RVPBinary1F1W<0b110, 0b01, 0b010, "ssha">; +def SSHAR : RVPBinary1F1W<0b111, 0b01, 0b010, "sshar">; } // Predicates = [HasStdExtP, IsRV32] let Predicates = [HasStdExtP, IsRV64] in { -def PSLL_WS : RVPBinary1F1W<0b000, 0b01, "psll.ws", 0b010>; -def PADD_WS : RVPBinary1F1W<0b001, 0b01, "padd.ws", 0b010>; -def PSSHA_WS : RVPBinary1F1W<0b110, 0b01, "pssha.ws", 0b010>; -def PSSHAR_WS : RVPBinary1F1W<0b111, 0b01, "psshar.ws", 0b010>; -def SHA : RVPBinary1F1W<0b110, 0b11, "sha", 0b010>; -def SHAR : RVPBinary1F1W<0b111, 0b11, "shar", 0b010>; +def PSLL_WS : RVPBinary1F1W<0b000, 0b01, 0b010, "psll.ws">; +def PADD_WS : RVPBinary1F1W<0b001, 0b01, 0b010, "padd.ws">; +def PSSHA_WS : RVPBinary1F1W<0b110, 0b01, 0b010, "pssha.ws">; +def PSSHAR_WS : RVPBinary1F1W<0b111, 0b01, 0b010, "psshar.ws">; +def SHA : RVPBinary1F1W<0b110, 0b11, 0b010, "sha">; +def SHAR : RVPBinary1F1W<0b111, 0b11, 0b010, "shar">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in { @@ -356,21 +356,21 @@ def USATI_RV64 : RVPUnary1F0<0b010, 0b1000000, "usati">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in { -def PSRL_HS : RVPBinary1F1W<0b000, 0b00, "psrl.hs", 0b100>; -def PSRL_BS : RVPBinary1F1W<0b000, 0b10, "psrl.bs", 0b100>; -def PREDSUM_HS : RVPBinary1F1W<0b001, 0b00, "predsum.hs", 0b100>; -def PREDSUM_BS : RVPBinary1F1W<0b001, 0b10, "predsum.bs", 0b100>; -def PREDSUMU_HS : RVPBinary1F1W<0b011, 0b00, "predsumu.hs", 0b100>; -def PREDSUMU_BS : RVPBinary1F1W<0b011, 0b10, "predsumu.bs", 0b100>; -def PSRA_HS : RVPBinary1F1W<0b100, 0b00, "psra.hs", 0b100>; -def PSRA_BS : RVPBinary1F1W<0b100, 0b10, "psra.bs", 0b100>; +def PSRL_HS : RVPBinary1F1W<0b000, 0b00, 0b100, "psrl.hs">; +def PSRL_BS : RVPBinary1F1W<0b000, 0b10, 0b100, "psrl.bs">; +def PREDSUM_HS : RVPBinary1F1W<0b001, 0b00, 0b100, "predsum.hs">; +def PREDSUM_BS : RVPBinary1F1W<0b001, 0b10, 0b100, "predsum.bs">; +def PREDSUMU_HS : RVPBinary1F1W<0b011, 0b00, 0b100, "predsumu.hs">; +def PREDSUMU_BS : RVPBinary1F1W<0b011, 0b10, 0b100, "predsumu.bs">; +def PSRA_HS : RVPBinary1F1W<0b100, 0b00, 0b100, "psra.hs">; +def PSRA_BS : RVPBinary1F1W<0b100, 0b10, 0b100, "psra.bs">; } // Predicates = [HasStdExtP] let Predicates = [HasStdExtP, IsRV64] in { -def PSRL_WS : RVPBinary1F1W<0b000, 0b01, "psrl.ws", 0b100>; -def PREDSUM_WS : RVPBinary1F1W<0b001, 0b01, "predsum.ws", 0b100>; -def PREDSUMU_WS : RVPBinary1F1W<0b011, 0b01, "predsumu.ws", 0b100>; -def PSRA_WS : RVPBinary1F1W<0b100, 0b01, "psra.ws", 0b100>; +def PSRL_WS : RVPBinary1F1W<0b000, 0b01, 0b100, "psrl.ws">; +def PREDSUM_WS : RVPBinary1F1W<0b001, 0b01, 0b100, "predsum.ws">; +def PREDSUMU_WS : RVPBinary1F1W<0b011, 0b01, 0b100, "predsumu.ws">; +def PSRA_WS : RVPBinary1F1W<0b100, 0b01, 0b100, "psra.ws">; } // Predicates = [HasStdExtP, IsRV64] @@ -472,26 +472,26 @@ def MACCU_W01 : RVPBinary1LongFW<0b0111, 0b11, 0b001, "maccu.w01">; let Predicates = [HasStdExtP] in { -def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, "psh1add.h", 0b010>; -def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, "pssh1sadd.h", 0b010>; +def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, 0b010, "psh1add.h">; +def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, 0b010, "pssh1sadd.h">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RISCV32Only_", Predicates = [HasStdExtP, IsRV32] in { -def SSH1SADD : RVPBinary1F0W<0b010, 0b01, "ssh1sadd", 0b010>; +def SSH1SADD : RVPBinary1F0W<0b010, 0b01, 0b010, "ssh1sadd">; } // 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>; +def PSH1ADD_W : RVPBinary1F0W<0b010, 0b01, 0b010, "psh1add.w">; +def PSSH1SADD_W : RVPBinary1F0W<0b011, 0b01, 0b010, "pssh1sadd.w">; + +def UNZIP8P : RVPBinary1F0W<0b110, 0b00, 0b010, "unzip8p">; +def UNZIP16P : RVPBinary1F0W<0b110, 0b01, 0b010, "unzip16p">; +def UNZIP8HP : RVPBinary1F0W<0b110, 0b10, 0b010, "unzip8hp">; +def UNZIP16HP : RVPBinary1F0W<0b110, 0b11, 0b010, "unzip16hp">; +def ZIP8P : RVPBinary1F0W<0b111, 0b00, 0b010, "zip8p">; +def ZIP16P : RVPBinary1F0W<0b111, 0b01, 0b010, "zip16p">; +def ZIP8HP : RVPBinary1F0W<0b111, 0b10, 0b010, "zip8hp">; +def ZIP16HP : RVPBinary1F0W<0b111, 0b11, 0b010, "zip16hp">; } // Predicates = [HasStdExtP, IsRV64] @@ -554,26 +554,26 @@ def MACCSU_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b011, "maccsu.w11">; 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>; +def PPACK_H : RVPBinary1F0W<0b000, 0b00, 0b100, "ppack.h">; +def PPACKBT_H : RVPBinary1F0W<0b001, 0b00, 0b100, "ppackbt.h">; +def PPACKTB_H : RVPBinary1F0W<0b010, 0b00, 0b100, "ppacktb.h">; +def PPACKT_H : RVPBinary1F0W<0b011, 0b00, 0b100, "ppackt.h">; } // 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>; +def PACKBT : RVPBinary1F0W<0b001, 0b01, 0b100, "packbt">; +def PACKTB : RVPBinary1F0W<0b010, 0b01, 0b100, "packtb">; +def PACKT : RVPBinary1F0W<0b011, 0b01, 0b100, "packt">; } // 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>; +def PPACK_W : RVPBinary1F0W<0b000, 0b01, 0b100, "ppack.w">; +def PPACKBT_W : RVPBinary1F0W<0b001, 0b01, 0b100, "ppackbt.w">; +def PPACKBT : RVPBinary1F0W<0b001, 0b11, 0b100, "ppackbt">; +def PPACKTB_W : RVPBinary1F0W<0b010, 0b01, 0b100, "ppacktb.w">; +def PPACKTB : RVPBinary1F0W<0b010, 0b11, 0b100, "ppacktb">; +def PPACKT_W : RVPBinary1F0W<0b011, 0b01, 0b100, "ppackt.w">; +def PPACKT : RVPBinary1F0W<0b011, 0b11, 0b100, "ppackt">; } // Predicates = [HasStdExtP, IsRV64] @@ -702,14 +702,14 @@ def PMULHRU_H : RVPBinary1LongFW<0b0010, 0b10, 0b111, "pmulhru.h">; def PMHACCU_H : RVPBinary1LongFW<0b0011, 0b00, 0b111, "pmhaccu.h">; def PMHRACCU_H : RVPBinary1LongFW<0b0011, 0b10, 0b111, "pmhraccu.h">; -def PMULH_H_B0 : RVPBinary1LongFW<0b0100, 0b00, 0b111, "pmulh.h.b0">; -def PMULHSU_H_B0 : RVPBinary1LongFW<0b0100, 0b10, 0b111, "pmulhsu.h.b0">; -def PMHACCU_H_B0 : RVPBinary1LongFW<0b0101, 0b00, 0b111, "pmhaccu.h.b0">; -def PMHACCSU_H_B0: RVPBinary1LongFW<0b0101, 0b10, 0b111, "pmhaccsu.h.b0">; -def PMULH_H_B1 : RVPBinary1LongFW<0b0110, 0b00, 0b111, "pmulh.h.b1">; -def PMULHSU_H_B1 : RVPBinary1LongFW<0b0110, 0b10, 0b111, "pmulhsu.h.b1">; -def PMHACC_H_B1 : RVPBinary1LongFW<0b0111, 0b00, 0b111, "pmhacc.h.b1">; -def PMHACCSU_H_B1: RVPBinary1LongFW<0b0111, 0b10, 0b111, "pmhaccsu.h.b1">; +def PMULH_H_B0 : RVPBinary1LongFW<0b0100, 0b00, 0b111, "pmulh.h.b0">; +def PMULHSU_H_B0 : RVPBinary1LongFW<0b0100, 0b10, 0b111, "pmulhsu.h.b0">; +def PMHACCU_H_B0 : RVPBinary1LongFW<0b0101, 0b00, 0b111, "pmhaccu.h.b0">; +def PMHACCSU_H_B0 : RVPBinary1LongFW<0b0101, 0b10, 0b111, "pmhaccsu.h.b0">; +def PMULH_H_B1 : RVPBinary1LongFW<0b0110, 0b00, 0b111, "pmulh.h.b1">; +def PMULHSU_H_B1 : RVPBinary1LongFW<0b0110, 0b10, 0b111, "pmulhsu.h.b1">; +def PMHACC_H_B1 : RVPBinary1LongFW<0b0111, 0b00, 0b111, "pmhacc.h.b1">; +def PMHACCSU_H_B1 : RVPBinary1LongFW<0b0111, 0b10, 0b111, "pmhaccsu.h.b1">; def PMULHSU_H : RVPBinary1LongFW<0b1000, 0b00, 0b111, "pmulhsu.h">; def PMULHRSU_H : RVPBinary1LongFW<0b1000, 0b10, 0b111, "pmulhrsu.h">; @@ -897,28 +897,28 @@ def PNCLIPRI_B : RVPUnary0F0Rs1p<0b111, 0b0010000, "pnclipri.b">; def PNCLIPRI_H : RVPUnary0F0Rs1p<0b111, 0b0100000, "pnclipri.h">; def NCLIPRI : RVPUnary0F0Rs1p<0b111, 0b1000000, "nclipri">; -def PNSRL_BS : RVPBinary0F1WRs1p<0b000, 0b00, "pnsrl.bs", 0b1>; -def PNSRL_HS : RVPBinary0F1WRs1p<0b000, 0b01, "pnsrl.hs", 0b1>; -def NSRL : RVPBinary0F1WRs1p<0b000, 0b11, "nsrl", 0b1>; -def PNCLIPU_BS : RVPBinary0F1WRs1p<0b010, 0b00, "pnclipu.bs", 0b1>; -def PNCLIPU_HS : RVPBinary0F1WRs1p<0b010, 0b01, "pnclipu.hs", 0b1>; -def NCLIPU : RVPBinary0F1WRs1p<0b010, 0b11, "nclipu", 0b1>; -def PNCLIPRU_BS : RVPBinary0F1WRs1p<0b011, 0b00, "pnclipru.bs", 0b1>; -def PNCLIPRU_HS : RVPBinary0F1WRs1p<0b011, 0b01, "pnclipru.hs", 0b1>; -def NCLIPRU : RVPBinary0F1WRs1p<0b011, 0b11, "nclipru", 0b1>; - -def PNSRA_BS : RVPBinary0F1WRs1p<0b100, 0b00, "pnsra.bs", 0b1>; -def PNSRA_HS : RVPBinary0F1WRs1p<0b100, 0b01, "pnsra.hs", 0b1>; -def NSRA : RVPBinary0F1WRs1p<0b100, 0b11, "nsra", 0b1>; -def PNSRAR_BS : RVPBinary0F1WRs1p<0b101, 0b00, "pnsrar.bs", 0b1>; -def PNSRAR_HS : RVPBinary0F1WRs1p<0b101, 0b01, "pnsrar.hs", 0b1>; -def NSRAR : RVPBinary0F1WRs1p<0b101, 0b11, "nsrar", 0b1>; -def PNCLIP_BS : RVPBinary0F1WRs1p<0b110, 0b00, "pnclip.bs", 0b1>; -def PNCLIP_HS : RVPBinary0F1WRs1p<0b110, 0b01, "pnclip.hs", 0b1>; -def NCLIP : RVPBinary0F1WRs1p<0b110, 0b11, "nclip", 0b1>; -def PNCLIPR_BS : RVPBinary0F1WRs1p<0b111, 0b00, "pnclipr.bs", 0b1>; -def PNCLIPR_HS : RVPBinary0F1WRs1p<0b111, 0b01, "pnclipr.hs", 0b1>; -def NCLIPR : RVPBinary0F1WRs1p<0b111, 0b11, "nclipr", 0b1>; +def PNSRL_BS : RVPBinary0F1WRs1p<0b000, 0b00, "pnsrl.bs", 0b1>; +def PNSRL_HS : RVPBinary0F1WRs1p<0b000, 0b01, "pnsrl.hs", 0b1>; +def NSRL : RVPBinary0F1WRs1p<0b000, 0b11, "nsrl", 0b1>; +def PNCLIPU_BS : RVPBinary0F1WRs1p<0b010, 0b00, "pnclipu.bs", 0b1>; +def PNCLIPU_HS : RVPBinary0F1WRs1p<0b010, 0b01, "pnclipu.hs", 0b1>; +def NCLIPU : RVPBinary0F1WRs1p<0b010, 0b11, "nclipu", 0b1>; +def PNCLIPRU_BS : RVPBinary0F1WRs1p<0b011, 0b00, "pnclipru.bs", 0b1>; +def PNCLIPRU_HS : RVPBinary0F1WRs1p<0b011, 0b01, "pnclipru.hs", 0b1>; +def NCLIPRU : RVPBinary0F1WRs1p<0b011, 0b11, "nclipru", 0b1>; + +def PNSRA_BS : RVPBinary0F1WRs1p<0b100, 0b00, "pnsra.bs", 0b1>; +def PNSRA_HS : RVPBinary0F1WRs1p<0b100, 0b01, "pnsra.hs", 0b1>; +def NSRA : RVPBinary0F1WRs1p<0b100, 0b11, "nsra", 0b1>; +def PNSRAR_BS : RVPBinary0F1WRs1p<0b101, 0b00, "pnsrar.bs", 0b1>; +def PNSRAR_HS : RVPBinary0F1WRs1p<0b101, 0b01, "pnsrar.hs", 0b1>; +def NSRAR : RVPBinary0F1WRs1p<0b101, 0b11, "nsrar", 0b1>; +def PNCLIP_BS : RVPBinary0F1WRs1p<0b110, 0b00, "pnclip.bs", 0b1>; +def PNCLIP_HS : RVPBinary0F1WRs1p<0b110, 0b01, "pnclip.hs", 0b1>; +def NCLIP : RVPBinary0F1WRs1p<0b110, 0b11, "nclip", 0b1>; +def PNCLIPR_BS : RVPBinary0F1WRs1p<0b111, 0b00, "pnclipr.bs", 0b1>; +def PNCLIPR_HS : RVPBinary0F1WRs1p<0b111, 0b01, "pnclipr.hs", 0b1>; +def NCLIPR : RVPBinary0F1WRs1p<0b111, 0b11, "nclipr", 0b1>; def PSLLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "pslli.db">; @@ -934,16 +934,16 @@ def PSEXT_DW_H : RVPUnaryWUFRs1pRdp<0b01, 0b00101, "psext.dw.h">; def PSABS_DH : RVPUnaryWUFRs1pRdp<0b00, 0b00111, "psabs.dh">; def PSABS_DB : RVPUnaryWUFRs1pRdp<0b10, 0b00111, "psabs.db">; -def PSLL_DHS : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psll.dhs">; +def PSLL_DHS : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psll.dhs">; def PSLL_DWS : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psll.dws">; -def PSLL_DBS : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psll.dbs">; -def PADD_DHS : RVPBinary0F1WRs1pRdp<0b001, 0b00, "padd.dhs">; +def PSLL_DBS : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psll.dbs">; +def PADD_DHS : RVPBinary0F1WRs1pRdp<0b001, 0b00, "padd.dhs">; def PADD_DWS : RVPBinary0F1WRs1pRdp<0b001, 0b01, "padd.dws">; -def PADD_DBS : RVPBinary0F1WRs1pRdp<0b001, 0b10, "padd.dbs">; +def PADD_DBS : RVPBinary0F1WRs1pRdp<0b001, 0b10, "padd.dbs">; -def PSSHA_DHS : RVPBinary0F1WRs1pRdp<0b110, 0b00, "pssha.dhs">; +def PSSHA_DHS : RVPBinary0F1WRs1pRdp<0b110, 0b00, "pssha.dhs">; def PSSHA_DWS : RVPBinary0F1WRs1pRdp<0b110, 0b01, "pssha.dws">; -def PSSHAR_DHS : RVPBinary0F1WRs1pRdp<0b111, 0b00, "psshar.dhs">; +def PSSHAR_DHS : RVPBinary0F1WRs1pRdp<0b111, 0b00, "psshar.dhs">; def PSSHAR_DWS : RVPBinary0F1WRs1pRdp<0b111, 0b01, "psshar.dws">; def PSRLI_DB : RVPUnary0F0Rs1pRdp<0b000, 0b0001000, "psrli.db", 0b1>; @@ -961,11 +961,11 @@ def PSATI_DH : RVPUnary0F0Rs1pRdp<0b110, 0b0010000, "psati.dh", 0b1>; def PSATI_DW : RVPUnary0F0Rs1pRdp<0b110, 0b0100000, "psati.dw", 0b1>; def PSRL_DHS : RVPBinary0F1WRs1pRdp<0b000, 0b00, "psrl.dhs", 0b1>; -def PSRL_DWS : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psrl.dws", 0b1>; +def PSRL_DWS : RVPBinary0F1WRs1pRdp<0b000, 0b01, "psrl.dws", 0b1>; def PSRL_DBS : RVPBinary0F1WRs1pRdp<0b000, 0b10, "psrl.dbs", 0b1>; def PSRA_DHS : RVPBinary0F1WRs1pRdp<0b100, 0b00, "psra.dhs", 0b1>; -def PSRA_DWS : RVPBinary0F1WRs1pRdp<0b100, 0b01, "psra.dws", 0b1>; +def PSRA_DWS : RVPBinary0F1WRs1pRdp<0b100, 0b01, "psra.dws", 0b1>; def PSRA_DBS : RVPBinary0F1WRs1pRdp<0b100, 0b10, "psra.dbs", 0b1>; def PADD_DH : RVPBinary1FWRs2pRs1pRdp<0b0000, 0b00, "padd.dh">; From 3a107620bd2b661e24d2e114208b78aa638d43a0 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 28 Feb 2025 11:37:52 +1100 Subject: [PATCH 12/17] fix encoding in RVPUnaryImm8 and RVPUnaryImm9 where rd is RVPGPRPairRV32. align equal signs in class templates. --- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 65 +++++++++++++++++------- llvm/test/MC/RISCV/rv32p-valid.s | 6 +-- 2 files changed, 50 insertions(+), 21 deletions(-) diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index c3de1ee545d58..d074645e37bd8 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -48,8 +48,8 @@ class RVPUnary funct5, bits<7> wuimm, } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryImm9 funct7, string opcodestr, DAGOperand TyRd = GPR> - : RVInstIBase<0b010, OPC_OP_IMM_32, (outs TyRd:$rd), (ins simm10:$simm10), +class RVPUnaryImm9 funct7, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins simm10:$simm10), opcodestr, "$rd, $simm10"> { bits<10> simm10; @@ -58,13 +58,42 @@ class RVPUnaryImm9 funct7, string opcodestr, DAGOperand TyRd = GPR> } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnaryImm8 funct8, string opcodestr, DAGOperand TyRd = GPR> - : RVInstIBase<0b010, OPC_OP_IMM_32, (outs TyRd:$rd), (ins uimm8:$uimm8), +class RVPUnaryImm9Rdp funct7, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs RVPGPRPairRV32:$rdp), + (ins simm10:$simm10), + opcodestr, "$rdp, $simm10"> { + bits<10> simm10; + bits<4> rdp; + + let Inst{31-25} = funct7; + let Inst{24-15} = simm10; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm8 funct8, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$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 Inst{15} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm8Rdp funct8, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs RVPGPRPairRV32:$rdp), + (ins uimm8:$uimm8), opcodestr, "$rdp, $uimm8"> { + bits<8> uimm8; + bits<4> rdp; + + let Inst{31-24} = funct8; + let Inst{23-16} = uimm8; + let Inst{15} = 0b0; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; } let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in @@ -96,9 +125,9 @@ let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPUnaryF f, bit aft, bits<7> wuimm, string opcodestr, bits<3> funct3, dag outs, dag ins, string argstr> : RVInstIBase { - let Inst{31} = bfr; + let Inst{31} = bfr; let Inst{30-28} = f; - let Inst{27} = aft; + let Inst{27} = aft; let Inst{26-20} = wuimm; } @@ -143,9 +172,9 @@ class RVPBinaryFW f, bit aft, bits<2> w, bits<3> funct3, dag outs = (outs GPR:$rd), dag ins = (ins GPR:$rs1, GPR:$rs2), string argstr = "$rd, $rs1, $rs2"> : RVInstRBase { - let Inst{31} = bfr; + let Inst{31} = bfr; let Inst{30-28} = f; - let Inst{27} = aft; + let Inst{27} = aft; let Inst{26-25} = w; } @@ -200,15 +229,15 @@ class RVPBinary1FWRs2pRs1pRdp f, bits<2> w, string opcodestr, bits<4> rs2p; bits<4> rdp; - let Inst{31} = 0b1; + 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{20} = aft; let Inst{19-16} = rs1p; - let Inst{15} = aft; - let Inst{11-8} = rdp; - let Inst{7} = 0b0; + let Inst{15} = aft; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; } class RVPBinary1F0WRs2pRs1pRdp f, bits<2> w, string opcodestr, @@ -233,7 +262,7 @@ class RVPBinaryLongFW f, bits<2> w, bits<3> funct3, string opcodestr, dag outs, dag ins, string argstr> : RVInstRBase { - let Inst{31} = bfr; + let Inst{31} = bfr; let Inst{30-27} = f; let Inst{26-25} = w; } @@ -795,9 +824,9 @@ 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, "pli.dh", RVPGPRPairRV32>; -def PLI_DB : RVPUnaryImm8<0b00110100, "pli.db", RVPGPRPairRV32>; -def PLUI_DH : RVPUnaryImm9<0b0111000, "plui.dh", RVPGPRPairRV32>; +def PLI_DH : RVPUnaryImm9Rdp<0b0011000, "pli.dh">; +def PLI_DB : RVPUnaryImm8Rdp<0b00110100, "pli.db">; +def PLUI_DH : RVPUnaryImm9Rdp<0b0111000, "plui.dh">; def PWSLLI_BS : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.bs">; diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s index be8692727268f..47a25f5d1be7a 100644 --- a/llvm/test/MC/RISCV/rv32p-valid.s +++ b/llvm/test/MC/RISCV/rv32p-valid.s @@ -779,13 +779,13 @@ pwslai.h t5, a4 # CHECK-ASM: encoding: [0x1b,0x23,0x06,0x44] wslai t1, a2 # CHECK-ASM-AND-OBJ: pli.dh s0, 32 -# CHECK-ASM: encoding: [0x1b,0x22,0x10,0x30] +# CHECK-ASM: encoding: [0x1b,0x24,0x10,0x30] pli.dh s0, 32 # CHECK-ASM-AND-OBJ: pli.db a2, 1 -# CHECK-ASM: encoding: [0x1b,0x23,0x01,0x34] +# CHECK-ASM: encoding: [0x1b,0x26,0x01,0x34] pli.db a2, 1 # CHECK-ASM-AND-OBJ: plui.dh t5, 16 -# CHECK-ASM: encoding: [0x9b,0x27,0x08,0x70] +# CHECK-ASM: encoding: [0x1b,0x2f,0x08,0x70] plui.dh t5, 16 # CHECK-ASM-AND-OBJ: pwslli.bs t3, t1, s0 # CHECK-ASM: encoding: [0x1b,0x2e,0x83,0x08] From 12cb98d08cc3dc1a68f7f386638d08efd76e243c Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Fri, 14 Mar 2025 19:43:30 +1100 Subject: [PATCH 13/17] rename decoder namespace to POverlap as it is only overlapping with P extension. --- .../RISCV/Disassembler/RISCVDisassembler.cpp | 1 + llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 24 +++++++++---------- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp index daed99fd604cc..1da837c6655c7 100644 --- a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp +++ b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp @@ -698,6 +698,7 @@ static constexpr DecoderListEntry DecoderList32[]{ {DecoderTableXRivos32, XRivosFeatureGroup, "Rivos"}, {DecoderTable32, {}, "RISCV32"}, {DecoderTableRV32GPRPair32, {}, "RV32GPRPair (rv32 and GPR pairs)"}, + {DecoderTablePOverlap32, {}, "POverlap (32-bit Instructions overlapping with P extension itself)"}, {DecoderTableZfinx32, {}, "Zfinx (Float in Integer)"}, {DecoderTableZdinxRV32GPRPair32, {}, diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index d074645e37bd8..0c61b59724702 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -304,7 +304,7 @@ def PSLLI_B : RVPUnary<0b10000, 0b0001000, 0b010, OPC_OP_IMM_32, "pslli.b">; def PSLLI_H : RVPUnary<0b10000, 0b0010000, 0b010, OPC_OP_IMM_32, "pslli.h">; def PSSLAI_H : RVPUnary<0b11010, 0b0010000, 0b010, OPC_OP_IMM_32, "psslai.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { @@ -319,7 +319,7 @@ def PLI_W : RVPUnaryImm9<0b1011001, "pli.w">; let Predicates = [HasStdExtP] in def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def PSEXT_H_B_RV32 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; def PSABS_H_RV32 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; @@ -347,7 +347,7 @@ def PADD_BS : RVPBinary1F1W<0b001, 0b10, 0b010, "padd.bs">; def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, 0b010, "pssha.hs">; def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, 0b010, "psshar.hs">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def SSHA : RVPBinary1F1W<0b110, 0b01, 0b010, "ssha">; def SSHAR : RVPBinary1F1W<0b111, 0b01, 0b010, "sshar">; @@ -372,7 +372,7 @@ def PSRARI_H : RVPUnary1F0<0b101, 0b0010000, "psrari.h">; def PSATI_H : RVPUnary1F0<0b110, 0b0010000, "psati.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def USATI_RV32 : RVPUnary1F0<0b010, 0b0100000, "usati">; def SRARI : RVPUnary1F0<0b101, 0b0100000, "srari">; @@ -433,7 +433,7 @@ def PASUBU_H : RVPBinary1LongFW<0b1111, 0b00, 0b000, "pasubu.h">; def PASUBU_B : RVPBinary1LongFW<0b1111, 0b10, 0b000, "pasubu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def SADD : RVPBinary1LongFW<0b0010, 0b01, 0b000, "sadd">; def AADD : RVPBinary1LongFW<0b0011, 0b01, 0b000, "aadd">; @@ -478,7 +478,7 @@ def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, 0b001, "pdifsumu.b">; def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, 0b001, "pdifsumau.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def MUL_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "mul.h01">; def MACC_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "macc.h01">; @@ -505,7 +505,7 @@ def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, 0b010, "psh1add.h">; def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, 0b010, "pssh1sadd.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def SSH1SADD : RVPBinary1F0W<0b010, 0b01, 0b010, "ssh1sadd">; } // Predicates = [HasStdExtP, IsRV32] @@ -534,7 +534,7 @@ def PMULU_H_B11 : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.b11">; def PMULSU_H_B00 : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.b00">; def PMULSU_H_B11 : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.b11">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def MUL_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "mul.h00">; def MACC_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "macc.h00">; @@ -588,7 +588,7 @@ def PPACKBT_H : RVPBinary1F0W<0b001, 0b00, 0b100, "ppackbt.h">; def PPACKTB_H : RVPBinary1F0W<0b010, 0b00, 0b100, "ppacktb.h">; def PPACKT_H : RVPBinary1F0W<0b011, 0b00, 0b100, "ppackt.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def PACKBT : RVPBinary1F0W<0b001, 0b01, 0b100, "packbt">; def PACKTB : RVPBinary1F0W<0b010, 0b01, 0b100, "packtb">; @@ -635,7 +635,7 @@ def PM4ADDSU_B : RVPBinary1LongFW<0b1100, 0b10, 0b101, "pm4addsu.b">; def PM2ADDASU_H : RVPBinary1LongFW<0b1101, 0b00, 0b101, "pm2addasu.h">; def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, 0b101, "pm4addasu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def MQACC_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "mqacc.h01">; def MQRACC_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "mqracc.h01">; @@ -696,7 +696,7 @@ def PMAX_B : RVPBinary1LongFW<0b1110, 0b10, 0b110, "pmax.b">; def PMAXU_H : RVPBinary1LongFW<0b1111, 0b00, 0b110, "pmaxu.h">; def PMAXU_B : RVPBinary1LongFW<0b1111, 0b10, 0b110, "pmaxu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def MSEQ : RVPBinary1LongFW<0b1000, 0b01, 0b110, "mseq">; def MSLT : RVPBinary1LongFW<0b1010, 0b01, 0b110, "mslt">; @@ -748,7 +748,7 @@ def PMULQ_H : RVPBinary1LongFW<0b1010, 0b00, 0b111, "pmulq.h">; def PMULQR_H : RVPBinary1LongFW<0b1010, 0b10, 0b111, "pmulqr.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RISCV32Only_", +let DecoderNamespace = "POverlap", Predicates = [HasStdExtP, IsRV32] in { def MULHR : RVPBinary1LongFW<0b0000, 0b11, 0b111, "mulhr">; def MHACC : RVPBinary1LongFW<0b0001, 0b01, 0b111, "mhacc">; From 95c4177b14b33e0af8b98aa4d15371a7c6393754 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Sun, 16 Mar 2025 20:30:56 +1100 Subject: [PATCH 14/17] change POverlap to use RV32GPRPair32 for now. --- .../RISCV/Disassembler/RISCVDisassembler.cpp | 1 - llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 24 +++++++++---------- 2 files changed, 12 insertions(+), 13 deletions(-) diff --git a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp index 1da837c6655c7..daed99fd604cc 100644 --- a/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp +++ b/llvm/lib/Target/RISCV/Disassembler/RISCVDisassembler.cpp @@ -698,7 +698,6 @@ static constexpr DecoderListEntry DecoderList32[]{ {DecoderTableXRivos32, XRivosFeatureGroup, "Rivos"}, {DecoderTable32, {}, "RISCV32"}, {DecoderTableRV32GPRPair32, {}, "RV32GPRPair (rv32 and GPR pairs)"}, - {DecoderTablePOverlap32, {}, "POverlap (32-bit Instructions overlapping with P extension itself)"}, {DecoderTableZfinx32, {}, "Zfinx (Float in Integer)"}, {DecoderTableZdinxRV32GPRPair32, {}, diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 0c61b59724702..2d60cf682e10c 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -304,7 +304,7 @@ def PSLLI_B : RVPUnary<0b10000, 0b0001000, 0b010, OPC_OP_IMM_32, "pslli.b">; def PSLLI_H : RVPUnary<0b10000, 0b0010000, 0b010, OPC_OP_IMM_32, "pslli.h">; def PSSLAI_H : RVPUnary<0b11010, 0b0010000, 0b010, OPC_OP_IMM_32, "psslai.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { @@ -319,7 +319,7 @@ def PLI_W : RVPUnaryImm9<0b1011001, "pli.w">; let Predicates = [HasStdExtP] in def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def PSEXT_H_B_RV32 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; def PSABS_H_RV32 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; @@ -347,7 +347,7 @@ def PADD_BS : RVPBinary1F1W<0b001, 0b10, 0b010, "padd.bs">; def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, 0b010, "pssha.hs">; def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, 0b010, "psshar.hs">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def SSHA : RVPBinary1F1W<0b110, 0b01, 0b010, "ssha">; def SSHAR : RVPBinary1F1W<0b111, 0b01, 0b010, "sshar">; @@ -372,7 +372,7 @@ def PSRARI_H : RVPUnary1F0<0b101, 0b0010000, "psrari.h">; def PSATI_H : RVPUnary1F0<0b110, 0b0010000, "psati.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def USATI_RV32 : RVPUnary1F0<0b010, 0b0100000, "usati">; def SRARI : RVPUnary1F0<0b101, 0b0100000, "srari">; @@ -433,7 +433,7 @@ def PASUBU_H : RVPBinary1LongFW<0b1111, 0b00, 0b000, "pasubu.h">; def PASUBU_B : RVPBinary1LongFW<0b1111, 0b10, 0b000, "pasubu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def SADD : RVPBinary1LongFW<0b0010, 0b01, 0b000, "sadd">; def AADD : RVPBinary1LongFW<0b0011, 0b01, 0b000, "aadd">; @@ -478,7 +478,7 @@ def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, 0b001, "pdifsumu.b">; def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, 0b001, "pdifsumau.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def MUL_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "mul.h01">; def MACC_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "macc.h01">; @@ -505,7 +505,7 @@ def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, 0b010, "psh1add.h">; def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, 0b010, "pssh1sadd.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def SSH1SADD : RVPBinary1F0W<0b010, 0b01, 0b010, "ssh1sadd">; } // Predicates = [HasStdExtP, IsRV32] @@ -534,7 +534,7 @@ def PMULU_H_B11 : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.b11">; def PMULSU_H_B00 : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.b00">; def PMULSU_H_B11 : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.b11">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def MUL_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "mul.h00">; def MACC_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "macc.h00">; @@ -588,7 +588,7 @@ def PPACKBT_H : RVPBinary1F0W<0b001, 0b00, 0b100, "ppackbt.h">; def PPACKTB_H : RVPBinary1F0W<0b010, 0b00, 0b100, "ppacktb.h">; def PPACKT_H : RVPBinary1F0W<0b011, 0b00, 0b100, "ppackt.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def PACKBT : RVPBinary1F0W<0b001, 0b01, 0b100, "packbt">; def PACKTB : RVPBinary1F0W<0b010, 0b01, 0b100, "packtb">; @@ -635,7 +635,7 @@ def PM4ADDSU_B : RVPBinary1LongFW<0b1100, 0b10, 0b101, "pm4addsu.b">; def PM2ADDASU_H : RVPBinary1LongFW<0b1101, 0b00, 0b101, "pm2addasu.h">; def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, 0b101, "pm4addasu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def MQACC_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "mqacc.h01">; def MQRACC_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "mqracc.h01">; @@ -696,7 +696,7 @@ def PMAX_B : RVPBinary1LongFW<0b1110, 0b10, 0b110, "pmax.b">; def PMAXU_H : RVPBinary1LongFW<0b1111, 0b00, 0b110, "pmaxu.h">; def PMAXU_B : RVPBinary1LongFW<0b1111, 0b10, 0b110, "pmaxu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def MSEQ : RVPBinary1LongFW<0b1000, 0b01, 0b110, "mseq">; def MSLT : RVPBinary1LongFW<0b1010, 0b01, 0b110, "mslt">; @@ -748,7 +748,7 @@ def PMULQ_H : RVPBinary1LongFW<0b1010, 0b00, 0b111, "pmulq.h">; def PMULQR_H : RVPBinary1LongFW<0b1010, 0b10, 0b111, "pmulqr.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "POverlap", +let DecoderNamespace = "RV32GPRPair", Predicates = [HasStdExtP, IsRV32] in { def MULHR : RVPBinary1LongFW<0b0000, 0b11, 0b111, "mulhr">; def MHACC : RVPBinary1LongFW<0b0001, 0b01, 0b111, "mhacc">; From ba4c8cb2bd252a51e8691bc7bf80cc587de4fcc9 Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Tue, 25 Mar 2025 05:05:20 +1100 Subject: [PATCH 15/17] make p use RV32Only, fix variant kind --- .../Target/RISCV/AsmParser/RISCVAsmParser.cpp | 4 ++-- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 24 +++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp index 3fda7f8cbc13c..fa603c9594b6f 100644 --- a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp +++ b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp @@ -1035,10 +1035,10 @@ struct RISCVOperand final : public MCParsedAsmOperand { if (!isImm()) return false; int64_t Imm; - RISCVMCExpr::VariantKind VK = RISCVMCExpr::VK_RISCV_None; + RISCVMCExpr::Specifier VK = RISCVMCExpr::VK_None; bool IsConstantImm = evaluateConstantImm(getImm(), Imm, VK); return IsConstantImm && isInt<10>(fixImmediateForRV32(Imm, isRV64Imm())) && - VK == RISCVMCExpr::VK_RISCV_None; + VK == RISCVMCExpr::VK_None; } bool isSImm10Lsb0000NonZero() const { diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 2d60cf682e10c..f080e09be0929 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -304,7 +304,7 @@ def PSLLI_B : RVPUnary<0b10000, 0b0001000, 0b010, OPC_OP_IMM_32, "pslli.b">; def PSLLI_H : RVPUnary<0b10000, 0b0010000, 0b010, OPC_OP_IMM_32, "pslli.h">; def PSSLAI_H : RVPUnary<0b11010, 0b0010000, 0b010, OPC_OP_IMM_32, "psslai.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { @@ -319,7 +319,7 @@ def PLI_W : RVPUnaryImm9<0b1011001, "pli.w">; let Predicates = [HasStdExtP] in def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def PSEXT_H_B_RV32 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; def PSABS_H_RV32 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; @@ -347,7 +347,7 @@ def PADD_BS : RVPBinary1F1W<0b001, 0b10, 0b010, "padd.bs">; def PSSHA_HS : RVPBinary1F1W<0b110, 0b00, 0b010, "pssha.hs">; def PSSHAR_HS : RVPBinary1F1W<0b111, 0b00, 0b010, "psshar.hs">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def SSHA : RVPBinary1F1W<0b110, 0b01, 0b010, "ssha">; def SSHAR : RVPBinary1F1W<0b111, 0b01, 0b010, "sshar">; @@ -372,7 +372,7 @@ def PSRARI_H : RVPUnary1F0<0b101, 0b0010000, "psrari.h">; def PSATI_H : RVPUnary1F0<0b110, 0b0010000, "psati.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def USATI_RV32 : RVPUnary1F0<0b010, 0b0100000, "usati">; def SRARI : RVPUnary1F0<0b101, 0b0100000, "srari">; @@ -433,7 +433,7 @@ def PASUBU_H : RVPBinary1LongFW<0b1111, 0b00, 0b000, "pasubu.h">; def PASUBU_B : RVPBinary1LongFW<0b1111, 0b10, 0b000, "pasubu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def SADD : RVPBinary1LongFW<0b0010, 0b01, 0b000, "sadd">; def AADD : RVPBinary1LongFW<0b0011, 0b01, 0b000, "aadd">; @@ -478,7 +478,7 @@ def PDIFSUMU_B : RVPBinary1LongFW<0b0110, 0b10, 0b001, "pdifsumu.b">; def PDIFSUMAU_B : RVPBinary1LongFW<0b0111, 0b10, 0b001, "pdifsumau.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def MUL_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "mul.h01">; def MACC_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "macc.h01">; @@ -505,7 +505,7 @@ def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, 0b010, "psh1add.h">; def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, 0b010, "pssh1sadd.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def SSH1SADD : RVPBinary1F0W<0b010, 0b01, 0b010, "ssh1sadd">; } // Predicates = [HasStdExtP, IsRV32] @@ -534,7 +534,7 @@ def PMULU_H_B11 : RVPBinary1LongFW<0b0110, 0b00, 0b011, "pmulu.h.b11">; def PMULSU_H_B00 : RVPBinary1LongFW<0b1100, 0b00, 0b011, "pmulsu.h.b00">; def PMULSU_H_B11 : RVPBinary1LongFW<0b1110, 0b00, 0b011, "pmulsu.h.b11">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def MUL_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "mul.h00">; def MACC_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "macc.h00">; @@ -588,7 +588,7 @@ def PPACKBT_H : RVPBinary1F0W<0b001, 0b00, 0b100, "ppackbt.h">; def PPACKTB_H : RVPBinary1F0W<0b010, 0b00, 0b100, "ppacktb.h">; def PPACKT_H : RVPBinary1F0W<0b011, 0b00, 0b100, "ppackt.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def PACKBT : RVPBinary1F0W<0b001, 0b01, 0b100, "packbt">; def PACKTB : RVPBinary1F0W<0b010, 0b01, 0b100, "packtb">; @@ -635,7 +635,7 @@ def PM4ADDSU_B : RVPBinary1LongFW<0b1100, 0b10, 0b101, "pm4addsu.b">; def PM2ADDASU_H : RVPBinary1LongFW<0b1101, 0b00, 0b101, "pm2addasu.h">; def PM4ADDASU_B : RVPBinary1LongFW<0b1101, 0b10, 0b101, "pm4addasu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def MQACC_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "mqacc.h01">; def MQRACC_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "mqracc.h01">; @@ -696,7 +696,7 @@ def PMAX_B : RVPBinary1LongFW<0b1110, 0b10, 0b110, "pmax.b">; def PMAXU_H : RVPBinary1LongFW<0b1111, 0b00, 0b110, "pmaxu.h">; def PMAXU_B : RVPBinary1LongFW<0b1111, 0b10, 0b110, "pmaxu.b">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def MSEQ : RVPBinary1LongFW<0b1000, 0b01, 0b110, "mseq">; def MSLT : RVPBinary1LongFW<0b1010, 0b01, 0b110, "mslt">; @@ -748,7 +748,7 @@ def PMULQ_H : RVPBinary1LongFW<0b1010, 0b00, 0b111, "pmulq.h">; def PMULQR_H : RVPBinary1LongFW<0b1010, 0b10, 0b111, "pmulqr.h">; } // Predicates = [HasStdExtP] -let DecoderNamespace = "RV32GPRPair", +let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in { def MULHR : RVPBinary1LongFW<0b0000, 0b11, 0b111, "mulhr">; def MHACC : RVPBinary1LongFW<0b0001, 0b01, 0b111, "mhacc">; From e12173f6290160c0f8805ba42b8a66023ac78ccb Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Tue, 25 Mar 2025 05:39:18 +1100 Subject: [PATCH 16/17] remove RVPUnary and fix test related to it --- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 57 +++++-------- llvm/test/MC/RISCV/rv32p-valid.s | 104 +---------------------- 2 files changed, 22 insertions(+), 139 deletions(-) diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index f080e09be0929..7505b232d53f1 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -37,16 +37,6 @@ def simm10 : RISCVSImmLeafOp<10> { // Instruction class templates //===----------------------------------------------------------------------===// -let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in -class RVPUnary funct5, bits<7> wuimm, - bits<3> funct3, RISCVOpcode opcode, - string opcodestr> - : RVInstIBase { - let Inst{31-27} = funct5; - let Inst{26-20} = wuimm; -} - let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPUnaryImm9 funct7, string opcodestr> : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins simm10:$simm10), @@ -285,31 +275,31 @@ class RVPBinary0LongFW f, bits<2> w, string opcodestr> //===----------------------------------------------------------------------===// let Predicates = [HasStdExtP] in { -def CLS : RVPUnary<0b01100, 0b0000011, 0b001, OPC_OP_IMM, "cls">; -def ABS : RVPUnary<0b01100, 0b0000111, 0b001, OPC_OP_IMM, "abs">; +def CLS : Unary_r<0b011000000011, 0b001, "cls">; +def ABS : Unary_r<0b011000000111, 0b001, "abs">; } // Predicates = [HasStdExtP] let Predicates = [HasStdExtP, IsRV32] in -def REV_RV32 : RVPUnary<0b01101, 0b0011111, 0b101, OPC_OP_IMM, "rev">; +def REV_RV32 : Unary_r<0b011010011111, 0b101, "rev">; 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 REV16 : Unary_r<0b011010110000, 0b101, "rev16">; +def REV_RV64 : Unary_r<0b011110111111, 0b101, "rev">; -def CLSW : RVPUnary<0b01100, 0b0000011, 0b001, OPC_OP_IMM_32, "clsw">; -def ABSW : RVPUnary<0b01100, 0b0000111, 0b001, OPC_OP_IMM_32, "absw">; +def CLSW : UnaryW_r<0b011000000011, 0b001, "clsw">; +def ABSW : UnaryW_r<0b011000000111, 0b001, "absw">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in { -def PSLLI_B : RVPUnary<0b10000, 0b0001000, 0b010, OPC_OP_IMM_32, "pslli.b">; -def PSLLI_H : RVPUnary<0b10000, 0b0010000, 0b010, OPC_OP_IMM_32, "pslli.h">; -def PSSLAI_H : RVPUnary<0b11010, 0b0010000, 0b010, OPC_OP_IMM_32, "psslai.h">; +def PSLLI_B : UnaryW_r<0b100000001000, 0b010, "pslli.b">; +def PSLLI_H : UnaryW_r<0b100000010000, 0b010, "pslli.h">; +def PSSLAI_H : UnaryW_r<0b110100010000, 0b010, "psslai.h">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in -def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "sslai">; +def SSLAI : UnaryW_r<0b110100100000, 0b010, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { -def PSLLI_W : RVPUnary<0b10000, 0b0100000, 0b010, OPC_OP_IMM_32, "pslli.w">; -def PSSLAI_W : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "psslai.w">; +def PSLLI_W : UnaryW_r<0b100000100000, 0b010, "pslli.w">; +def PSSLAI_W : UnaryW_r<0b110100100000, 0b010, "psslai.w">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in @@ -319,19 +309,14 @@ def PLI_W : RVPUnaryImm9<0b1011001, "pli.w">; let Predicates = [HasStdExtP] in def PLI_B : RVPUnaryImm8<0b10110100, "pli.b">; -let DecoderNamespace = "RV32Only", - Predicates = [HasStdExtP, IsRV32] in { -def PSEXT_H_B_RV32 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; -def PSABS_H_RV32 : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; -def PSABS_B_RV32 : RVPUnaryWUF<0b01, 0b00111, "psabs.b">; -} // Predicates = [HasStdExtP, IsRV32] - +let Predicates = [HasStdExtP] in { +def PSEXT_H_B : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; +def PSABS_H : RVPUnaryWUF<0b00, 0b00111, "psabs.h">; +def PSABS_B : RVPUnaryWUF<0b10, 0b00111, "psabs.b">; +} // Predicates = [HasStdExtP] let Predicates = [HasStdExtP, IsRV64] in { -def PSEXT_H_B_RV64 : RVPUnaryWUF<0b00, 0b00100, "psext.h.b">; def PSEXT_W_B : RVPUnaryWUF<0b01, 0b00100, "psext.w.b">; def PSEXT_W_H : RVPUnaryWUF<0b01, 0b00101, "psext.w.h">; -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 @@ -831,10 +816,10 @@ def PLUI_DH : RVPUnaryImm9Rdp<0b0111000, "plui.dh">; def PWSLLI_BS : RVPBinary0F1WRdp<0b000, 0b00, "pwslli.bs">; def PWSLL_HS : RVPBinary0F1WRdp<0b000, 0b01, "pwsll.hs">; -def WSLL : RVPBinary0F1WRdp<0b000, 0b11, "wsll">; +def WSLL : RVPBinary0F1WRdp<0b000, 0b11, "wsll">; -def PWSLA_BS : RVPBinary0F1WRdp<0b100, 0b00, "pwsla.bs">; -def PWSLA_HS : RVPBinary0F1WRdp<0b100, 0b01, "pwsla.hs">; +def PWSLA_BS : RVPBinary0F1WRdp<0b100, 0b00, "pwsla.bs">; +def PWSLA_HS : RVPBinary0F1WRdp<0b100, 0b01, "pwsla.hs">; def WSLA : RVPBinary0F1WRdp<0b100, 0b11, "wsla">; def WZIP8P : RVPBinary0F1WRdp<0b111, 0b00, "wzip8p">; def WZIP16P : RVPBinary0F1WRdp<0b111, 0b01, "wzip16p">; diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s index 47a25f5d1be7a..96d237c95b78b 100644 --- a/llvm/test/MC/RISCV/rv32p-valid.s +++ b/llvm/test/MC/RISCV/rv32p-valid.s @@ -68,109 +68,7 @@ psext.h.b a7, a0 # CHECK-ASM: encoding: [0x9b,0x25,0x76,0xe0] psabs.h a1, a2 # CHECK-ASM-AND-OBJ: psabs.b t0, t1 -# CHECK-ASM: encoding: [0x9b,0x22,0x73,0xe2] -psabs.b t0, t1 -# CHECK-ASM-AND-OBJ: plui.h gp, 32 -# CHECK-ASM: encoding: [0x9b,0x21,0x10,0xf0] -plui.h gp, 32 -# CHECK-ASM-AND-OBJ: psll.hs a0, a1, a2 -# CHECK-ASM: encoding: [0x1b,0xa5,0xc5,0x88] -psll.hs a0, a1, a2 -# CHECK-ASM-AND-OBJ: psll.bs a3, a4, a5 -# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0x8c] -psll.bs a3, a4, a5 -# CHECK-ASM-AND-OBJ: padd.hs t0, t1, t2 -# CHECK-ASM: encoding: [0x9b,0x22,0x73,0x98] -padd.hs t0, t1, t2 -# CHECK-ASM-AND-OBJ: padd.bs ra, a1, a2 -# CHECK-ASM: encoding: [0x9b,0xa0,0xc5,0x9c] -padd.bs ra, a1, a2 -# CHECK-ASM-AND-OBJ: pssha.hs a3, a4, a5 -# CHECK-ASM: encoding: [0x9b,0x26,0xf7,0xe8] -pssha.hs a3, a4, a5 -# CHECK-ASM-AND-OBJ: ssha gp, a4, a5 -# CHECK-ASM: encoding: [0x9b,0x21,0xf7,0xea] -ssha gp, a4, a5 -# CHECK-ASM-AND-OBJ: psshar.hs a6, a7, a0 -# CHECK-ASM: encoding: [0x1b,0xa8,0xa8,0xf8] -psshar.hs a6, a7, a0 -# CHECK-ASM-AND-OBJ: sshar t1, a7, a0 -# CHECK-ASM: encoding: [0x1b,0xa3,0xa8,0xfa] -sshar t1, a7, a0 -# CHECK-ASM-AND-OBJ: psrli.b a1, a2 -# CHECK-ASM: encoding: [0x9b,0x45,0x86,0x80] -psrli.b a1, a2 -# CHECK-ASM-AND-OBJ: psrli.h a0, a1 -# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0x81] -psrli.h a0, a1 -# CHECK-ASM-AND-OBJ: pusati.h a2, t1 -# CHECK-ASM: encoding: [0x1b,0x46,0x03,0xa1] -pusati.h a2, t1 -# CHECK-ASM-AND-OBJ: usati a3, t2 -# CHECK-ASM: encoding: [0x9b,0xc6,0x03,0xa2] -usati a3, t2 -# CHECK-ASM-AND-OBJ: psrai.b a4, a5 -# CHECK-ASM: encoding: [0x1b,0xc7,0x87,0xc0] -psrai.b a4, a5 -# CHECK-ASM-AND-OBJ: psrai.h a6, a7 -# CHECK-ASM: encoding: [0x1b,0xc8,0x08,0xc1] -psrai.h a6, a7 -# CHECK-ASM-AND-OBJ: psrari.h a0, a1 -# CHECK-ASM: encoding: [0x1b,0xc5,0x05,0xd1] -psrari.h a0, a1 -# CHECK-ASM-AND-OBJ: srari a2, a3 -# CHECK-ASM: encoding: [0x1b,0xc6,0x06,0xd2] -srari a2, a3 -# CHECK-ASM-AND-OBJ: psati.h a4, t0 -# CHECK-ASM: encoding: [0x1b,0xc7,0x02,0xe1] -psati.h a4, t0 -# CHECK-ASM-AND-OBJ: sati a5, t1 -# CHECK-ASM: encoding: [0x9b,0x47,0x03,0xe2] -sati a5, t1 -# CHECK-ASM-AND-OBJ: psrl.hs a6, a7, a1 -# CHECK-ASM: encoding: [0x1b,0xc8,0xb8,0x88] -psrl.hs a6, a7, a1 -# CHECK-ASM-AND-OBJ: psrl.bs a1, a2, a3 -# CHECK-ASM: encoding: [0x9b,0x45,0xd6,0x8c] -psrl.bs a1, a2, a3 -# CHECK-ASM-AND-OBJ: predsum.hs a4, a5, a6 -# CHECK-ASM: encoding: [0x1b,0xc7,0x07,0x99] -predsum.hs a4, a5, a6 -# CHECK-ASM-AND-OBJ: predsum.bs a7, a1, a1 -# CHECK-ASM: encoding: [0x9b,0xc8,0xb5,0x9c] -predsum.bs a7, a1, a1 -# CHECK-ASM-AND-OBJ: predsumu.hs t0, t1, t2 -# CHECK-ASM: encoding: [0x9b,0x42,0x73,0xb8] -predsumu.hs t0, t1, t2 -# CHECK-ASM-AND-OBJ: predsumu.bs t3, t4, t5 -# CHECK-ASM: encoding: [0x1b,0xce,0xee,0xbd] -predsumu.bs t3, t4, t5 -# CHECK-ASM-AND-OBJ: psra.hs ra, a1, a2 -# CHECK-ASM: encoding: [0x9b,0xc0,0xc5,0xc8] -psra.hs ra, a1, a2 -# CHECK-ASM-AND-OBJ: psra.bs sp, a2, a3 -# CHECK-ASM: encoding: [0x1b,0x41,0xd6,0xcc] -psra.bs sp, a2, a3 -# CHECK-ASM-AND-OBJ: psslai.h t0, t1 -# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] -psslai.h t0, t1 -# CHECK-ASM-AND-OBJ: sslai a4, a5 -# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] -sslai a4, a5 -# CHECK-ASM-AND-OBJ: pli.h a5, 16 -# CHECK-ASM: encoding: [0x9b,0x27,0x08,0xb0] -pli.h a5, 16 -# CHECK-ASM-AND-OBJ: pli.b a6, 16 -# CHECK-ASM: encoding: [0x1b,0x28,0x10,0xb4] -pli.b a6, 16 -# CHECK-ASM-AND-OBJ: psext.h.b a7, a0 -# CHECK-ASM: encoding: [0x9b,0x28,0x45,0xe0] -psext.h.b a7, a0 -# CHECK-ASM-AND-OBJ: psabs.h a1, a2 -# CHECK-ASM: encoding: [0x9b,0x25,0x76,0xe0] -psabs.h a1, a2 -# CHECK-ASM-AND-OBJ: psabs.b t0, t1 -# CHECK-ASM: encoding: [0x9b,0x22,0x73,0xe2] +# CHECK-ASM: encoding: [0x9b,0x22,0x73,0xe4] psabs.b t0, t1 # CHECK-ASM-AND-OBJ: plui.h gp, 32 # CHECK-ASM: encoding: [0x9b,0x21,0x10,0xf0] From c58b0c9280627bbcc7b8989efb2eb42d6f36272b Mon Sep 17 00:00:00 2001 From: Qihan Cai Date: Tue, 25 Mar 2025 06:42:23 +1100 Subject: [PATCH 17/17] fix sll that uses immediate shift --- llvm/lib/Target/RISCV/RISCVInstrInfoP.td | 48 +++++++++++++++++++++--- llvm/test/MC/RISCV/rv32p-invalid.s | 9 +++++ llvm/test/MC/RISCV/rv32p-valid.s | 22 +++++------ llvm/test/MC/RISCV/rv64p-invalid.s | 11 ++++++ llvm/test/MC/RISCV/rv64p-valid.s | 26 ++++++------- 5 files changed, 86 insertions(+), 30 deletions(-) diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td index 7505b232d53f1..e667d1d80d3d6 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfoP.td +++ b/llvm/lib/Target/RISCV/RISCVInstrInfoP.td @@ -86,6 +86,42 @@ class RVPUnaryImm8Rdp funct8, string opcodestr> let Inst{7} = 0b0; } +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm5 f, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), + (ins GPR:$rs1, uimm5:$uimm5), opcodestr, "$rd, $rs1, $uimm5"> { + bits<5> uimm5; + let Inst{31} = 0b1; + let Inst{30-28} = f; + let Inst{27} = 0b0; + let Inst{26-25} = 0b01; + let Inst{24-20} = uimm5; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm4 f, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), + (ins GPR:$rs1, uimm4:$uimm4), opcodestr, "$rd, $rs1, $uimm4"> { + bits<4> uimm4; + let Inst{31} = 0b1; + let Inst{30-28} = f; + let Inst{27} = 0b0; + let Inst{26-24} = 0b001; + let Inst{23-20} = uimm4; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm3 f, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), + (ins GPR:$rs1, uimm3:$uimm3), opcodestr, "$rd, $rs1, $uimm3"> { + bits<3> uimm3; + let Inst{31} = 0b1; + let Inst{30-28} = f; + let Inst{27} = 0b0; + let Inst{26-23} = 0b0001; + let Inst{22-20} = uimm3; +} + let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in class RVPUnaryWUF w, bits<5> uf, string opcodestr> : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins GPR:$rs1), @@ -290,16 +326,16 @@ def ABSW : UnaryW_r<0b011000000111, 0b001, "absw">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in { -def PSLLI_B : UnaryW_r<0b100000001000, 0b010, "pslli.b">; -def PSLLI_H : UnaryW_r<0b100000010000, 0b010, "pslli.h">; -def PSSLAI_H : UnaryW_r<0b110100010000, 0b010, "psslai.h">; +def PSLLI_B : RVPUnaryImm3<0b000, "pslli.b">; +def PSLLI_H : RVPUnaryImm4<0b000, "pslli.h">; +def PSSLAI_H : RVPUnaryImm4<0b101, "psslai.h">; } // Predicates = [HasStdExtP] let DecoderNamespace = "RV32Only", Predicates = [HasStdExtP, IsRV32] in -def SSLAI : UnaryW_r<0b110100100000, 0b010, "sslai">; +def SSLAI : RVPUnaryImm5<0b101, "sslai">; let Predicates = [HasStdExtP, IsRV64] in { -def PSLLI_W : UnaryW_r<0b100000100000, 0b010, "pslli.w">; -def PSSLAI_W : UnaryW_r<0b110100100000, 0b010, "psslai.w">; +def PSLLI_W : RVPUnaryImm5<0b000, "pslli.w">; +def PSSLAI_W : RVPUnaryImm5<0b101, "psslai.w">; } // Predicates = [HasStdExtP, IsRV64] let Predicates = [HasStdExtP] in diff --git a/llvm/test/MC/RISCV/rv32p-invalid.s b/llvm/test/MC/RISCV/rv32p-invalid.s index 4b705a8db4854..fd9fc656b11da 100644 --- a/llvm/test/MC/RISCV/rv32p-invalid.s +++ b/llvm/test/MC/RISCV/rv32p-invalid.s @@ -12,3 +12,12 @@ pwadd.b a1, a2, a3 # CHECK-ERROR: register must be even pmqwacc.h a1, a1, a2 # CHECK-ERROR: register must be even + +pslli.b a6, a7, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 7] +pslli.h ra, sp, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 15] +psslai.h t0, t1, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 15] +sslai a4, a5, -1 +# CHECK-ERROR: immediate must be an integer in the range [0, 31] diff --git a/llvm/test/MC/RISCV/rv32p-valid.s b/llvm/test/MC/RISCV/rv32p-valid.s index 96d237c95b78b..a74df52019f20 100644 --- a/llvm/test/MC/RISCV/rv32p-valid.s +++ b/llvm/test/MC/RISCV/rv32p-valid.s @@ -43,18 +43,18 @@ max t3, t4, t5 # CHECK-ASM-AND-OBJ: maxu a4, a5, a6 # CHECK-ASM: encoding: [0x33,0xf7,0x07,0x0b] maxu a4, a5, a6 -# CHECK-ASM-AND-OBJ: pslli.b a6, a7 +# CHECK-ASM-AND-OBJ: pslli.b a6, a7, 0 # CHECK-ASM: encoding: [0x1b,0xa8,0x88,0x80] -pslli.b a6, a7 -# CHECK-ASM-AND-OBJ: pslli.h ra, sp -# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x81] -pslli.h ra, sp -# CHECK-ASM-AND-OBJ: psslai.h t0, t1 -# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] -psslai.h t0, t1 -# CHECK-ASM-AND-OBJ: sslai a4, a5 -# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] -sslai a4, a5 +pslli.b a6, a7, 0 +# CHECK-ASM-AND-OBJ: pslli.h ra, sp, 1 +# CHECK-ASM: encoding: [0x9b,0x20,0x11,0x81] +pslli.h ra, sp, 1 +# CHECK-ASM-AND-OBJ: psslai.h t0, t1, 2 +# CHECK-ASM: encoding: [0x9b,0x22,0x23,0xd1] +psslai.h t0, t1, 2 +# CHECK-ASM-AND-OBJ: sslai a4, a5, 3 +# CHECK-ASM: encoding: [0x1b,0xa7,0x37,0xd2] +sslai a4, a5, 3 # CHECK-ASM-AND-OBJ: pli.h a5, 16 # CHECK-ASM: encoding: [0x9b,0x27,0x08,0xb0] pli.h a5, 16 diff --git a/llvm/test/MC/RISCV/rv64p-invalid.s b/llvm/test/MC/RISCV/rv64p-invalid.s index 8ab5437ad3166..e6060637f2e10 100644 --- a/llvm/test/MC/RISCV/rv64p-invalid.s +++ b/llvm/test/MC/RISCV/rv64p-invalid.s @@ -7,3 +7,14 @@ pli.h a0, 0x400 pli.w a1, -0x201 # CHECK-ERROR: immediate must be an integer in the range [-512, 511] + +pslli.b a6, a7, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 7] +pslli.h ra, sp, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 15] +pslli.w ra, sp, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 31] +psslai.h t0, t1, 100 +# CHECK-ERROR: immediate must be an integer in the range [0, 15] +psslai.w a4, a5, -1 +# CHECK-ERROR: error: immediate must be an integer in the range [0, 31] diff --git a/llvm/test/MC/RISCV/rv64p-valid.s b/llvm/test/MC/RISCV/rv64p-valid.s index 7ca3c4159ddd3..b22af0fb20618 100644 --- a/llvm/test/MC/RISCV/rv64p-valid.s +++ b/llvm/test/MC/RISCV/rv64p-valid.s @@ -57,19 +57,19 @@ max t3, t4, t5 maxu a4, a5, a6 # CHECK-ASM-AND-OBJ: pslli.b a6, a7 # CHECK-ASM: encoding: [0x1b,0xa8,0x88,0x80] -pslli.b a6, a7 -# CHECK-ASM-AND-OBJ: pslli.h ra, sp -# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x81] -pslli.h ra, sp -# CHECK-ASM-AND-OBJ: pslli.w ra, sp -# CHECK-ASM: encoding: [0x9b,0x20,0x01,0x82] -pslli.w ra, sp -# CHECK-ASM-AND-OBJ: psslai.h t0, t1 -# CHECK-ASM: encoding: [0x9b,0x22,0x03,0xd1] -psslai.h t0, t1 -# CHECK-ASM-AND-OBJ: psslai.w a4, a5 -# CHECK-ASM: encoding: [0x1b,0xa7,0x07,0xd2] -psslai.w a4, a5 +pslli.b a6, a7, 0 +# CHECK-ASM-AND-OBJ: pslli.h ra, sp, 1 +# CHECK-ASM: encoding: [0x9b,0x20,0x11,0x81] +pslli.h ra, sp, 1 +# CHECK-ASM-AND-OBJ: pslli.w ra, sp, 2 +# CHECK-ASM: encoding: [0x9b,0x20,0x21,0x82] +pslli.w ra, sp, 2 +# CHECK-ASM-AND-OBJ: psslai.h t0, t1, 3 +# CHECK-ASM: encoding: [0x9b,0x22,0x33,0xd1] +psslai.h t0, t1, 3 +# CHECK-ASM-AND-OBJ: psslai.w a4, a5, 4 +# CHECK-ASM: encoding: [0x1b,0xa7,0x47,0xd2] +psslai.w a4, a5, 4 # CHECK-ASM-AND-OBJ: pli.h a5, 5 # CHECK-ASM: encoding: [0x9b,0xa7,0x02,0xb0] pli.h a5, 5