================ @@ -0,0 +1,1079 @@ +//===-- 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 RVPGPRPairRV32 : RegisterOperand<GPRPair> { + let ParserMatchClass = GPRPairRV32Operand; + let EncoderMethod = "getRVPGPRPair"; + let DecoderMethod = "decodeRVPGPRPair"; +} + +def simm10 : RISCVSImmLeafOp<10> { + let MCOperandPredicate = [{ + int64_t Imm; + if (!MCOp.evaluateAsConstantImm(Imm)) + return false; + return isInt<10>(Imm); + }]; +} + +//===----------------------------------------------------------------------===// +// Instruction class templates +//===----------------------------------------------------------------------===// + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnary<bits<5> funct5, bits<7> wuimm, + bits<3> funct3, RISCVOpcode opcode, + string opcodestr> + : RVInstIBase<funct3, opcode, (outs GPR:$rd), (ins GPR:$rs1), + opcodestr, "$rd, $rs1"> { + let Inst{31-27} = funct5; + let Inst{26-20} = wuimm; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm9<bits<7> funct7, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$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 RVPUnaryImm9Rdp<bits<7> 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<bits<8> 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 hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryImm8Rdp<bits<8> 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 +class RVPUnaryWUF<bits<2> w, bits<5> uf, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs GPR:$rd), (ins GPR:$rs1), + opcodestr, "$rd, $rs1"> { + let Inst{31-27} = 0b11100; + let Inst{26-25} = w; + let Inst{24-20} = uf; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryWUFRs1pRdp<bits<2> w, bits<5> uf, string opcodestr> + : RVInstIBase<0b010, OPC_OP_IMM_32, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p), opcodestr, "$rdp, $rs1p"> { + bits<4> rs1p; + bits<4> rdp; + + let Inst{31-27} = 0b01100; + let Inst{26-25} = w; + let Inst{24-20} = uf; + let Inst{19-16} = rs1p; + let Inst{15} = 0b0; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPUnaryF<bit bfr, bits<3> f, bit aft, bits<7> wuimm, string opcodestr, + bits<3> funct3, dag outs, dag ins, string argstr> + : RVInstIBase<funct3, OPC_OP_IMM_32, outs, ins, opcodestr, argstr> { + let Inst{31} = bfr; + let Inst{30-28} = f; + let Inst{27} = aft; + let Inst{26-20} = wuimm; +} + +class RVPUnary1F0<bits<3> f, bits<7> wuimm, string opcodestr> + : RVPUnaryF<1, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd), + (ins GPR:$rs1), "$rd, $rs1">; + +class RVPUnary0F0Rdp<bits<3> f, bits<7> wuimm, string opcodestr> + : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b010, (outs RVPGPRPairRV32:$rdp), + (ins GPR:$rs1), "$rdp, $rs1"> { + bits<4> rdp; + + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +class RVPUnary0F0Rs1p<bits<3> f, bits<7> wuimm, string opcodestr> + : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b100, (outs GPR:$rd), + (ins RVPGPRPairRV32:$rs1p), "$rd, $rs1p"> { + bits<4> rs1p; + + let Inst{19-16} = rs1p; + let Inst{15} = 0b1; +} + +class RVPUnary0F0Rs1pRdp<bits<3> f, bits<7> wuimm, string opcodestr, + bit aft = 0b0> + : RVPUnaryF<0, f, 0, wuimm, opcodestr, 0b110, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p), "$rdp, $rs1p"> { + bits<4> rs1p; + bits<4> rdp; + + let Inst{19-16} = rs1p; + let Inst{15} = aft; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPBinaryFW<bit bfr, bits<3> f, bit aft, bits<2> w, 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<funct3, Opcode, outs, ins, opcodestr, argstr> { + let Inst{31} = bfr; + let Inst{30-28} = f; + let Inst{27} = aft; + let Inst{26-25} = w; +} + +class RVPBinary1F1W<bits<3> f, bits<2> w, bits<3> funct3, string opcodestr, + RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVPBinaryFW<1, f, 1, w, funct3, opcodestr, Opcode>; + +class RVPBinary1F0W<bits<3> f, bits<2> w, bits<3> funct3, string opcodestr, + RISCVOpcode Opcode = OPC_OP_32> + : RVPBinaryFW<1, f, 0, w, funct3, opcodestr, Opcode>; + +class RVPBinary0F1WRdp<bits<3> f, bits<2> w, string opcodestr, + RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVPBinaryFW<0, f, 1, w, 0b010, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins GPR:$rs1, GPR:$rs2), "$rdp, $rs1, $rs2"> { + bits<4> rdp; + + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +class RVPBinary0F1WRs1p<bits<3> f, bits<2> w, string opcodestr, + bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVPBinaryFW<0, f, 1, w, 0b100, opcodestr, Opcode, (outs GPR:$rd), + (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rd, $rs1p, $rs2"> { + bits<4> rs1p; + + let Inst{19-16} = rs1p; + let Inst{15} = aft; +} + +class RVPBinary0F1WRs1pRdp<bits<3> f, bits<2> w, string opcodestr, + bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVPBinaryFW<0, f, 1, w, 0b110, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, GPR:$rs2), "$rdp, $rs1p, $rs2"> { + bits<4> rs1p; + bits<4> rdp; + + let Inst{19-16} = rs1p; + let Inst{15} = aft; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPBinary1FWRs2pRs1pRdp<bits<4> f, bits<2> w, string opcodestr, + bit aft = 0b0, RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVInstRBase<0b110, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, RVPGPRPairRV32:$rs2p), + opcodestr, "$rdp, $rs1p, $rs2p"> { + bits<4> rs1p; + bits<4> rs2p; + bits<4> rdp; + + let Inst{31} = 0b1; + let Inst{30-27} = f; + let Inst{26-25} = w; + let Inst{24-21} = rs2p; + let Inst{20} = aft; + let Inst{19-16} = rs1p; + let Inst{15} = aft; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +class RVPBinary1F0WRs2pRs1pRdp<bits<3> f, bits<2> w, string opcodestr, + bit bfr = 0b1, bit aft = 0b0, + RISCVOpcode Opcode = OPC_OP_IMM_32> + : RVPBinaryFW<1, f, 0, w, 0b110, opcodestr, Opcode, (outs RVPGPRPairRV32:$rdp), + (ins RVPGPRPairRV32:$rs1p, RVPGPRPairRV32:$rs2p), "$rdp, $rs1p, $rs2p"> { + bits<4> rs1p; + bits<4> rs2p; + bits<4> rdp; + + let Inst{24-21} = rs2p; + let Inst{20} = bfr; + let Inst{19-16} = rs1p; + let Inst{15} = aft; + let Inst{11-8} = rdp; + let Inst{7} = 0b0; +} + +let hasSideEffects = 0, mayLoad = 0, mayStore = 0 in +class RVPBinaryLongFW<bit bfr = 1, bits<4> f, bits<2> w, bits<3> funct3, + string opcodestr, dag outs, dag ins, string argstr> + : RVInstRBase<funct3, OPC_OP_32, outs, ins, + opcodestr, argstr> { + let Inst{31} = bfr; + let Inst{30-27} = f; + let Inst{26-25} = w; +} + +class RVPBinary1LongFW<bits<4> f, bits<2> w, bits<3> funct3, string opcodestr> + : RVPBinaryLongFW<1, f, w, funct3, opcodestr, (outs GPR:$rd), + (ins GPR:$rs1, GPR:$rs2), "$rd, $rs1, $rs2">; + +class RVPBinary0LongFW<bits<4> f, bits<2> w, string opcodestr> + : RVPBinaryLongFW<0, f, w, 0b010, opcodestr, (outs RVPGPRPairRV32:$rdp), + (ins GPR:$rs1, RVPGPRPairRV32:$rs2), "$rdp, $rs1, $rs2"> { + bits<4> rdp; + + let Inst{11-8} = rdp; + let Inst{7} = 0b1; +} + +//===----------------------------------------------------------------------===// +// 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 Predicates = [HasStdExtP, IsRV32] in +def REV_RV32 : RVPUnary<0b01101, 0b0011111, 0b101, OPC_OP_IMM, "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 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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in +def SSLAI : RVPUnary<0b11010, 0b0100000, 0b010, OPC_OP_IMM_32, "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">; +} // Predicates = [HasStdExtP, IsRV64] + +let Predicates = [HasStdExtP] in +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, "pli.b">; + +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">; +def PSABS_B_RV32 : RVPUnaryWUF<0b01, 0b00111, "psabs.b">; +} // Predicates = [HasStdExtP, IsRV32] + +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 +def PLUI_H : RVPUnaryImm9<0b1111000, "plui.h">; +let Predicates = [HasStdExtP, IsRV64] in +def PLUI_W : RVPUnaryImm9<0b1111001, "plui.w">; + +let Predicates = [HasStdExtP] in { +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +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, 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 { +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 = "RV32GPRPair", + 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_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, 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] + + +let Predicates = [HasStdExtP] in { +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +def SADD : RVPBinary1LongFW<0b0010, 0b01, 0b000, "sadd">; +def AADD : RVPBinary1LongFW<0b0011, 0b01, 0b000, "aadd">; + +def SADDU : RVPBinary1LongFW<0b0110, 0b01, 0b000, "saddu">; +def AADDU : RVPBinary1LongFW<0b0111, 0b01, 0b000, "aaddu">; + +def SSUB : RVPBinary1LongFW<0b1010, 0b01, 0b000, "ssub">; +def ASUB : RVPBinary1LongFW<0b1011, 0b01, 0b000, "asub">; + +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, 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, 0b000, "psaddu.w">; +def PAADDU_W : RVPBinary1LongFW<0b0111, 0b01, 0b000, "paaddu.w">; + +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, 0b000, "pssubu.w">; +def PASUBU_W : RVPBinary1LongFW<0b1111, 0b01, 0b000, "pasubu.w">; +} // Predicates = [HasStdExtP, IsRV64] + + +let Predicates = [HasStdExtP] in { +def SLX : RVPBinary1LongFW<0b0001, 0b11, 0b001, "slx">; +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_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] + +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">; + +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_H01 : RVPBinary1LongFW<0b0010, 0b01, 0b001, "pmul.w.h01">; +def MUL_W01 : RVPBinary1LongFW<0b0010, 0b11, 0b001, "mul.w01">; +def PMACC_W_H01 : RVPBinary1LongFW<0b0011, 0b01, 0b001, "pmacc.w.h01">; +def MACC_W01 : RVPBinary1LongFW<0b0011, 0b11, 0b001, "macc.w01">; + +def PMULU_W_H01 : RVPBinary1LongFW<0b0110, 0b01, 0b001, "pmulu.w.h01">; +def MULU_W01 : RVPBinary1LongFW<0b0110, 0b11, 0b001, "mulu.w01">; +def PMACCU_W_H01 : RVPBinary1LongFW<0b0111, 0b01, 0b001, "pmaccu.w.h01">; +def MACCU_W01 : RVPBinary1LongFW<0b0111, 0b11, 0b001, "maccu.w01">; +} // Predicates = [HasStdExtP, IsRV64] + + +let Predicates = [HasStdExtP] in { +def PSH1ADD_H : RVPBinary1F0W<0b010, 0b00, 0b010, "psh1add.h">; +def PSSH1SADD_H : RVPBinary1F0W<0b011, 0b00, 0b010, "pssh1sadd.h">; +} // Predicates = [HasStdExtP] + +let DecoderNamespace = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +def SSH1SADD : RVPBinary1F0W<0b010, 0b01, 0b010, "ssh1sadd">; +} // Predicates = [HasStdExtP, IsRV32] +let Predicates = [HasStdExtP, IsRV64] in { +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] + + +let Predicates = [HasStdExtP] in { +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_B00 : RVPBinary1LongFW<0b0100, 0b00, 0b011, "pmulu.h.b00">; +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", + Predicates = [HasStdExtP, IsRV32] in { +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_H00 : RVPBinary1LongFW<0b0000, 0b01, 0b011, "pmul.w.h00">; +def MUL_W00 : RVPBinary1LongFW<0b0000, 0b11, 0b011, "mul.w00">; +def PMACC_W_H00 : RVPBinary1LongFW<0b0001, 0b01, 0b011, "pmacc.w.h00">; +def MACC_W00 : RVPBinary1LongFW<0b0001, 0b11, 0b011, "macc.w00">; +def PMUL_W_H11 : RVPBinary1LongFW<0b0010, 0b01, 0b011, "pmul.w.h11">; +def MUL_W11 : RVPBinary1LongFW<0b0010, 0b11, 0b011, "mul.w11">; +def PMACC_W_H11 : RVPBinary1LongFW<0b0011, 0b01, 0b011, "pmacc.w.h11">; +def MACC_W11 : RVPBinary1LongFW<0b0011, 0b11, 0b011, "macc.w11">; + +def PMULU_W_H00 : RVPBinary1LongFW<0b0100, 0b01, 0b011, "pmulu.w.h00">; +def MULU_W00 : RVPBinary1LongFW<0b0100, 0b11, 0b011, "mulu.w00">; +def PMACCU_W_H00 : RVPBinary1LongFW<0b0101, 0b01, 0b011, "pmaccu.w.h00">; +def MACCU_W00 : RVPBinary1LongFW<0b0101, 0b11, 0b011, "maccu.w00">; +def PMULU_W_H11 : RVPBinary1LongFW<0b0110, 0b01, 0b011, "pmulu.w.h11">; +def MULU_W11 : RVPBinary1LongFW<0b0110, 0b11, 0b011, "mulu.w11">; +def PMACCU_W_H11 : RVPBinary1LongFW<0b0111, 0b01, 0b011, "pmaccu.w.h11">; +def MACCU_W11 : RVPBinary1LongFW<0b0111, 0b11, 0b011, "maccu.w11">; + +def PMULSU_W_H00 : RVPBinary1LongFW<0b1100, 0b01, 0b011, "pmulsu.w.h00">; +def MULSU_W00 : RVPBinary1LongFW<0b1100, 0b11, 0b011, "mulsu.w00">; +def PMACCSU_W_H00 : RVPBinary1LongFW<0b1101, 0b01, 0b011, "pmaccsu.w.h00">; +def MACCSU_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b011, "maccsu.w00">; +def PMULSU_W_H11 : RVPBinary1LongFW<0b1110, 0b01, 0b011, "pmulsu.w.h11">; +def MULSU_W11 : RVPBinary1LongFW<0b1110, 0b11, 0b011, "mulsu.w11">; +def PMACCSU_W_H11 : RVPBinary1LongFW<0b1111, 0b01, 0b011, "pmaccsu.w.h11">; +def MACCSU_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b011, "maccsu.w11">; +} // Predicates = [HasStdExtP, IsRV64] + + +let Predicates = [HasStdExtP] in { +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +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, 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] + + +let Predicates = [HasStdExtP] in { +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +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 { +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_H01 : RVPBinary1LongFW<0b1111, 0b00, 0b101, "pmqacc.w.h01">; +def MQACC_W01 : RVPBinary1LongFW<0b1111, 0b01, 0b101, "mqacc.w01">; +def PMQRACC_W_H01 : RVPBinary1LongFW<0b1111, 0b10, 0b101, "pmqracc.w.h01">; +def MQRACC_W01 : RVPBinary1LongFW<0b1111, 0b11, 0b101, "mqracc.w01">; +} // Predicates = [HasStdExtP, IsRV64] + +let Predicates = [HasStdExtP] in { +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +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, 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, 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_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">; +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 = "RV32GPRPair", + Predicates = [HasStdExtP, IsRV32] in { +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, 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_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">; +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_H00 : RVPBinary1LongFW<0b1101, 0b00, 0b111, "pmqacc.w.h00">; +def MQACC_W00 : RVPBinary1LongFW<0b1101, 0b01, 0b111, "mqacc.w00">; +def PMQRACC_W_H00: RVPBinary1LongFW<0b1101, 0b10, 0b111, "pmqracc.w.h00">; +def MQRACC_W00 : RVPBinary1LongFW<0b1101, 0b11, 0b111, "mqracc.w00">; +def PMQACC_W_H11 : RVPBinary1LongFW<0b1111, 0b00, 0b111, "pmqacc.w.h11">; +def MQACC_W11 : RVPBinary1LongFW<0b1111, 0b01, 0b111, "mqacc.w11">; +def PMQRACC_W_H11: RVPBinary1LongFW<0b1111, 0b10, 0b111, "pmqracc.w.h11">; +def MQRACC_W11 : RVPBinary1LongFW<0b1111, 0b11, 0b111, "mqracc.w11">; +} // Predicates = [HasStdExtP, IsRV64] + + +let Predicates = [HasStdExtP, IsRV32] in { +def PWSLLI_B : RVPUnary0F0Rdp<0b000, 0b0010000, "pwslli.b">; ---------------- topperc wrote:
This is missing a shift amount. This is the `xxx` in the encoding. https://github.com/llvm/llvm-project/pull/123271 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
