| //===-- RISCVInstrInfoVPseudos.td - RISC-V 'V' Pseudos -----*- 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 contains the required infrastructure to support code generation |
| /// for the standard 'V' (Vector) extension, version 1.0. |
| /// |
| /// This file is included from RISCVInstrInfoV.td |
| /// |
| /// Overview of our vector instruction pseudos. Many of the instructions |
| /// have behavior which depends on the value of VTYPE. Several core aspects of |
| /// the compiler - e.g. register allocation - depend on fields in this |
| /// configuration register. The details of which fields matter differ by the |
| /// specific instruction, but the common dimensions are: |
| /// |
| /// LMUL/EMUL - Most instructions can write to differently sized register groups |
| /// depending on LMUL. |
| /// |
| /// Masked vs Unmasked - Many instructions which allow a mask disallow register |
| /// overlap. As a result, masked vs unmasked require different register |
| /// allocation constraints. |
| /// |
| /// Policy - For each of mask and tail policy, there are three options: |
| /// * "Undisturbed" - As defined in the specification, required to preserve the |
| /// exact bit pattern of inactive lanes. |
| /// * "Agnostic" - As defined in the specification, required to either preserve |
| /// the exact bit pattern of inactive lanes, or produce the bit pattern -1 for |
| /// those lanes. Note that each lane can make this choice independently. |
| /// Instructions which produce masks (and only those instructions) also have the |
| /// option of producing a result as-if VL had been VLMAX. |
| /// * "Undefined" - The bit pattern of the inactive lanes is unspecified, and |
| /// can be changed without impacting the semantics of the program. Note that |
| /// this concept does not exist in the specification, and requires source |
| /// knowledge to be preserved. |
| /// |
| /// SEW - Some instructions have semantics which depend on SEW. This is |
| /// relatively rare, and mostly impacts scheduling and cost estimation. |
| /// |
| /// We have two techniques we use to represent the impact of these fields: |
| /// * For fields which don't impact register classes, we largely use |
| /// dummy operands on the pseudo instructions which convey information |
| /// about the value of VTYPE. |
| /// * For fields which do impact register classes (and a few bits of |
| /// legacy - see policy discussion below), we define a family of pseudo |
| /// instructions for each actual instruction. Said differently, we encode |
| /// each of the preceding fields which are relevant for a given instruction |
| /// in the opcode space. |
| /// |
| /// Currently, the policy is represented via the following instrinsic families: |
| /// * _MASK - Can represent all three policy states for both tail and mask. If |
| /// passthrough is IMPLICIT_DEF, then represents "undefined". Otherwise, |
| /// policy operand and tablegen flags drive the interpretation. (If policy |
| /// operand is not present - there are a couple, thought we're rapidly |
| /// removing them - a non-undefined policy defaults to "tail agnostic", and |
| /// "mask undisturbed". Since this is the only variant with a mask, all |
| /// other variants are "mask undefined". |
| /// * Unsuffixed w/ both passthrough and policy operand. Can represent all |
| /// three policy states. If passthrough is IMPLICIT_DEF, then represents |
| /// "undefined". Otherwise, policy operand and tablegen flags drive the |
| /// interpretation. |
| /// * Unsuffixed w/o passthrough or policy operand -- Does not have a |
| /// passthrough operand, and thus represents the "undefined" state. Note |
| /// that terminology in code frequently refers to these as "TA" which is |
| /// confusing. We're in the process of migrating away from this |
| /// representation. |
| /// * _TU w/o policy operand -- Has a passthrough operand, and always |
| /// represents the tail undisturbed state. |
| /// * _TU w/policy operand - Can represent all three policy states. If |
| /// passthrough is IMPLICIT_DEF, then represents "undefined". Otherwise, |
| /// policy operand and tablegen flags drive the interpretation. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| def riscv_vmv_x_s : SDNode<"RISCVISD::VMV_X_S", |
| SDTypeProfile<1, 1, [SDTCisInt<0>, SDTCisVec<1>, |
| SDTCisInt<1>]>>; |
| def riscv_read_vlenb : SDNode<"RISCVISD::READ_VLENB", |
| SDTypeProfile<1, 0, [SDTCisVT<0, XLenVT>]>>; |
| |
| // Operand that is allowed to be a register or a 5 bit immediate. |
| // This allows us to pick between VSETIVLI and VSETVLI opcodes using the same |
| // pseudo instructions. |
| def AVL : RegisterOperand<GPRNoX0> { |
| let OperandNamespace = "RISCVOp"; |
| let OperandType = "OPERAND_AVL"; |
| } |
| |
| // X0 has special meaning for vsetvl/vsetvli. |
| // rd | rs1 | AVL value | Effect on vl |
| //-------------------------------------------------------------- |
| // !X0 | X0 | VLMAX | Set vl to VLMAX |
| // X0 | X0 | Value in vl | Keep current vl, just change vtype. |
| def VLOp : ComplexPattern<XLenVT, 1, "selectVLOp">; |
| |
| def DecImm : SDNodeXForm<imm, [{ |
| return CurDAG->getTargetConstant(N->getSExtValue() - 1, SDLoc(N), |
| N->getValueType(0)); |
| }]>; |
| |
| defvar TAIL_AGNOSTIC = 1; |
| defvar TU_MU = 0; |
| defvar TA_MA = 3; |
| |
| //===----------------------------------------------------------------------===// |
| // Utilities. |
| //===----------------------------------------------------------------------===// |
| |
| class PseudoToVInst<string PseudoInst> { |
| defvar AffixSubsts = [["Pseudo", ""], |
| ["_E64", ""], |
| ["_E32", ""], |
| ["_E16", ""], |
| ["_E8", ""], |
| ["_F64", "_F"], |
| ["_F32", "_F"], |
| ["_F16", "_F"], |
| ["_VF64", "_VF"], |
| ["_VF32", "_VF"], |
| ["_VF16", "_VF"], |
| ["_WF64", "_WF"], |
| ["_WF32", "_WF"], |
| ["_WF16", "_WF"], |
| ["_TU", ""], |
| ["_TIED", ""], |
| ["_MASK", ""], |
| ["_B64", ""], |
| ["_B32", ""], |
| ["_B16", ""], |
| ["_B8", ""], |
| ["_B4", ""], |
| ["_B2", ""], |
| ["_B1", ""], |
| ["_MF8", ""], |
| ["_MF4", ""], |
| ["_MF2", ""], |
| ["_M1", ""], |
| ["_M2", ""], |
| ["_M4", ""], |
| ["_M8", ""], |
| ["_SE", ""] |
| ]; |
| string VInst = !foldl(PseudoInst, AffixSubsts, Acc, AffixSubst, |
| !subst(AffixSubst[0], AffixSubst[1], Acc)); |
| } |
| |
| // This class describes information associated to the LMUL. |
| class LMULInfo<int lmul, int oct, VReg regclass, VReg wregclass, |
| VReg f2regclass, VReg f4regclass, VReg f8regclass, string mx> { |
| bits<3> value = lmul; // This is encoded as the vlmul field of vtype. |
| VReg vrclass = regclass; |
| VReg wvrclass = wregclass; |
| VReg f8vrclass = f8regclass; |
| VReg f4vrclass = f4regclass; |
| VReg f2vrclass = f2regclass; |
| string MX = mx; |
| int octuple = oct; |
| } |
| |
| // Associate LMUL with tablegen records of register classes. |
| def V_M1 : LMULInfo<0b000, 8, VR, VRM2, VR, VR, VR, "M1">; |
| def V_M2 : LMULInfo<0b001, 16, VRM2, VRM4, VR, VR, VR, "M2">; |
| def V_M4 : LMULInfo<0b010, 32, VRM4, VRM8, VRM2, VR, VR, "M4">; |
| def V_M8 : LMULInfo<0b011, 64, VRM8,/*NoVReg*/VR, VRM4, VRM2, VR, "M8">; |
| |
| def V_MF8 : LMULInfo<0b101, 1, VR, VR,/*NoVReg*/VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF8">; |
| def V_MF4 : LMULInfo<0b110, 2, VR, VR, VR,/*NoVReg*/VR,/*NoVReg*/VR, "MF4">; |
| def V_MF2 : LMULInfo<0b111, 4, VR, VR, VR, VR,/*NoVReg*/VR, "MF2">; |
| |
| // Used to iterate over all possible LMULs. |
| defvar MxList = [V_MF8, V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8]; |
| // For floating point which don't need MF8. |
| defvar MxListF = [V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8]; |
| |
| // Used for widening and narrowing instructions as it doesn't contain M8. |
| defvar MxListW = [V_MF8, V_MF4, V_MF2, V_M1, V_M2, V_M4]; |
| // Used for widening reductions. It can contain M8 because wider operands are |
| // scalar operands. |
| defvar MxListWRed = MxList; |
| // For floating point which don't need MF8. |
| defvar MxListFW = [V_MF4, V_MF2, V_M1, V_M2, V_M4]; |
| // For widening floating-point Reduction as it doesn't contain MF8. It can |
| // contain M8 because wider operands are scalar operands. |
| defvar MxListFWRed = [V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8]; |
| |
| // Use for zext/sext.vf2 |
| defvar MxListVF2 = [V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8]; |
| |
| // Use for zext/sext.vf4 |
| defvar MxListVF4 = [V_MF2, V_M1, V_M2, V_M4, V_M8]; |
| |
| // Use for zext/sext.vf8 |
| defvar MxListVF8 = [V_M1, V_M2, V_M4, V_M8]; |
| |
| class MxSet<int eew> { |
| list<LMULInfo> m = !cond(!eq(eew, 8) : [V_MF8, V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8], |
| !eq(eew, 16) : [V_MF4, V_MF2, V_M1, V_M2, V_M4, V_M8], |
| !eq(eew, 32) : [V_MF2, V_M1, V_M2, V_M4, V_M8], |
| !eq(eew, 64) : [V_M1, V_M2, V_M4, V_M8]); |
| } |
| |
| class FPR_Info<int sew> { |
| RegisterClass fprclass = !cast<RegisterClass>("FPR" # sew); |
| string FX = "F" # sew; |
| int SEW = sew; |
| list<LMULInfo> MxList = MxSet<sew>.m; |
| list<LMULInfo> MxListFW = !if(!eq(sew, 64), [], !listremove(MxList, [V_M8])); |
| } |
| |
| def SCALAR_F16 : FPR_Info<16>; |
| def SCALAR_F32 : FPR_Info<32>; |
| def SCALAR_F64 : FPR_Info<64>; |
| |
| defvar FPList = [SCALAR_F16, SCALAR_F32, SCALAR_F64]; |
| |
| // Used for widening instructions. It excludes F64. |
| defvar FPListW = [SCALAR_F16, SCALAR_F32]; |
| |
| class NFSet<LMULInfo m> { |
| list<int> L = !cond(!eq(m.value, V_M8.value): [], |
| !eq(m.value, V_M4.value): [2], |
| !eq(m.value, V_M2.value): [2, 3, 4], |
| true: [2, 3, 4, 5, 6, 7, 8]); |
| } |
| |
| class octuple_to_str<int octuple> { |
| string ret = !cond(!eq(octuple, 1): "MF8", |
| !eq(octuple, 2): "MF4", |
| !eq(octuple, 4): "MF2", |
| !eq(octuple, 8): "M1", |
| !eq(octuple, 16): "M2", |
| !eq(octuple, 32): "M4", |
| !eq(octuple, 64): "M8"); |
| } |
| |
| def VLOpFrag : PatFrag<(ops), (XLenVT (VLOp (XLenVT AVL:$vl)))>; |
| |
| // Output pattern for X0 used to represent VLMAX in the pseudo instructions. |
| // We can't use X0 register becuase the AVL operands use GPRNoX0. |
| // This must be kept in sync with RISCV::VLMaxSentinel. |
| def VLMax : OutPatFrag<(ops), (XLenVT -1)>; |
| |
| // List of EEW. |
| defvar EEWList = [8, 16, 32, 64]; |
| |
| class SegRegClass<LMULInfo m, int nf> { |
| VReg RC = !cast<VReg>("VRN" # nf # !cond(!eq(m.value, V_MF8.value): V_M1.MX, |
| !eq(m.value, V_MF4.value): V_M1.MX, |
| !eq(m.value, V_MF2.value): V_M1.MX, |
| true: m.MX)); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Vector register and vector group type information. |
| //===----------------------------------------------------------------------===// |
| |
| class VTypeInfo<ValueType Vec, ValueType Mas, int Sew, VReg Reg, LMULInfo M, |
| ValueType Scal = XLenVT, RegisterClass ScalarReg = GPR> { |
| ValueType Vector = Vec; |
| ValueType Mask = Mas; |
| int SEW = Sew; |
| int Log2SEW = !logtwo(Sew); |
| VReg RegClass = Reg; |
| LMULInfo LMul = M; |
| ValueType Scalar = Scal; |
| RegisterClass ScalarRegClass = ScalarReg; |
| // The pattern fragment which produces the AVL operand, representing the |
| // "natural" vector length for this type. For scalable vectors this is VLMax. |
| OutPatFrag AVL = VLMax; |
| |
| string ScalarSuffix = !cond(!eq(Scal, XLenVT) : "X", |
| !eq(Scal, f16) : "F16", |
| !eq(Scal, f32) : "F32", |
| !eq(Scal, f64) : "F64"); |
| } |
| |
| class GroupVTypeInfo<ValueType Vec, ValueType VecM1, ValueType Mas, int Sew, |
| VReg Reg, LMULInfo M, ValueType Scal = XLenVT, |
| RegisterClass ScalarReg = GPR> |
| : VTypeInfo<Vec, Mas, Sew, Reg, M, Scal, ScalarReg> { |
| ValueType VectorM1 = VecM1; |
| } |
| |
| defset list<VTypeInfo> AllVectors = { |
| defset list<VTypeInfo> AllIntegerVectors = { |
| defset list<VTypeInfo> NoGroupIntegerVectors = { |
| defset list<VTypeInfo> FractionalGroupIntegerVectors = { |
| def VI8MF8: VTypeInfo<vint8mf8_t, vbool64_t, 8, VR, V_MF8>; |
| def VI8MF4: VTypeInfo<vint8mf4_t, vbool32_t, 8, VR, V_MF4>; |
| def VI8MF2: VTypeInfo<vint8mf2_t, vbool16_t, 8, VR, V_MF2>; |
| def VI16MF4: VTypeInfo<vint16mf4_t, vbool64_t, 16, VR, V_MF4>; |
| def VI16MF2: VTypeInfo<vint16mf2_t, vbool32_t, 16, VR, V_MF2>; |
| def VI32MF2: VTypeInfo<vint32mf2_t, vbool64_t, 32, VR, V_MF2>; |
| } |
| def VI8M1: VTypeInfo<vint8m1_t, vbool8_t, 8, VR, V_M1>; |
| def VI16M1: VTypeInfo<vint16m1_t, vbool16_t, 16, VR, V_M1>; |
| def VI32M1: VTypeInfo<vint32m1_t, vbool32_t, 32, VR, V_M1>; |
| def VI64M1: VTypeInfo<vint64m1_t, vbool64_t, 64, VR, V_M1>; |
| } |
| defset list<GroupVTypeInfo> GroupIntegerVectors = { |
| def VI8M2: GroupVTypeInfo<vint8m2_t, vint8m1_t, vbool4_t, 8, VRM2, V_M2>; |
| def VI8M4: GroupVTypeInfo<vint8m4_t, vint8m1_t, vbool2_t, 8, VRM4, V_M4>; |
| def VI8M8: GroupVTypeInfo<vint8m8_t, vint8m1_t, vbool1_t, 8, VRM8, V_M8>; |
| |
| def VI16M2: GroupVTypeInfo<vint16m2_t,vint16m1_t,vbool8_t, 16,VRM2, V_M2>; |
| def VI16M4: GroupVTypeInfo<vint16m4_t,vint16m1_t,vbool4_t, 16,VRM4, V_M4>; |
| def VI16M8: GroupVTypeInfo<vint16m8_t,vint16m1_t,vbool2_t, 16,VRM8, V_M8>; |
| |
| def VI32M2: GroupVTypeInfo<vint32m2_t,vint32m1_t,vbool16_t,32,VRM2, V_M2>; |
| def VI32M4: GroupVTypeInfo<vint32m4_t,vint32m1_t,vbool8_t, 32,VRM4, V_M4>; |
| def VI32M8: GroupVTypeInfo<vint32m8_t,vint32m1_t,vbool4_t, 32,VRM8, V_M8>; |
| |
| def VI64M2: GroupVTypeInfo<vint64m2_t,vint64m1_t,vbool32_t,64,VRM2, V_M2>; |
| def VI64M4: GroupVTypeInfo<vint64m4_t,vint64m1_t,vbool16_t,64,VRM4, V_M4>; |
| def VI64M8: GroupVTypeInfo<vint64m8_t,vint64m1_t,vbool8_t, 64,VRM8, V_M8>; |
| } |
| } |
| |
| defset list<VTypeInfo> AllFloatVectors = { |
| defset list<VTypeInfo> NoGroupFloatVectors = { |
| defset list<VTypeInfo> FractionalGroupFloatVectors = { |
| def VF16MF4: VTypeInfo<vfloat16mf4_t, vbool64_t, 16, VR, V_MF4, f16, FPR16>; |
| def VF16MF2: VTypeInfo<vfloat16mf2_t, vbool32_t, 16, VR, V_MF2, f16, FPR16>; |
| def VF32MF2: VTypeInfo<vfloat32mf2_t,vbool64_t, 32, VR, V_MF2, f32, FPR32>; |
| } |
| def VF16M1: VTypeInfo<vfloat16m1_t, vbool16_t, 16, VR, V_M1, f16, FPR16>; |
| def VF32M1: VTypeInfo<vfloat32m1_t, vbool32_t, 32, VR, V_M1, f32, FPR32>; |
| def VF64M1: VTypeInfo<vfloat64m1_t, vbool64_t, 64, VR, V_M1, f64, FPR64>; |
| } |
| |
| defset list<GroupVTypeInfo> GroupFloatVectors = { |
| def VF16M2: GroupVTypeInfo<vfloat16m2_t, vfloat16m1_t, vbool8_t, 16, |
| VRM2, V_M2, f16, FPR16>; |
| def VF16M4: GroupVTypeInfo<vfloat16m4_t, vfloat16m1_t, vbool4_t, 16, |
| VRM4, V_M4, f16, FPR16>; |
| def VF16M8: GroupVTypeInfo<vfloat16m8_t, vfloat16m1_t, vbool2_t, 16, |
| VRM8, V_M8, f16, FPR16>; |
| |
| def VF32M2: GroupVTypeInfo<vfloat32m2_t, vfloat32m1_t, vbool16_t, 32, |
| VRM2, V_M2, f32, FPR32>; |
| def VF32M4: GroupVTypeInfo<vfloat32m4_t, vfloat32m1_t, vbool8_t, 32, |
| VRM4, V_M4, f32, FPR32>; |
| def VF32M8: GroupVTypeInfo<vfloat32m8_t, vfloat32m1_t, vbool4_t, 32, |
| VRM8, V_M8, f32, FPR32>; |
| |
| def VF64M2: GroupVTypeInfo<vfloat64m2_t, vfloat64m1_t, vbool32_t, 64, |
| VRM2, V_M2, f64, FPR64>; |
| def VF64M4: GroupVTypeInfo<vfloat64m4_t, vfloat64m1_t, vbool16_t, 64, |
| VRM4, V_M4, f64, FPR64>; |
| def VF64M8: GroupVTypeInfo<vfloat64m8_t, vfloat64m1_t, vbool8_t, 64, |
| VRM8, V_M8, f64, FPR64>; |
| } |
| } |
| } |
| |
| // This functor is used to obtain the int vector type that has the same SEW and |
| // multiplier as the input parameter type |
| class GetIntVTypeInfo<VTypeInfo vti> { |
| // Equivalent integer vector type. Eg. |
| // VI8M1 → VI8M1 (identity) |
| // VF64M4 → VI64M4 |
| VTypeInfo Vti = !cast<VTypeInfo>(!subst("VF", "VI", !cast<string>(vti))); |
| } |
| |
| class MTypeInfo<ValueType Mas, LMULInfo M, string Bx> { |
| ValueType Mask = Mas; |
| // {SEW, VLMul} values set a valid VType to deal with this mask type. |
| // we assume SEW=1 and set corresponding LMUL. vsetvli insertion will |
| // look for SEW=1 to optimize based on surrounding instructions. |
| int SEW = 1; |
| int Log2SEW = 0; |
| LMULInfo LMul = M; |
| string BX = Bx; // Appendix of mask operations. |
| // The pattern fragment which produces the AVL operand, representing the |
| // "natural" vector length for this mask type. For scalable masks this is |
| // VLMax. |
| OutPatFrag AVL = VLMax; |
| } |
| |
| defset list<MTypeInfo> AllMasks = { |
| // vbool<n>_t, <n> = SEW/LMUL, we assume SEW=8 and corresponding LMUL. |
| def : MTypeInfo<vbool64_t, V_MF8, "B1">; |
| def : MTypeInfo<vbool32_t, V_MF4, "B2">; |
| def : MTypeInfo<vbool16_t, V_MF2, "B4">; |
| def : MTypeInfo<vbool8_t, V_M1, "B8">; |
| def : MTypeInfo<vbool4_t, V_M2, "B16">; |
| def : MTypeInfo<vbool2_t, V_M4, "B32">; |
| def : MTypeInfo<vbool1_t, V_M8, "B64">; |
| } |
| |
| class VTypeInfoToWide<VTypeInfo vti, VTypeInfo wti> { |
| VTypeInfo Vti = vti; |
| VTypeInfo Wti = wti; |
| } |
| |
| class VTypeInfoToFraction<VTypeInfo vti, VTypeInfo fti> { |
| VTypeInfo Vti = vti; |
| VTypeInfo Fti = fti; |
| } |
| |
| defset list<VTypeInfoToWide> AllWidenableIntVectors = { |
| def : VTypeInfoToWide<VI8MF8, VI16MF4>; |
| def : VTypeInfoToWide<VI8MF4, VI16MF2>; |
| def : VTypeInfoToWide<VI8MF2, VI16M1>; |
| def : VTypeInfoToWide<VI8M1, VI16M2>; |
| def : VTypeInfoToWide<VI8M2, VI16M4>; |
| def : VTypeInfoToWide<VI8M4, VI16M8>; |
| |
| def : VTypeInfoToWide<VI16MF4, VI32MF2>; |
| def : VTypeInfoToWide<VI16MF2, VI32M1>; |
| def : VTypeInfoToWide<VI16M1, VI32M2>; |
| def : VTypeInfoToWide<VI16M2, VI32M4>; |
| def : VTypeInfoToWide<VI16M4, VI32M8>; |
| |
| def : VTypeInfoToWide<VI32MF2, VI64M1>; |
| def : VTypeInfoToWide<VI32M1, VI64M2>; |
| def : VTypeInfoToWide<VI32M2, VI64M4>; |
| def : VTypeInfoToWide<VI32M4, VI64M8>; |
| } |
| |
| defset list<VTypeInfoToWide> AllWidenableFloatVectors = { |
| def : VTypeInfoToWide<VF16MF4, VF32MF2>; |
| def : VTypeInfoToWide<VF16MF2, VF32M1>; |
| def : VTypeInfoToWide<VF16M1, VF32M2>; |
| def : VTypeInfoToWide<VF16M2, VF32M4>; |
| def : VTypeInfoToWide<VF16M4, VF32M8>; |
| |
| def : VTypeInfoToWide<VF32MF2, VF64M1>; |
| def : VTypeInfoToWide<VF32M1, VF64M2>; |
| def : VTypeInfoToWide<VF32M2, VF64M4>; |
| def : VTypeInfoToWide<VF32M4, VF64M8>; |
| } |
| |
| defset list<VTypeInfoToFraction> AllFractionableVF2IntVectors = { |
| def : VTypeInfoToFraction<VI16MF4, VI8MF8>; |
| def : VTypeInfoToFraction<VI16MF2, VI8MF4>; |
| def : VTypeInfoToFraction<VI16M1, VI8MF2>; |
| def : VTypeInfoToFraction<VI16M2, VI8M1>; |
| def : VTypeInfoToFraction<VI16M4, VI8M2>; |
| def : VTypeInfoToFraction<VI16M8, VI8M4>; |
| def : VTypeInfoToFraction<VI32MF2, VI16MF4>; |
| def : VTypeInfoToFraction<VI32M1, VI16MF2>; |
| def : VTypeInfoToFraction<VI32M2, VI16M1>; |
| def : VTypeInfoToFraction<VI32M4, VI16M2>; |
| def : VTypeInfoToFraction<VI32M8, VI16M4>; |
| def : VTypeInfoToFraction<VI64M1, VI32MF2>; |
| def : VTypeInfoToFraction<VI64M2, VI32M1>; |
| def : VTypeInfoToFraction<VI64M4, VI32M2>; |
| def : VTypeInfoToFraction<VI64M8, VI32M4>; |
| } |
| |
| defset list<VTypeInfoToFraction> AllFractionableVF4IntVectors = { |
| def : VTypeInfoToFraction<VI32MF2, VI8MF8>; |
| def : VTypeInfoToFraction<VI32M1, VI8MF4>; |
| def : VTypeInfoToFraction<VI32M2, VI8MF2>; |
| def : VTypeInfoToFraction<VI32M4, VI8M1>; |
| def : VTypeInfoToFraction<VI32M8, VI8M2>; |
| def : VTypeInfoToFraction<VI64M1, VI16MF4>; |
| def : VTypeInfoToFraction<VI64M2, VI16MF2>; |
| def : VTypeInfoToFraction<VI64M4, VI16M1>; |
| def : VTypeInfoToFraction<VI64M8, VI16M2>; |
| } |
| |
| defset list<VTypeInfoToFraction> AllFractionableVF8IntVectors = { |
| def : VTypeInfoToFraction<VI64M1, VI8MF8>; |
| def : VTypeInfoToFraction<VI64M2, VI8MF4>; |
| def : VTypeInfoToFraction<VI64M4, VI8MF2>; |
| def : VTypeInfoToFraction<VI64M8, VI8M1>; |
| } |
| |
| defset list<VTypeInfoToWide> AllWidenableIntToFloatVectors = { |
| def : VTypeInfoToWide<VI8MF8, VF16MF4>; |
| def : VTypeInfoToWide<VI8MF4, VF16MF2>; |
| def : VTypeInfoToWide<VI8MF2, VF16M1>; |
| def : VTypeInfoToWide<VI8M1, VF16M2>; |
| def : VTypeInfoToWide<VI8M2, VF16M4>; |
| def : VTypeInfoToWide<VI8M4, VF16M8>; |
| |
| def : VTypeInfoToWide<VI16MF4, VF32MF2>; |
| def : VTypeInfoToWide<VI16MF2, VF32M1>; |
| def : VTypeInfoToWide<VI16M1, VF32M2>; |
| def : VTypeInfoToWide<VI16M2, VF32M4>; |
| def : VTypeInfoToWide<VI16M4, VF32M8>; |
| |
| def : VTypeInfoToWide<VI32MF2, VF64M1>; |
| def : VTypeInfoToWide<VI32M1, VF64M2>; |
| def : VTypeInfoToWide<VI32M2, VF64M4>; |
| def : VTypeInfoToWide<VI32M4, VF64M8>; |
| } |
| |
| // This class holds the record of the RISCVVPseudoTable below. |
| // This represents the information we need in codegen for each pseudo. |
| // The definition should be consistent with `struct PseudoInfo` in |
| // RISCVInstrInfo.h. |
| class RISCVVPseudo { |
| Pseudo Pseudo = !cast<Pseudo>(NAME); // Used as a key. |
| Instruction BaseInstr = !cast<Instruction>(PseudoToVInst<NAME>.VInst); |
| // SEW = 0 is used to denote that the Pseudo is not SEW specific (or unknown). |
| bits<8> SEW = 0; |
| } |
| |
| // The actual table. |
| def RISCVVPseudosTable : GenericTable { |
| let FilterClass = "RISCVVPseudo"; |
| let CppTypeName = "PseudoInfo"; |
| let Fields = [ "Pseudo", "BaseInstr" ]; |
| let PrimaryKey = [ "Pseudo" ]; |
| let PrimaryKeyName = "getPseudoInfo"; |
| let PrimaryKeyEarlyOut = true; |
| } |
| |
| def RISCVVInversePseudosTable : GenericTable { |
| let FilterClass = "RISCVVPseudo"; |
| let CppTypeName = "PseudoInfo"; |
| let Fields = [ "Pseudo", "BaseInstr", "VLMul", "SEW"]; |
| let PrimaryKey = [ "BaseInstr", "VLMul", "SEW"]; |
| let PrimaryKeyName = "getBaseInfo"; |
| let PrimaryKeyEarlyOut = true; |
| } |
| |
| def RISCVVIntrinsicsTable : GenericTable { |
| let FilterClass = "RISCVVIntrinsic"; |
| let CppTypeName = "RISCVVIntrinsicInfo"; |
| let Fields = ["IntrinsicID", "ScalarOperand", "VLOperand"]; |
| let PrimaryKey = ["IntrinsicID"]; |
| let PrimaryKeyName = "getRISCVVIntrinsicInfo"; |
| } |
| |
| // Describes the relation of a masked pseudo to the unmasked variants. |
| // Note that all masked variants (in this table) have exactly one |
| // unmasked variant. For all but compares, both the masked and |
| // unmasked variant have a passthru and policy operand. For compares, |
| // neither has a policy op, and only the masked version has a passthru. |
| class RISCVMaskedPseudo<bits<4> MaskIdx> { |
| Pseudo MaskedPseudo = !cast<Pseudo>(NAME); |
| Pseudo UnmaskedPseudo = !cast<Pseudo>(!subst("_MASK", "", NAME)); |
| bits<4> MaskOpIdx = MaskIdx; |
| } |
| |
| def RISCVMaskedPseudosTable : GenericTable { |
| let FilterClass = "RISCVMaskedPseudo"; |
| let CppTypeName = "RISCVMaskedPseudoInfo"; |
| let Fields = ["MaskedPseudo", "UnmaskedPseudo", "MaskOpIdx"]; |
| let PrimaryKey = ["MaskedPseudo"]; |
| let PrimaryKeyName = "getMaskedPseudoInfo"; |
| } |
| |
| class RISCVVLE<bit M, bit Str, bit F, bits<3> S, bits<3> L> { |
| bits<1> Masked = M; |
| bits<1> Strided = Str; |
| bits<1> FF = F; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def lookupMaskedIntrinsicByUnmasked : SearchIndex { |
| let Table = RISCVMaskedPseudosTable; |
| let Key = ["UnmaskedPseudo"]; |
| } |
| |
| def RISCVVLETable : GenericTable { |
| let FilterClass = "RISCVVLE"; |
| let CppTypeName = "VLEPseudo"; |
| let Fields = ["Masked", "Strided", "FF", "Log2SEW", "LMUL", "Pseudo"]; |
| let PrimaryKey = ["Masked", "Strided", "FF", "Log2SEW", "LMUL"]; |
| let PrimaryKeyName = "getVLEPseudo"; |
| } |
| |
| class RISCVVSE<bit M, bit Str, bits<3> S, bits<3> L> { |
| bits<1> Masked = M; |
| bits<1> Strided = Str; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def RISCVVSETable : GenericTable { |
| let FilterClass = "RISCVVSE"; |
| let CppTypeName = "VSEPseudo"; |
| let Fields = ["Masked", "Strided", "Log2SEW", "LMUL", "Pseudo"]; |
| let PrimaryKey = ["Masked", "Strided", "Log2SEW", "LMUL"]; |
| let PrimaryKeyName = "getVSEPseudo"; |
| } |
| |
| class RISCVVLX_VSX<bit M, bit O, bits<3> S, bits<3> L, bits<3> IL> { |
| bits<1> Masked = M; |
| bits<1> Ordered = O; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| bits<3> IndexLMUL = IL; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| class RISCVVLX<bit M, bit O, bits<3> S, bits<3> L, bits<3> IL> : |
| RISCVVLX_VSX<M, O, S, L, IL>; |
| class RISCVVSX<bit M, bit O, bits<3> S, bits<3> L, bits<3> IL> : |
| RISCVVLX_VSX<M, O, S, L, IL>; |
| |
| class RISCVVLX_VSXTable : GenericTable { |
| let CppTypeName = "VLX_VSXPseudo"; |
| let Fields = ["Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL", "Pseudo"]; |
| let PrimaryKey = ["Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL"]; |
| } |
| |
| def RISCVVLXTable : RISCVVLX_VSXTable { |
| let FilterClass = "RISCVVLX"; |
| let PrimaryKeyName = "getVLXPseudo"; |
| } |
| |
| def RISCVVSXTable : RISCVVLX_VSXTable { |
| let FilterClass = "RISCVVSX"; |
| let PrimaryKeyName = "getVSXPseudo"; |
| } |
| |
| class RISCVVLSEG<bits<4> N, bit M, bit Str, bit F, bits<3> S, bits<3> L> { |
| bits<4> NF = N; |
| bits<1> Masked = M; |
| bits<1> Strided = Str; |
| bits<1> FF = F; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def RISCVVLSEGTable : GenericTable { |
| let FilterClass = "RISCVVLSEG"; |
| let CppTypeName = "VLSEGPseudo"; |
| let Fields = ["NF", "Masked", "Strided", "FF", "Log2SEW", "LMUL", "Pseudo"]; |
| let PrimaryKey = ["NF", "Masked", "Strided", "FF", "Log2SEW", "LMUL"]; |
| let PrimaryKeyName = "getVLSEGPseudo"; |
| } |
| |
| class RISCVVLXSEG<bits<4> N, bit M, bit O, bits<3> S, bits<3> L, bits<3> IL> { |
| bits<4> NF = N; |
| bits<1> Masked = M; |
| bits<1> Ordered = O; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| bits<3> IndexLMUL = IL; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def RISCVVLXSEGTable : GenericTable { |
| let FilterClass = "RISCVVLXSEG"; |
| let CppTypeName = "VLXSEGPseudo"; |
| let Fields = ["NF", "Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL", "Pseudo"]; |
| let PrimaryKey = ["NF", "Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL"]; |
| let PrimaryKeyName = "getVLXSEGPseudo"; |
| } |
| |
| class RISCVVSSEG<bits<4> N, bit M, bit Str, bits<3> S, bits<3> L> { |
| bits<4> NF = N; |
| bits<1> Masked = M; |
| bits<1> Strided = Str; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def RISCVVSSEGTable : GenericTable { |
| let FilterClass = "RISCVVSSEG"; |
| let CppTypeName = "VSSEGPseudo"; |
| let Fields = ["NF", "Masked", "Strided", "Log2SEW", "LMUL", "Pseudo"]; |
| let PrimaryKey = ["NF", "Masked", "Strided", "Log2SEW", "LMUL"]; |
| let PrimaryKeyName = "getVSSEGPseudo"; |
| } |
| |
| class RISCVVSXSEG<bits<4> N, bit M, bit O, bits<3> S, bits<3> L, bits<3> IL> { |
| bits<4> NF = N; |
| bits<1> Masked = M; |
| bits<1> Ordered = O; |
| bits<3> Log2SEW = S; |
| bits<3> LMUL = L; |
| bits<3> IndexLMUL = IL; |
| Pseudo Pseudo = !cast<Pseudo>(NAME); |
| } |
| |
| def RISCVVSXSEGTable : GenericTable { |
| let FilterClass = "RISCVVSXSEG"; |
| let CppTypeName = "VSXSEGPseudo"; |
| let Fields = ["NF", "Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL", "Pseudo"]; |
| let PrimaryKey = ["NF", "Masked", "Ordered", "Log2SEW", "LMUL", "IndexLMUL"]; |
| let PrimaryKeyName = "getVSXSEGPseudo"; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Helpers to define the different pseudo instructions. |
| //===----------------------------------------------------------------------===// |
| |
| // The destination vector register group for a masked vector instruction cannot |
| // overlap the source mask register (v0), unless the destination vector register |
| // is being written with a mask value (e.g., comparisons) or the scalar result |
| // of a reduction. |
| class GetVRegNoV0<VReg VRegClass> { |
| VReg R = !cond(!eq(VRegClass, VR) : VRNoV0, |
| !eq(VRegClass, VRM2) : VRM2NoV0, |
| !eq(VRegClass, VRM4) : VRM4NoV0, |
| !eq(VRegClass, VRM8) : VRM8NoV0, |
| !eq(VRegClass, VRN2M1) : VRN2M1NoV0, |
| !eq(VRegClass, VRN2M2) : VRN2M2NoV0, |
| !eq(VRegClass, VRN2M4) : VRN2M4NoV0, |
| !eq(VRegClass, VRN3M1) : VRN3M1NoV0, |
| !eq(VRegClass, VRN3M2) : VRN3M2NoV0, |
| !eq(VRegClass, VRN4M1) : VRN4M1NoV0, |
| !eq(VRegClass, VRN4M2) : VRN4M2NoV0, |
| !eq(VRegClass, VRN5M1) : VRN5M1NoV0, |
| !eq(VRegClass, VRN6M1) : VRN6M1NoV0, |
| !eq(VRegClass, VRN7M1) : VRN7M1NoV0, |
| !eq(VRegClass, VRN8M1) : VRN8M1NoV0, |
| true : VRegClass); |
| } |
| |
| class VPseudo<Instruction instr, LMULInfo m, dag outs, dag ins, int sew = 0> : |
| Pseudo<outs, ins, []>, RISCVVPseudo { |
| let BaseInstr = instr; |
| let VLMul = m.value; |
| let SEW = sew; |
| } |
| |
| class GetVTypePredicates<VTypeInfo vti> { |
| list<Predicate> Predicates = !cond(!eq(vti.Scalar, f16) : [HasVInstructionsF16], |
| !eq(vti.Scalar, f32) : [HasVInstructionsAnyF], |
| !eq(vti.Scalar, f64) : [HasVInstructionsF64], |
| !eq(vti.SEW, 64) : [HasVInstructionsI64], |
| true : [HasVInstructions]); |
| } |
| |
| class VPseudoUSLoadNoMask<VReg RetClass, int EEW> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$dest, GPRMem:$rs1, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/0, /*Strided*/0, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $dest"; |
| } |
| |
| class VPseudoUSLoadMask<VReg RetClass, int EEW> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| GPRMem:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/1, /*Strided*/0, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoUSLoadFFNoMask<VReg RetClass, int EEW> : |
| Pseudo<(outs RetClass:$rd, GPR:$vl), |
| (ins RetClass:$dest, GPRMem:$rs1, AVL:$avl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/0, /*Strided*/0, /*FF*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $dest"; |
| } |
| |
| class VPseudoUSLoadFFMask<VReg RetClass, int EEW> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd, GPR:$vl), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| GPRMem:$rs1, |
| VMaskOp:$vm, AVL:$avl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/1, /*Strided*/0, /*FF*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoSLoadNoMask<VReg RetClass, int EEW>: |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$dest, GPRMem:$rs1, GPR:$rs2, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/0, /*Strided*/1, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $dest"; |
| } |
| |
| class VPseudoSLoadMask<VReg RetClass, int EEW>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| GPRMem:$rs1, GPR:$rs2, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLE</*Masked*/1, /*Strided*/1, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoILoadNoMask<VReg RetClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bit Ordered, bit EarlyClobber>: |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$dest, GPRMem:$rs1, IdxClass:$rs2, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLX</*Masked*/0, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = !if(!eq(EarlyClobber, 1), "@earlyclobber $rd, $rd = $dest", "$rd = $dest"); |
| } |
| |
| class VPseudoILoadMask<VReg RetClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bit Ordered, bit EarlyClobber>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| GPRMem:$rs1, IdxClass:$rs2, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLX</*Masked*/1, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !if(!eq(EarlyClobber, 1), "@earlyclobber $rd, $rd = $merge", "$rd = $merge"); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoUSStoreNoMask<VReg StClass, int EEW>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSE</*Masked*/0, /*Strided*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoUSStoreMask<VReg StClass, int EEW>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSE</*Masked*/1, /*Strided*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoSStoreNoMask<VReg StClass, int EEW>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, GPR:$rs2, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSE</*Masked*/0, /*Strided*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoSStoreMask<VReg StClass, int EEW>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, GPR:$rs2, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSE</*Masked*/1, /*Strided*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoNullaryNoMask<VReg RegClass>: |
| Pseudo<(outs RegClass:$rd), |
| (ins RegClass:$merge, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy), []>, RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| class VPseudoNullaryMask<VReg RegClass>: |
| Pseudo<(outs GetVRegNoV0<RegClass>.R:$rd), |
| (ins GetVRegNoV0<RegClass>.R:$merge, VMaskOp:$vm, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy), []>, RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints ="$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let UsesMaskPolicy = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| // Nullary for pseudo instructions. They are expanded in |
| // RISCVExpandPseudoInsts pass. |
| class VPseudoNullaryPseudoM<string BaseInst> |
| : Pseudo<(outs VR:$rd), (ins AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| // BaseInstr is not used in RISCVExpandPseudoInsts pass. |
| // Just fill a corresponding real v-inst to pass tablegen check. |
| let BaseInstr = !cast<Instruction>(BaseInst); |
| } |
| |
| class VPseudoUnaryNoMask<DAGOperand RetClass, DAGOperand OpClass, |
| string Constraint = ""> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, OpClass:$rs2, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| class VPseudoUnaryNoMaskRoundingMode<DAGOperand RetClass, DAGOperand OpClass, |
| string Constraint = ""> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, OpClass:$rs2, ixlenimm:$rm, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| class VPseudoUnaryMask<VReg RetClass, VReg OpClass, string Constraint = ""> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, OpClass:$rs2, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoUnaryMaskRoundingMode<VReg RetClass, VReg OpClass, string Constraint = ""> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, OpClass:$rs2, |
| VMaskOp:$vm, ixlenimm:$rm, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| class VPseudoUnaryMask_NoExcept<VReg RetClass, VReg OpClass, string Constraint = ""> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, OpClass:$rs2, VMaskOp:$vm, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []> { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let usesCustomInserter = 1; |
| } |
| |
| class VPseudoUnaryNoMask_FRM<VReg RetClass, VReg OpClass, string Constraint = ""> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, OpClass:$rs2, ixlenimm:$frm, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy), []> { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let usesCustomInserter = 1; |
| } |
| |
| class VPseudoUnaryMask_FRM<VReg RetClass, VReg OpClass, string Constraint = ""> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, OpClass:$rs2, |
| VMaskOp:$vm, ixlenimm:$frm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []> { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let usesCustomInserter = 1; |
| } |
| |
| class VPseudoUnaryNoMaskGPROut : |
| Pseudo<(outs GPR:$rd), |
| (ins VR:$rs2, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoUnaryMaskGPROut: |
| Pseudo<(outs GPR:$rd), |
| (ins VR:$rs1, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| // Mask can be V0~V31 |
| class VPseudoUnaryAnyMask<VReg RetClass, |
| VReg Op1Class> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, |
| Op1Class:$rs2, |
| VR:$vm, AVL:$vl, ixlenimm:$sew), |
| []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "@earlyclobber $rd, $rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoBinaryNoMask<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins Op1Class:$rs2, Op2Class:$rs1, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = Constraint; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoBinaryNoMaskTU<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, Op1Class:$rs2, Op2Class:$rs1, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| class VPseudoBinaryNoMaskRoundingMode<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| string Constraint, |
| int UsesVXRM_ = 1> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, Op1Class:$rs2, Op2Class:$rs1, ixlenimm:$rm, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = UsesVXRM_; |
| } |
| |
| class VPseudoBinaryMaskPolicyRoundingMode<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint, |
| int UsesVXRM_> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, ixlenimm:$rm, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = UsesVXRM_; |
| } |
| |
| // Special version of VPseudoBinaryNoMask where we pretend the first source is |
| // tied to the destination. |
| // This allows maskedoff and rs2 to be the same register. |
| class VPseudoTiedBinaryNoMask<VReg RetClass, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$rs2, Op2Class:$rs1, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $rs2"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let isConvertibleToThreeAddress = 1; |
| let IsTiedPseudo = 1; |
| } |
| |
| class VPseudoTiedBinaryNoMaskRoundingMode<VReg RetClass, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$rs2, Op2Class:$rs1, |
| ixlenimm:$rm, |
| AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $rs2"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let isConvertibleToThreeAddress = 1; |
| let IsTiedPseudo = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| class VPseudoIStoreNoMask<VReg StClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bit Ordered>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, IdxClass:$rs2, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSX</*Masked*/0, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoIStoreMask<VReg StClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bit Ordered>: |
| Pseudo<(outs), |
| (ins StClass:$rd, GPRMem:$rs1, IdxClass:$rs2, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSX</*Masked*/1, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoBinaryMask<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoBinaryMaskPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoTernaryMaskPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| class VPseudoTernaryMaskPolicyRoundingMode<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, |
| ixlenimm:$rm, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| // Like VPseudoBinaryNoMask, but output can be V0. |
| class VPseudoBinaryMOutNoMask<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins Op1Class:$rs2, Op2Class:$rs1, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = Constraint; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| // Like VPseudoBinaryMask, but output can be V0. |
| class VPseudoBinaryMOutMask<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, |
| Op1Class:$rs2, Op2Class:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| // Special version of VPseudoBinaryMask where we pretend the first source is |
| // tied to the destination so we can workaround the earlyclobber constraint. |
| // This allows maskedoff and rs2 to be the same register. |
| class VPseudoTiedBinaryMask<VReg RetClass, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op2Class:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let IsTiedPseudo = 1; |
| } |
| |
| class VPseudoTiedBinaryMaskRoundingMode<VReg RetClass, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, |
| Op2Class:$rs1, |
| VMaskOp:$vm, |
| ixlenimm:$rm, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| let IsTiedPseudo = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| class VPseudoBinaryCarryIn<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| bit CarryIn, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| !if(CarryIn, |
| (ins Op1Class:$rs2, Op2Class:$rs1, VMV0:$carry, AVL:$vl, |
| ixlenimm:$sew), |
| (ins Op1Class:$rs2, Op2Class:$rs1, AVL:$vl, ixlenimm:$sew)), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = Constraint; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let VLMul = MInfo.value; |
| } |
| |
| class VPseudoTiedBinaryCarryIn<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| bit CarryIn, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| !if(CarryIn, |
| (ins RetClass:$merge, Op1Class:$rs2, Op2Class:$rs1, VMV0:$carry, AVL:$vl, |
| ixlenimm:$sew), |
| (ins RetClass:$merge, Op1Class:$rs2, Op2Class:$rs1, AVL:$vl, ixlenimm:$sew)), []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $merge"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 0; |
| let VLMul = MInfo.value; |
| } |
| |
| class VPseudoTernaryNoMask<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$rs3, Op1Class:$rs1, Op2Class:$rs2, |
| AVL:$vl, ixlenimm:$sew), |
| []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $rs3"], ","); |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoTernaryNoMaskWithPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$rs3, Op1Class:$rs1, Op2Class:$rs2, |
| AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), |
| []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $rs3"], ","); |
| let HasVecPolicyOp = 1; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoTernaryNoMaskWithPolicyRoundingMode<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| string Constraint> : |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$rs3, Op1Class:$rs1, Op2Class:$rs2, |
| ixlenimm:$rm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy), |
| []>, |
| RISCVVPseudo { |
| let mayLoad = 0; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = !interleave([Constraint, "$rd = $rs3"], ","); |
| let HasVecPolicyOp = 1; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasRoundModeOp = 1; |
| let UsesVXRM = 0; |
| } |
| |
| class VPseudoUSSegLoadNoMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$dest, GPRMem:$rs1, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/0, /*Strided*/0, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $dest"; |
| } |
| |
| class VPseudoUSSegLoadMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, GPRMem:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/1, /*Strided*/0, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoUSSegLoadFFNoMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs RetClass:$rd, GPR:$vl), |
| (ins RetClass:$dest, GPRMem:$rs1, AVL:$avl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/0, /*Strided*/0, /*FF*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $dest"; |
| } |
| |
| class VPseudoUSSegLoadFFMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd, GPR:$vl), |
| (ins GetVRegNoV0<RetClass>.R:$merge, GPRMem:$rs1, |
| VMaskOp:$vm, AVL:$avl, ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/1, /*Strided*/0, /*FF*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoSSegLoadNoMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, GPRMem:$rs1, GPR:$offset, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/0, /*Strided*/1, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let Constraints = "$rd = $merge"; |
| } |
| |
| class VPseudoSSegLoadMask<VReg RetClass, int EEW, bits<4> NF>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, GPRMem:$rs1, |
| GPR:$offset, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLSEG<NF, /*Masked*/1, /*Strided*/1, /*FF*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| let Constraints = "$rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoISegLoadNoMask<VReg RetClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bits<4> NF, bit Ordered>: |
| Pseudo<(outs RetClass:$rd), |
| (ins RetClass:$merge, GPRMem:$rs1, IdxClass:$offset, AVL:$vl, |
| ixlenimm:$sew, ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLXSEG<NF, /*Masked*/0, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| // For vector indexed segment loads, the destination vector register groups |
| // cannot overlap the source vector register group |
| let Constraints = "@earlyclobber $rd, $rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| } |
| |
| class VPseudoISegLoadMask<VReg RetClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bits<4> NF, bit Ordered>: |
| Pseudo<(outs GetVRegNoV0<RetClass>.R:$rd), |
| (ins GetVRegNoV0<RetClass>.R:$merge, GPRMem:$rs1, |
| IdxClass:$offset, VMaskOp:$vm, AVL:$vl, ixlenimm:$sew, |
| ixlenimm:$policy),[]>, |
| RISCVVPseudo, |
| RISCVVLXSEG<NF, /*Masked*/1, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 1; |
| let mayStore = 0; |
| let hasSideEffects = 0; |
| // For vector indexed segment loads, the destination vector register groups |
| // cannot overlap the source vector register group |
| let Constraints = "@earlyclobber $rd, $rd = $merge"; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| let HasVecPolicyOp = 1; |
| let UsesMaskPolicy = 1; |
| } |
| |
| class VPseudoUSSegStoreNoMask<VReg ValClass, int EEW, bits<4> NF>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSSEG<NF, /*Masked*/0, /*Strided*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoUSSegStoreMask<VReg ValClass, int EEW, bits<4> NF>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSSEG<NF, /*Masked*/1, /*Strided*/0, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoSSegStoreNoMask<VReg ValClass, int EEW, bits<4> NF>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, GPR: $offset, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSSEG<NF, /*Masked*/0, /*Strided*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoSSegStoreMask<VReg ValClass, int EEW, bits<4> NF>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, GPR: $offset, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSSEG<NF, /*Masked*/1, /*Strided*/1, !logtwo(EEW), VLMul> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoISegStoreNoMask<VReg ValClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bits<4> NF, bit Ordered>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, IdxClass: $index, |
| AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSXSEG<NF, /*Masked*/0, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| class VPseudoISegStoreMask<VReg ValClass, VReg IdxClass, int EEW, bits<3> LMUL, |
| bits<4> NF, bit Ordered>: |
| Pseudo<(outs), |
| (ins ValClass:$rd, GPRMem:$rs1, IdxClass: $index, |
| VMaskOp:$vm, AVL:$vl, ixlenimm:$sew),[]>, |
| RISCVVPseudo, |
| RISCVVSXSEG<NF, /*Masked*/1, Ordered, !logtwo(EEW), VLMul, LMUL> { |
| let mayLoad = 0; |
| let mayStore = 1; |
| let hasSideEffects = 0; |
| let HasVLOp = 1; |
| let HasSEWOp = 1; |
| } |
| |
| multiclass VPseudoUSLoad { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| defvar vreg = lmul.vrclass; |
| let VLMul = lmul.value, SEW=eew in { |
| def "E" # eew # "_V_" # LInfo : |
| VPseudoUSLoadNoMask<vreg, eew>, |
| VLESched<LInfo>; |
| def "E" # eew # "_V_" # LInfo # "_MASK" : |
| VPseudoUSLoadMask<vreg, eew>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| VLESched<LInfo>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoFFLoad { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| defvar vreg = lmul.vrclass; |
| let VLMul = lmul.value, SEW=eew in { |
| def "E" # eew # "FF_V_" # LInfo: |
| VPseudoUSLoadFFNoMask<vreg, eew>, |
| VLFSched<LInfo>; |
| def "E" # eew # "FF_V_" # LInfo # "_MASK": |
| VPseudoUSLoadFFMask<vreg, eew>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| VLFSched<LInfo>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoLoadMask { |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVLDM_MX = !cast<SchedWrite>("WriteVLDM_" # mx); |
| let VLMul = mti.LMul.value in { |
| def "_V_" # mti.BX : VPseudoUSLoadNoMask<VR, EEW=1>, |
| Sched<[WriteVLDM_MX, ReadVLDX]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoSLoad { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| defvar vreg = lmul.vrclass; |
| let VLMul = lmul.value, SEW=eew in { |
| def "E" # eew # "_V_" # LInfo : VPseudoSLoadNoMask<vreg, eew>, |
| VLSSched<eew, LInfo>; |
| def "E" # eew # "_V_" # LInfo # "_MASK" : |
| VPseudoSLoadMask<vreg, eew>, |
| RISCVMaskedPseudo<MaskIdx=3>, |
| VLSSched<eew, LInfo>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoILoad<bit Ordered> { |
| foreach idxEEW = EEWList in { |
| foreach dataEEW = EEWList in { |
| foreach dataEMUL = MxSet<dataEEW>.m in { |
| defvar dataEMULOctuple = dataEMUL.octuple; |
| // Calculate emul = eew * lmul / sew |
| defvar idxEMULOctuple = |
| !srl(!mul(idxEEW, dataEMULOctuple), !logtwo(dataEEW)); |
| if !and(!ge(idxEMULOctuple, 1), !le(idxEMULOctuple, 64)) then { |
| defvar DataLInfo = dataEMUL.MX; |
| defvar IdxLInfo = octuple_to_str<idxEMULOctuple>.ret; |
| defvar idxEMUL = !cast<LMULInfo>("V_" # IdxLInfo); |
| defvar Vreg = dataEMUL.vrclass; |
| defvar IdxVreg = idxEMUL.vrclass; |
| defvar HasConstraint = !ne(dataEEW, idxEEW); |
| defvar Order = !if(Ordered, "O", "U"); |
| let VLMul = dataEMUL.value in { |
| def "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo : |
| VPseudoILoadNoMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, Ordered, HasConstraint>, |
| VLXSched<dataEEW, Order, DataLInfo, IdxLInfo>; |
| def "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo # "_MASK" : |
| VPseudoILoadMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, Ordered, HasConstraint>, |
| RISCVMaskedPseudo<MaskIdx=3>, |
| VLXSched<dataEEW, Order, DataLInfo, IdxLInfo>; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoUSStore { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| defvar vreg = lmul.vrclass; |
| let VLMul = lmul.value, SEW=eew in { |
| def "E" # eew # "_V_" # LInfo : VPseudoUSStoreNoMask<vreg, eew>, |
| VSESched<LInfo>; |
| def "E" # eew # "_V_" # LInfo # "_MASK" : VPseudoUSStoreMask<vreg, eew>, |
| VSESched<LInfo>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoStoreMask { |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVSTM_MX = !cast<SchedWrite>("WriteVSTM_" # mx); |
| let VLMul = mti.LMul.value in { |
| def "_V_" # mti.BX : VPseudoUSStoreNoMask<VR, EEW=1>, |
| Sched<[WriteVSTM_MX, ReadVSTX]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoSStore { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| defvar vreg = lmul.vrclass; |
| let VLMul = lmul.value, SEW=eew in { |
| def "E" # eew # "_V_" # LInfo : VPseudoSStoreNoMask<vreg, eew>, |
| VSSSched<eew, LInfo>; |
| def "E" # eew # "_V_" # LInfo # "_MASK" : VPseudoSStoreMask<vreg, eew>, |
| VSSSched<eew, LInfo>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoIStore<bit Ordered> { |
| foreach idxEEW = EEWList in { |
| foreach dataEEW = EEWList in { |
| foreach dataEMUL = MxSet<dataEEW>.m in { |
| defvar dataEMULOctuple = dataEMUL.octuple; |
| // Calculate emul = eew * lmul / sew |
| defvar idxEMULOctuple = |
| !srl(!mul(idxEEW, dataEMULOctuple), !logtwo(dataEEW)); |
| if !and(!ge(idxEMULOctuple, 1), !le(idxEMULOctuple, 64)) then { |
| defvar DataLInfo = dataEMUL.MX; |
| defvar IdxLInfo = octuple_to_str<idxEMULOctuple>.ret; |
| defvar idxEMUL = !cast<LMULInfo>("V_" # IdxLInfo); |
| defvar Vreg = dataEMUL.vrclass; |
| defvar IdxVreg = idxEMUL.vrclass; |
| defvar Order = !if(Ordered, "O", "U"); |
| let VLMul = dataEMUL.value in { |
| def "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo : |
| VPseudoIStoreNoMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, Ordered>, |
| VSXSched<dataEEW, Order, DataLInfo, IdxLInfo>; |
| def "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo # "_MASK" : |
| VPseudoIStoreMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, Ordered>, |
| VSXSched<dataEEW, Order, DataLInfo, IdxLInfo>; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoVPOP_M { |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVMPopV_MX = !cast<SchedWrite>("WriteVMPopV_" # mx); |
| defvar ReadVMPopV_MX = !cast<SchedRead>("ReadVMPopV_" # mx); |
| let VLMul = mti.LMul.value in { |
| def "_M_" # mti.BX : VPseudoUnaryNoMaskGPROut, |
| Sched<[WriteVMPopV_MX, ReadVMPopV_MX, ReadVMPopV_MX]>; |
| def "_M_" # mti.BX # "_MASK" : VPseudoUnaryMaskGPROut, |
| Sched<[WriteVMPopV_MX, ReadVMPopV_MX, ReadVMPopV_MX]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoV1ST_M { |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVMFFSV_MX = !cast<SchedWrite>("WriteVMFFSV_" # mx); |
| defvar ReadVMFFSV_MX = !cast<SchedRead>("ReadVMFFSV_" # mx); |
| let VLMul = mti.LMul.value in { |
| def "_M_" # mti.BX : VPseudoUnaryNoMaskGPROut, |
| Sched<[WriteVMFFSV_MX, ReadVMFFSV_MX, ReadVMFFSV_MX]>; |
| def "_M_" # mti.BX # "_MASK" : VPseudoUnaryMaskGPROut, |
| Sched<[WriteVMFFSV_MX, ReadVMFFSV_MX, ReadVMFFSV_MX]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVSFS_M { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVMSFSV_MX = !cast<SchedWrite>("WriteVMSFSV_" # mx); |
| defvar ReadVMSFSV_MX = !cast<SchedRead>("ReadVMSFSV_" # mx); |
| let VLMul = mti.LMul.value in { |
| def "_M_" # mti.BX : VPseudoUnaryNoMask<VR, VR, constraint>, |
| Sched<[WriteVMSFSV_MX, ReadVMSFSV_MX, ReadVMask]>; |
| def "_M_" # mti.BX # "_MASK" : VPseudoUnaryMask<VR, VR, constraint>, |
| Sched<[WriteVMSFSV_MX, ReadVMSFSV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVID_V { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVMIdxV_MX = !cast<SchedWrite>("WriteVMIdxV_" # mx); |
| defvar ReadVMIdxV_MX = !cast<SchedRead>("ReadVMIdxV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_V_" # m.MX : VPseudoNullaryNoMask<m.vrclass>, |
| Sched<[WriteVMIdxV_MX, ReadVMask]>; |
| def "_V_" # m.MX # "_MASK" : VPseudoNullaryMask<m.vrclass>, |
| RISCVMaskedPseudo<MaskIdx=1>, |
| Sched<[WriteVMIdxV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoNullaryPseudoM <string BaseInst> { |
| foreach mti = AllMasks in { |
| defvar mx = mti.LMul.MX; |
| defvar WriteVMALUV_MX = !cast<SchedWrite>("WriteVMALUV_" # mx); |
| defvar ReadVMALUV_MX = !cast<SchedRead>("ReadVMALUV_" # mx); |
| |
| let VLMul = mti.LMul.value in { |
| def "_M_" # mti.BX : VPseudoNullaryPseudoM<BaseInst # "_MM">, |
| Sched<[WriteVMALUV_MX, ReadVMALUV_MX, ReadVMALUV_MX]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVIOT_M { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVMIotV_MX = !cast<SchedWrite>("WriteVMIotV_" # mx); |
| defvar ReadVMIotV_MX = !cast<SchedRead>("ReadVMIotV_" # mx); |
| let VLMul = m.value in { |
| def "_" # m.MX : VPseudoUnaryNoMask<m.vrclass, VR, constraint>, |
| Sched<[WriteVMIotV_MX, ReadVMIotV_MX, ReadVMask]>; |
| def "_" # m.MX # "_MASK" : VPseudoUnaryMask<m.vrclass, VR, constraint>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVMIotV_MX, ReadVMIotV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVCPR_V { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar sews = SchedSEWSet<mx>.val; |
| let VLMul = m.value in |
| foreach e = sews in { |
| defvar suffix = "_" # m.MX # "_E" # e; |
| defvar WriteVCompressV_MX_E = !cast<SchedWrite>("WriteVCompressV" # suffix); |
| defvar ReadVCompressV_MX_E = !cast<SchedRead>("ReadVCompressV" # suffix); |
| |
| let SEW = e in |
| def _VM # suffix : VPseudoUnaryAnyMask<m.vrclass, m.vrclass>, |
| Sched<[WriteVCompressV_MX_E, ReadVCompressV_MX_E, ReadVCompressV_MX_E]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoBinary<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = "", |
| int sew = 0> { |
| let VLMul = MInfo.value, SEW=sew in { |
| defvar suffix = !if(sew, "_" # MInfo.MX # "_E" # sew, "_" # MInfo.MX); |
| def suffix : VPseudoBinaryNoMaskTU<RetClass, Op1Class, Op2Class, |
| Constraint>; |
| def suffix # "_MASK" : VPseudoBinaryMaskPolicy<RetClass, Op1Class, Op2Class, |
| Constraint>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoBinaryRoundingMode<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = "", |
| int sew = 0, |
| int UsesVXRM = 1> { |
| let VLMul = MInfo.value, SEW=sew in { |
| defvar suffix = !if(sew, "_" # MInfo.MX # "_E" # sew, "_" # MInfo.MX); |
| def suffix : VPseudoBinaryNoMaskRoundingMode<RetClass, Op1Class, Op2Class, |
| Constraint, UsesVXRM>; |
| def suffix # "_MASK" : VPseudoBinaryMaskPolicyRoundingMode<RetClass, |
| Op1Class, |
| Op2Class, |
| Constraint, |
| UsesVXRM>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| |
| multiclass VPseudoBinaryM<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX : VPseudoBinaryMOutNoMask<RetClass, Op1Class, Op2Class, |
| Constraint>; |
| let ForceTailAgnostic = true in |
| def "_" # MInfo.MX # "_MASK" : VPseudoBinaryMOutMask<RetClass, Op1Class, |
| Op2Class, Constraint>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoBinaryEmul<VReg RetClass, |
| VReg Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo lmul, |
| LMULInfo emul, |
| string Constraint = "", |
| int sew = 0> { |
| let VLMul = lmul.value, SEW=sew in { |
| defvar suffix = !if(sew, "_" # lmul.MX # "_E" # sew, "_" # lmul.MX); |
| def suffix # "_" # emul.MX : VPseudoBinaryNoMaskTU<RetClass, Op1Class, Op2Class, |
| Constraint>; |
| def suffix # "_" # emul.MX # "_MASK" : VPseudoBinaryMaskPolicy<RetClass, Op1Class, Op2Class, |
| Constraint>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoTiedBinary<VReg RetClass, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX # "_TIED": VPseudoTiedBinaryNoMask<RetClass, Op2Class, |
| Constraint>; |
| def "_" # MInfo.MX # "_MASK_TIED" : VPseudoTiedBinaryMask<RetClass, Op2Class, |
| Constraint>; |
| } |
| } |
| |
| multiclass VPseudoTiedBinaryRoundingMode<VReg RetClass, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX # "_TIED": |
| VPseudoTiedBinaryNoMaskRoundingMode<RetClass, Op2Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK_TIED" : |
| VPseudoTiedBinaryMaskRoundingMode<RetClass, Op2Class, Constraint>; |
| } |
| } |
| |
| |
| multiclass VPseudoBinaryV_VV<LMULInfo m, string Constraint = "", int sew = 0> { |
| defm _VV : VPseudoBinary<m.vrclass, m.vrclass, m.vrclass, m, Constraint, sew>; |
| } |
| |
| multiclass VPseudoBinaryV_VV_RM<LMULInfo m, string Constraint = ""> { |
| defm _VV : VPseudoBinaryRoundingMode<m.vrclass, m.vrclass, m.vrclass, m, Constraint>; |
| } |
| |
| // Similar to VPseudoBinaryV_VV, but uses MxListF. |
| multiclass VPseudoBinaryFV_VV<LMULInfo m, string Constraint = "", int sew = 0> { |
| defm _VV : VPseudoBinary<m.vrclass, m.vrclass, m.vrclass, m, Constraint, sew>; |
| } |
| |
| multiclass VPseudoBinaryFV_VV_RM<LMULInfo m, string Constraint = "", int sew = 0> { |
| defm _VV : VPseudoBinaryRoundingMode<m.vrclass, m.vrclass, m.vrclass, m, |
| Constraint, sew, |
| UsesVXRM=0>; |
| } |
| |
| multiclass VPseudoVGTR_VV_EEW<int eew, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| foreach sew = EEWList in { |
| defvar dataEMULOctuple = m.octuple; |
| // emul = lmul * eew / sew |
| defvar idxEMULOctuple = !srl(!mul(dataEMULOctuple, eew), !logtwo(sew)); |
| if !and(!ge(idxEMULOctuple, 1), !le(idxEMULOctuple, 64)) then { |
| defvar emulMX = octuple_to_str<idxEMULOctuple>.ret; |
| defvar emul = !cast<LMULInfo>("V_" # emulMX); |
| defvar sews = SchedSEWSet<mx>.val; |
| foreach e = sews in { |
| defvar WriteVRGatherVV_MX_E = !cast<SchedWrite>("WriteVRGatherVV_" # mx # "_E" # e); |
| defvar ReadVRGatherVV_data_MX_E = !cast<SchedRead>("ReadVRGatherVV_data_" # mx # "_E" # e); |
| defvar ReadVRGatherVV_index_MX_E = !cast<SchedRead>("ReadVRGatherVV_index_" # mx # "_E" # e); |
| defm _VV : VPseudoBinaryEmul<m.vrclass, m.vrclass, emul.vrclass, m, emul, Constraint, e>, |
| Sched<[WriteVRGatherVV_MX_E, ReadVRGatherVV_data_MX_E, ReadVRGatherVV_index_MX_E]>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoBinaryV_VX<LMULInfo m, string Constraint = "", int sew = 0> { |
| defm "_VX" : VPseudoBinary<m.vrclass, m.vrclass, GPR, m, Constraint, sew>; |
| } |
| |
| multiclass VPseudoBinaryV_VX_RM<LMULInfo m, string Constraint = ""> { |
| defm "_VX" : VPseudoBinaryRoundingMode<m.vrclass, m.vrclass, GPR, m, Constraint>; |
| } |
| |
| multiclass VPseudoVSLD1_VX<string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVISlide1X_MX = !cast<SchedWrite>("WriteVISlide1X_" # mx); |
| defvar ReadVISlideV_MX = !cast<SchedRead>("ReadVISlideV_" # mx); |
| defvar ReadVISlideX_MX = !cast<SchedRead>("ReadVISlideX_" # mx); |
| |
| defm "_VX" : VPseudoBinary<m.vrclass, m.vrclass, GPR, m, Constraint>, |
| Sched<[WriteVISlide1X_MX, ReadVISlideV_MX, ReadVISlideX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoBinaryV_VF<LMULInfo m, FPR_Info f, string Constraint = "", int sew = 0> { |
| defm "_V" # f.FX : VPseudoBinary<m.vrclass, m.vrclass, |
| f.fprclass, m, Constraint, sew>; |
| } |
| |
| multiclass VPseudoBinaryV_VF_RM<LMULInfo m, FPR_Info f, string Constraint = "", int sew = 0> { |
| defm "_V" # f.FX : VPseudoBinaryRoundingMode<m.vrclass, m.vrclass, |
| f.fprclass, m, Constraint, sew, |
| UsesVXRM=0>; |
| } |
| |
| multiclass VPseudoVSLD1_VF<string Constraint = ""> { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFSlide1F_MX = !cast<SchedWrite>("WriteVFSlide1F_" # mx); |
| defvar ReadVFSlideV_MX = !cast<SchedRead>("ReadVFSlideV_" # mx); |
| defvar ReadVFSlideF_MX = !cast<SchedRead>("ReadVFSlideF_" # mx); |
| |
| defm "_V" # f.FX : |
| VPseudoBinary<m.vrclass, m.vrclass, f.fprclass, m, Constraint>, |
| Sched<[WriteVFSlide1F_MX, ReadVFSlideV_MX, ReadVFSlideF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoBinaryV_VI<Operand ImmType = simm5, LMULInfo m, string Constraint = ""> { |
| defm _VI : VPseudoBinary<m.vrclass, m.vrclass, ImmType, m, Constraint>; |
| } |
| |
| multiclass VPseudoBinaryV_VI_RM<Operand ImmType = simm5, LMULInfo m, string Constraint = ""> { |
| defm _VI : VPseudoBinaryRoundingMode<m.vrclass, m.vrclass, ImmType, m, Constraint>; |
| } |
| |
| multiclass VPseudoVALU_MM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVMALUV_MX = !cast<SchedWrite>("WriteVMALUV_" # mx); |
| defvar ReadVMALUV_MX = !cast<SchedRead>("ReadVMALUV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_MM_" # mx : VPseudoBinaryNoMask<VR, VR, VR, "">, |
| Sched<[WriteVMALUV_MX, ReadVMALUV_MX, ReadVMALUV_MX]>; |
| } |
| } |
| } |
| |
| // We use earlyclobber here due to |
| // * The destination EEW is smaller than the source EEW and the overlap is |
| // in the lowest-numbered part of the source register group is legal. |
| // Otherwise, it is illegal. |
| // * The destination EEW is greater than the source EEW, the source EMUL is |
| // at least 1, and the overlap is in the highest-numbered part of the |
| // destination register group is legal. Otherwise, it is illegal. |
| multiclass VPseudoBinaryW_VV<LMULInfo m> { |
| defm _VV : VPseudoBinary<m.wvrclass, m.vrclass, m.vrclass, m, |
| "@earlyclobber $rd">; |
| } |
| |
| multiclass VPseudoBinaryW_VV_RM<LMULInfo m> { |
| defm _VV : VPseudoBinaryRoundingMode<m.wvrclass, m.vrclass, m.vrclass, m, |
| "@earlyclobber $rd", UsesVXRM=0>; |
| } |
| |
| multiclass VPseudoBinaryW_VX<LMULInfo m> { |
| defm "_VX" : VPseudoBinary<m.wvrclass, m.vrclass, GPR, m, |
| "@earlyclobber $rd">; |
| } |
| |
| multiclass VPseudoBinaryW_VF<LMULInfo m, FPR_Info f> { |
| defm "_V" # f.FX : VPseudoBinary<m.wvrclass, m.vrclass, |
| f.fprclass, m, |
| "@earlyclobber $rd">; |
| } |
| |
| multiclass VPseudoBinaryW_VF_RM<LMULInfo m, FPR_Info f> { |
| defm "_V" # f.FX : VPseudoBinaryRoundingMode<m.wvrclass, m.vrclass, |
| f.fprclass, m, |
| "@earlyclobber $rd", |
| UsesVXRM=0>; |
| } |
| |
| multiclass VPseudoBinaryW_WV<LMULInfo m> { |
| defm _WV : VPseudoBinary<m.wvrclass, m.wvrclass, m.vrclass, m, |
| "@earlyclobber $rd">; |
| defm _WV : VPseudoTiedBinary<m.wvrclass, m.vrclass, m, |
| "@earlyclobber $rd">; |
| } |
| |
| multiclass VPseudoBinaryW_WV_RM<LMULInfo m> { |
| defm _WV : VPseudoBinaryRoundingMode<m.wvrclass, m.wvrclass, m.vrclass, m, |
| "@earlyclobber $rd", UsesVXRM=0>; |
| defm _WV : VPseudoTiedBinaryRoundingMode<m.wvrclass, m.vrclass, m, |
| "@earlyclobber $rd">; |
| } |
| |
| multiclass VPseudoBinaryW_WX<LMULInfo m> { |
| defm "_WX" : VPseudoBinary<m.wvrclass, m.wvrclass, GPR, m>; |
| } |
| |
| multiclass VPseudoBinaryW_WF<LMULInfo m, FPR_Info f> { |
| defm "_W" # f.FX : VPseudoBinary<m.wvrclass, m.wvrclass, |
| f.fprclass, m>; |
| } |
| |
| multiclass VPseudoBinaryW_WF_RM<LMULInfo m, FPR_Info f> { |
| defm "_W" # f.FX : VPseudoBinaryRoundingMode<m.wvrclass, m.wvrclass, |
| f.fprclass, m, |
| UsesVXRM=0>; |
| } |
| |
| // Narrowing instructions like vnsrl/vnsra/vnclip(u) don't need @earlyclobber |
| // if the source and destination have an LMUL<=1. This matches this overlap |
| // exception from the spec. |
| // "The destination EEW is smaller than the source EEW and the overlap is in the |
| // lowest-numbered part of the source register group." |
| multiclass VPseudoBinaryV_WV<LMULInfo m> { |
| defm _WV : VPseudoBinary<m.vrclass, m.wvrclass, m.vrclass, m, |
| !if(!ge(m.octuple, 8), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryV_WV_RM<LMULInfo m> { |
| defm _WV : VPseudoBinaryRoundingMode<m.vrclass, m.wvrclass, m.vrclass, m, |
| !if(!ge(m.octuple, 8), |
| "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryV_WX<LMULInfo m> { |
| defm _WX : VPseudoBinary<m.vrclass, m.wvrclass, GPR, m, |
| !if(!ge(m.octuple, 8), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryV_WX_RM<LMULInfo m> { |
| defm _WX : VPseudoBinaryRoundingMode<m.vrclass, m.wvrclass, GPR, m, |
| !if(!ge(m.octuple, 8), |
| "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryV_WI<LMULInfo m> { |
| defm _WI : VPseudoBinary<m.vrclass, m.wvrclass, uimm5, m, |
| !if(!ge(m.octuple, 8), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryV_WI_RM<LMULInfo m> { |
| defm _WI : VPseudoBinaryRoundingMode<m.vrclass, m.wvrclass, uimm5, m, |
| !if(!ge(m.octuple, 8), |
| "@earlyclobber $rd", "")>; |
| } |
| |
| // For vadc and vsbc, the instruction encoding is reserved if the destination |
| // vector register is v0. |
| // For vadc and vsbc, CarryIn == 1 and CarryOut == 0 |
| multiclass VPseudoBinaryV_VM<LMULInfo m, bit CarryOut = 0, bit CarryIn = 1, |
| string Constraint = ""> { |
| def "_VV" # !if(CarryIn, "M", "") # "_" # m.MX : |
| VPseudoBinaryCarryIn<!if(CarryOut, VR, |
| !if(!and(CarryIn, !not(CarryOut)), |
| GetVRegNoV0<m.vrclass>.R, m.vrclass)), |
| m.vrclass, m.vrclass, m, CarryIn, Constraint>; |
| } |
| |
| multiclass VPseudoTiedBinaryV_VM<LMULInfo m> { |
| def "_VVM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, m.vrclass, m, 1, "">; |
| } |
| |
| multiclass VPseudoBinaryV_XM<LMULInfo m, bit CarryOut = 0, bit CarryIn = 1, |
| string Constraint = ""> { |
| def "_VX" # !if(CarryIn, "M", "") # "_" # m.MX : |
| VPseudoBinaryCarryIn<!if(CarryOut, VR, |
| !if(!and(CarryIn, !not(CarryOut)), |
| GetVRegNoV0<m.vrclass>.R, m.vrclass)), |
| m.vrclass, GPR, m, CarryIn, Constraint>; |
| } |
| |
| multiclass VPseudoTiedBinaryV_XM<LMULInfo m> { |
| def "_VXM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, GPR, m, 1, "">; |
| } |
| |
| multiclass VPseudoVMRG_FM { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMergeV_MX = !cast<SchedWrite>("WriteVFMergeV_" # mx); |
| defvar ReadVFMergeV_MX = !cast<SchedRead>("ReadVFMergeV_" # mx); |
| defvar ReadVFMergeF_MX = !cast<SchedRead>("ReadVFMergeF_" # mx); |
| |
| def "_V" # f.FX # "M_" # mx: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, f.fprclass, m, CarryIn=1, Constraint="">, |
| Sched<[WriteVFMergeV_MX, ReadVFMergeV_MX, ReadVFMergeF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoBinaryV_IM<LMULInfo m, bit CarryOut = 0, bit CarryIn = 1, |
| string Constraint = ""> { |
| def "_VI" # !if(CarryIn, "M", "") # "_" # m.MX : |
| VPseudoBinaryCarryIn<!if(CarryOut, VR, |
| !if(!and(CarryIn, !not(CarryOut)), |
| GetVRegNoV0<m.vrclass>.R, m.vrclass)), |
| m.vrclass, simm5, m, CarryIn, Constraint>; |
| } |
| |
| multiclass VPseudoTiedBinaryV_IM<LMULInfo m> { |
| def "_VIM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, simm5, m, 1, "">; |
| } |
| |
| multiclass VPseudoUnaryVMV_V_X_I { |
| foreach m = MxList in { |
| let VLMul = m.value in { |
| defvar mx = m.MX; |
| defvar WriteVIMovV_MX = !cast<SchedWrite>("WriteVIMovV_" # mx); |
| defvar WriteVIMovX_MX = !cast<SchedWrite>("WriteVIMovX_" # mx); |
| defvar WriteVIMovI_MX = !cast<SchedWrite>("WriteVIMovI_" # mx); |
| defvar ReadVIMovV_MX = !cast<SchedRead>("ReadVIMovV_" # mx); |
| defvar ReadVIMovX_MX = !cast<SchedRead>("ReadVIMovX_" # mx); |
| |
| let VLMul = m.value in { |
| def "_V_" # mx : VPseudoUnaryNoMask<m.vrclass, m.vrclass>, |
| Sched<[WriteVIMovV_MX, ReadVIMovV_MX]>; |
| def "_X_" # mx : VPseudoUnaryNoMask<m.vrclass, GPR>, |
| Sched<[WriteVIMovX_MX, ReadVIMovX_MX]>; |
| def "_I_" # mx : VPseudoUnaryNoMask<m.vrclass, simm5>, |
| Sched<[WriteVIMovI_MX]>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoVMV_F { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMovV_MX = !cast<SchedWrite>("WriteVFMovV_" # mx); |
| defvar ReadVFMovF_MX = !cast<SchedRead>("ReadVFMovF_" # mx); |
| |
| let VLMul = m.value in { |
| def "_" # f.FX # "_" # mx : |
| VPseudoUnaryNoMask<m.vrclass, f.fprclass>, |
| Sched<[WriteVFMovV_MX, ReadVFMovF_MX]>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoVCLS_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFClassV_MX = !cast<SchedWrite>("WriteVFClassV_" # mx); |
| defvar ReadVFClassV_MX = !cast<SchedRead>("ReadVFClassV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_V_" # mx : VPseudoUnaryNoMask<m.vrclass, m.vrclass>, |
| Sched<[WriteVFClassV_MX, ReadVFClassV_MX, ReadVMask]>; |
| def "_V_" # mx # "_MASK" : VPseudoUnaryMask<m.vrclass, m.vrclass>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVFClassV_MX, ReadVFClassV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVSQR_V_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar sews = SchedSEWSet<m.MX, isF=1>.val; |
| |
| let VLMul = m.value in |
| foreach e = sews in { |
| defvar suffix = "_" # mx # "_E" # e; |
| defvar WriteVFSqrtV_MX_E = !cast<SchedWrite>("WriteVFSqrtV" # suffix); |
| defvar ReadVFSqrtV_MX_E = !cast<SchedRead>("ReadVFSqrtV" # suffix); |
| |
| let SEW = e in { |
| def "_V" # suffix : VPseudoUnaryNoMaskRoundingMode<m.vrclass, m.vrclass>, |
| Sched<[WriteVFSqrtV_MX_E, ReadVFSqrtV_MX_E, |
| ReadVMask]>; |
| def "_V" # suffix # "_MASK" : VPseudoUnaryMaskRoundingMode<m.vrclass, m.vrclass>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVFSqrtV_MX_E, ReadVFSqrtV_MX_E, |
| ReadVMask]>; |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoVRCP_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFRecpV_MX = !cast<SchedWrite>("WriteVFRecpV_" # mx); |
| defvar ReadVFRecpV_MX = !cast<SchedRead>("ReadVFRecpV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_V_" # mx : VPseudoUnaryNoMask<m.vrclass, m.vrclass>, |
| Sched<[WriteVFRecpV_MX, ReadVFRecpV_MX, ReadVMask]>; |
| def "_V_" # mx # "_MASK" : VPseudoUnaryMask<m.vrclass, m.vrclass>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVFRecpV_MX, ReadVFRecpV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVRCP_V_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFRecpV_MX = !cast<SchedWrite>("WriteVFRecpV_" # mx); |
| defvar ReadVFRecpV_MX = !cast<SchedRead>("ReadVFRecpV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_V_" # mx : VPseudoUnaryNoMaskRoundingMode<m.vrclass, m.vrclass>, |
| Sched<[WriteVFRecpV_MX, ReadVFRecpV_MX, ReadVMask]>; |
| def "_V_" # mx # "_MASK" : VPseudoUnaryMaskRoundingMode<m.vrclass, m.vrclass>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVFRecpV_MX, ReadVFRecpV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass PseudoVEXT_VF2 { |
| defvar constraints = "@earlyclobber $rd"; |
| foreach m = MxListVF2 in { |
| defvar mx = m.MX; |
| defvar WriteVExtV_MX = !cast<SchedWrite>("WriteVExtV_" # mx); |
| defvar ReadVExtV_MX = !cast<SchedRead>("ReadVExtV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_" # mx : VPseudoUnaryNoMask<m.vrclass, m.f2vrclass, constraints>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| def "_" # mx # "_MASK" : |
| VPseudoUnaryMask<m.vrclass, m.f2vrclass, constraints>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass PseudoVEXT_VF4 { |
| defvar constraints = "@earlyclobber $rd"; |
| foreach m = MxListVF4 in { |
| defvar mx = m.MX; |
| defvar WriteVExtV_MX = !cast<SchedWrite>("WriteVExtV_" # mx); |
| defvar ReadVExtV_MX = !cast<SchedRead>("ReadVExtV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_" # mx : VPseudoUnaryNoMask<m.vrclass, m.f4vrclass, constraints>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| def "_" # mx # "_MASK" : |
| VPseudoUnaryMask<m.vrclass, m.f4vrclass, constraints>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass PseudoVEXT_VF8 { |
| defvar constraints = "@earlyclobber $rd"; |
| foreach m = MxListVF8 in { |
| defvar mx = m.MX; |
| defvar WriteVExtV_MX = !cast<SchedWrite>("WriteVExtV_" # mx); |
| defvar ReadVExtV_MX = !cast<SchedRead>("ReadVExtV_" # mx); |
| |
| let VLMul = m.value in { |
| def "_" # mx : VPseudoUnaryNoMask<m.vrclass, m.f8vrclass, constraints>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| def "_" # mx # "_MASK" : |
| VPseudoUnaryMask<m.vrclass, m.f8vrclass, constraints>, |
| RISCVMaskedPseudo<MaskIdx=2>, |
| Sched<[WriteVExtV_MX, ReadVExtV_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| // The destination EEW is 1 since "For the purposes of register group overlap |
| // constraints, mask elements have EEW=1." |
| // The source EEW is 8, 16, 32, or 64. |
| // When the destination EEW is different from source EEW, we need to use |
| // @earlyclobber to avoid the overlap between destination and source registers. |
| // We don't need @earlyclobber for LMUL<=1 since that matches this overlap |
| // exception from the spec |
| // "The destination EEW is smaller than the source EEW and the overlap is in the |
| // lowest-numbered part of the source register group". |
| // With LMUL<=1 the source and dest occupy a single register so any overlap |
| // is in the lowest-numbered part. |
| multiclass VPseudoBinaryM_VV<LMULInfo m> { |
| defm _VV : VPseudoBinaryM<VR, m.vrclass, m.vrclass, m, |
| !if(!ge(m.octuple, 16), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryM_VX<LMULInfo m> { |
| defm "_VX" : |
| VPseudoBinaryM<VR, m.vrclass, GPR, m, |
| !if(!ge(m.octuple, 16), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryM_VF<LMULInfo m, FPR_Info f> { |
| defm "_V" # f.FX : |
| VPseudoBinaryM<VR, m.vrclass, f.fprclass, m, |
| !if(!ge(m.octuple, 16), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoBinaryM_VI<LMULInfo m> { |
| defm _VI : VPseudoBinaryM<VR, m.vrclass, simm5, m, |
| !if(!ge(m.octuple, 16), "@earlyclobber $rd", "")>; |
| } |
| |
| multiclass VPseudoVGTR_VV_VX_VI<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVRGatherVX_MX = !cast<SchedWrite>("WriteVRGatherVX_" # mx); |
| defvar WriteVRGatherVI_MX = !cast<SchedWrite>("WriteVRGatherVI_" # mx); |
| defvar ReadVRGatherVX_data_MX = !cast<SchedRead>("ReadVRGatherVX_data_" # mx); |
| defvar ReadVRGatherVX_index_MX = !cast<SchedRead>("ReadVRGatherVX_index_" # mx); |
| defvar ReadVRGatherVI_data_MX = !cast<SchedRead>("ReadVRGatherVI_data_" # mx); |
| |
| defm "" : VPseudoBinaryV_VX<m, Constraint>, |
| Sched<[WriteVRGatherVX_MX, ReadVRGatherVX_data_MX, |
| ReadVRGatherVX_index_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI<ImmType, m, Constraint>, |
| Sched<[WriteVRGatherVI_MX, ReadVRGatherVI_data_MX, ReadVMask]>; |
| |
| defvar sews = SchedSEWSet<mx>.val; |
| foreach e = sews in { |
| defvar WriteVRGatherVV_MX_E = !cast<SchedWrite>("WriteVRGatherVV_" # mx # "_E" # e); |
| defvar ReadVRGatherVV_data_MX_E = !cast<SchedRead>("ReadVRGatherVV_data_" # mx # "_E" # e); |
| defvar ReadVRGatherVV_index_MX_E = !cast<SchedRead>("ReadVRGatherVV_index_" # mx # "_E" # e); |
| defm "" : VPseudoBinaryV_VV<m, Constraint, e>, |
| Sched<[WriteVRGatherVV_MX_E, ReadVRGatherVV_data_MX_E, |
| ReadVRGatherVV_index_MX_E, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVSALU_VV_VX_VI<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVSALUV_MX = !cast<SchedWrite>("WriteVSALUV_" # mx); |
| defvar WriteVSALUX_MX = !cast<SchedWrite>("WriteVSALUX_" # mx); |
| defvar WriteVSALUI_MX = !cast<SchedWrite>("WriteVSALUI_" # mx); |
| defvar ReadVSALUV_MX = !cast<SchedRead>("ReadVSALUV_" # mx); |
| defvar ReadVSALUX_MX = !cast<SchedRead>("ReadVSALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m, Constraint>, |
| Sched<[WriteVSALUV_MX, ReadVSALUV_MX, ReadVSALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m, Constraint>, |
| Sched<[WriteVSALUX_MX, ReadVSALUV_MX, ReadVSALUX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI<ImmType, m, Constraint>, |
| Sched<[WriteVSALUI_MX, ReadVSALUV_MX, ReadVMask]>; |
| } |
| } |
| |
| |
| multiclass VPseudoVSHT_VV_VX_VI<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVShiftV_MX = !cast<SchedWrite>("WriteVShiftV_" # mx); |
| defvar WriteVShiftX_MX = !cast<SchedWrite>("WriteVShiftX_" # mx); |
| defvar WriteVShiftI_MX = !cast<SchedWrite>("WriteVShiftI_" # mx); |
| defvar ReadVShiftV_MX = !cast<SchedRead>("ReadVShiftV_" # mx); |
| defvar ReadVShiftX_MX = !cast<SchedRead>("ReadVShiftX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m, Constraint>, |
| Sched<[WriteVShiftV_MX, ReadVShiftV_MX, ReadVShiftV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m, Constraint>, |
| Sched<[WriteVShiftX_MX, ReadVShiftV_MX, ReadVShiftX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI<ImmType, m, Constraint>, |
| Sched<[WriteVShiftI_MX, ReadVShiftV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVSSHT_VV_VX_VI_RM<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVSShiftV_MX = !cast<SchedWrite>("WriteVSShiftV_" # mx); |
| defvar WriteVSShiftX_MX = !cast<SchedWrite>("WriteVSShiftX_" # mx); |
| defvar WriteVSShiftI_MX = !cast<SchedWrite>("WriteVSShiftI_" # mx); |
| defvar ReadVSShiftV_MX = !cast<SchedRead>("ReadVSShiftV_" # mx); |
| defvar ReadVSShiftX_MX = !cast<SchedRead>("ReadVSShiftX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV_RM<m, Constraint>, |
| Sched<[WriteVSShiftV_MX, ReadVSShiftV_MX, ReadVSShiftV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX_RM<m, Constraint>, |
| Sched<[WriteVSShiftX_MX, ReadVSShiftV_MX, ReadVSShiftX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI_RM<ImmType, m, Constraint>, |
| Sched<[WriteVSShiftI_MX, ReadVSShiftV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVALU_VV_VX_VI<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIALUV_MX = !cast<SchedWrite>("WriteVIALUV_" # mx); |
| defvar WriteVIALUX_MX = !cast<SchedWrite>("WriteVIALUX_" # mx); |
| defvar WriteVIALUI_MX = !cast<SchedWrite>("WriteVIALUI_" # mx); |
| defvar ReadVIALUV_MX = !cast<SchedRead>("ReadVIALUV_" # mx); |
| defvar ReadVIALUX_MX = !cast<SchedRead>("ReadVIALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m, Constraint>, |
| Sched<[WriteVIALUV_MX, ReadVIALUV_MX, ReadVIALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m, Constraint>, |
| Sched<[WriteVIALUX_MX, ReadVIALUV_MX, ReadVIALUX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI<ImmType, m, Constraint>, |
| Sched<[WriteVIALUI_MX, ReadVIALUV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVSALU_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVSALUV_MX = !cast<SchedWrite>("WriteVSALUV_" # mx); |
| defvar WriteVSALUX_MX = !cast<SchedWrite>("WriteVSALUX_" # mx); |
| defvar ReadVSALUV_MX = !cast<SchedRead>("ReadVSALUV_" # mx); |
| defvar ReadVSALUX_MX = !cast<SchedRead>("ReadVSALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m>, |
| Sched<[WriteVSALUV_MX, ReadVSALUV_MX, ReadVSALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m>, |
| Sched<[WriteVSALUX_MX, ReadVSALUV_MX, ReadVSALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVSMUL_VV_VX_RM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVSMulV_MX = !cast<SchedWrite>("WriteVSMulV_" # mx); |
| defvar WriteVSMulX_MX = !cast<SchedWrite>("WriteVSMulX_" # mx); |
| defvar ReadVSMulV_MX = !cast<SchedRead>("ReadVSMulV_" # mx); |
| defvar ReadVSMulX_MX = !cast<SchedRead>("ReadVSMulX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV_RM<m>, |
| Sched<[WriteVSMulV_MX, ReadVSMulV_MX, ReadVSMulV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX_RM<m>, |
| Sched<[WriteVSMulX_MX, ReadVSMulV_MX, ReadVSMulX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVAALU_VV_VX_RM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVAALUV_MX = !cast<SchedWrite>("WriteVAALUV_" # mx); |
| defvar WriteVAALUX_MX = !cast<SchedWrite>("WriteVAALUX_" # mx); |
| defvar ReadVAALUV_MX = !cast<SchedRead>("ReadVAALUV_" # mx); |
| defvar ReadVAALUX_MX = !cast<SchedRead>("ReadVAALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV_RM<m>, |
| Sched<[WriteVAALUV_MX, ReadVAALUV_MX, ReadVAALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX_RM<m>, |
| Sched<[WriteVAALUX_MX, ReadVAALUV_MX, ReadVAALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVMINMAX_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIMinMaxV_MX = !cast<SchedWrite>("WriteVIMinMaxV_" # mx); |
| defvar WriteVIMinMaxX_MX = !cast<SchedWrite>("WriteVIMinMaxX_" # mx); |
| defvar ReadVIMinMaxV_MX = !cast<SchedRead>("ReadVIMinMaxV_" # mx); |
| defvar ReadVIMinMaxX_MX = !cast<SchedRead>("ReadVIMinMaxX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m>, |
| Sched<[WriteVIMinMaxV_MX, ReadVIMinMaxV_MX, ReadVIMinMaxV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m>, |
| Sched<[WriteVIMinMaxX_MX, ReadVIMinMaxV_MX, ReadVIMinMaxX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVMUL_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIMulV_MX = !cast<SchedWrite>("WriteVIMulV_" # mx); |
| defvar WriteVIMulX_MX = !cast<SchedWrite>("WriteVIMulX_" # mx); |
| defvar ReadVIMulV_MX = !cast<SchedRead>("ReadVIMulV_" # mx); |
| defvar ReadVIMulX_MX = !cast<SchedRead>("ReadVIMulX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m>, |
| Sched<[WriteVIMulV_MX, ReadVIMulV_MX, ReadVIMulV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m>, |
| Sched<[WriteVIMulX_MX, ReadVIMulV_MX, ReadVIMulX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVDIV_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar sews = SchedSEWSet<mx>.val; |
| foreach e = sews in { |
| defvar WriteVIDivV_MX_E = !cast<SchedWrite>("WriteVIDivV_" # mx # "_E" # e); |
| defvar WriteVIDivX_MX_E = !cast<SchedWrite>("WriteVIDivX_" # mx # "_E" # e); |
| defvar ReadVIDivV_MX_E = !cast<SchedRead>("ReadVIDivV_" # mx # "_E" # e); |
| defvar ReadVIDivX_MX_E = !cast<SchedRead>("ReadVIDivX_" # mx # "_E" # e); |
| |
| defm "" : VPseudoBinaryV_VV<m, "", e>, |
| Sched<[WriteVIDivV_MX_E, ReadVIDivV_MX_E, ReadVIDivV_MX_E, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m, "", e>, |
| Sched<[WriteVIDivX_MX_E, ReadVIDivV_MX_E, ReadVIDivX_MX_E, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFMUL_VV_VF_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFMulV_MX = !cast<SchedWrite>("WriteVFMulV_" # mx); |
| defvar ReadVFMulV_MX = !cast<SchedRead>("ReadVFMulV_" # mx); |
| |
| defm "" : VPseudoBinaryFV_VV_RM<m>, |
| Sched<[WriteVFMulV_MX, ReadVFMulV_MX, ReadVFMulV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMulF_MX = !cast<SchedWrite>("WriteVFMulF_" # mx); |
| defvar ReadVFMulV_MX = !cast<SchedRead>("ReadVFMulV_" # mx); |
| defvar ReadVFMulF_MX = !cast<SchedRead>("ReadVFMulF_" # mx); |
| |
| defm "" : VPseudoBinaryV_VF_RM<m, f>, |
| Sched<[WriteVFMulF_MX, ReadVFMulV_MX, ReadVFMulF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFDIV_VV_VF_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar sews = SchedSEWSet<mx, isF=1>.val; |
| foreach e = sews in { |
| defvar WriteVFDivV_MX_E = !cast<SchedWrite>("WriteVFDivV_" # mx # "_E" # e); |
| defvar ReadVFDivV_MX_E = !cast<SchedRead>("ReadVFDivV_" # mx # "_E" # e); |
| |
| defm "" : VPseudoBinaryFV_VV_RM<m, "", e>, |
| Sched<[WriteVFDivV_MX_E, ReadVFDivV_MX_E, ReadVFDivV_MX_E, ReadVMask]>; |
| } |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFDivF_MX_E = !cast<SchedWrite>("WriteVFDivF_" # mx # "_E" # f.SEW); |
| defvar ReadVFDivV_MX_E = !cast<SchedRead>("ReadVFDivV_" # mx # "_E" # f.SEW); |
| defvar ReadVFDivF_MX_E = !cast<SchedRead>("ReadVFDivF_" # mx # "_E" # f.SEW); |
| |
| defm "" : VPseudoBinaryV_VF_RM<m, f, "", f.SEW>, |
| Sched<[WriteVFDivF_MX_E, ReadVFDivV_MX_E, ReadVFDivF_MX_E, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFRDIV_VF_RM { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFDivF_MX_E = !cast<SchedWrite>("WriteVFDivF_" # mx # "_E" # f.SEW); |
| defvar ReadVFDivV_MX_E = !cast<SchedRead>("ReadVFDivV_" # mx # "_E" # f.SEW); |
| defvar ReadVFDivF_MX_E = !cast<SchedRead>("ReadVFDivF_" # mx # "_E" # f.SEW); |
| |
| defm "" : VPseudoBinaryV_VF_RM<m, f, "", f.SEW>, |
| Sched<[WriteVFDivF_MX_E, ReadVFDivV_MX_E, ReadVFDivF_MX_E, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIALUV_MX = !cast<SchedWrite>("WriteVIALUV_" # mx); |
| defvar WriteVIALUX_MX = !cast<SchedWrite>("WriteVIALUV_" # mx); |
| defvar ReadVIALUV_MX = !cast<SchedRead>("ReadVIALUV_" # mx); |
| defvar ReadVIALUX_MX = !cast<SchedRead>("ReadVIALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VV<m>, |
| Sched<[WriteVIALUV_MX, ReadVIALUV_MX, ReadVIALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VX<m>, |
| Sched<[WriteVIALUX_MX, ReadVIALUV_MX, ReadVIALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVSGNJ_VV_VF { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFSgnjV_MX = !cast<SchedWrite>("WriteVFSgnjV_" # mx); |
| defvar ReadVFSgnjV_MX = !cast<SchedRead>("ReadVFSgnjV_" # mx); |
| |
| defm "" : VPseudoBinaryFV_VV<m>, |
| Sched<[WriteVFSgnjV_MX, ReadVFSgnjV_MX, ReadVFSgnjV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFSgnjF_MX = !cast<SchedWrite>("WriteVFSgnjF_" # mx); |
| defvar ReadVFSgnjV_MX = !cast<SchedRead>("ReadVFSgnjV_" # mx); |
| defvar ReadVFSgnjF_MX = !cast<SchedRead>("ReadVFSgnjF_" # mx); |
| |
| defm "" : VPseudoBinaryV_VF<m, f>, |
| Sched<[WriteVFSgnjF_MX, ReadVFSgnjV_MX, ReadVFSgnjF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVMAX_VV_VF { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFMinMaxV_MX = !cast<SchedWrite>("WriteVFMinMaxV_" # mx); |
| defvar ReadVFMinMaxV_MX = !cast<SchedRead>("ReadVFMinMaxV_" # mx); |
| |
| defm "" : VPseudoBinaryFV_VV<m>, |
| Sched<[WriteVFMinMaxV_MX, ReadVFMinMaxV_MX, ReadVFMinMaxV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMinMaxF_MX = !cast<SchedWrite>("WriteVFMinMaxF_" # mx); |
| defvar ReadVFMinMaxV_MX = !cast<SchedRead>("ReadVFMinMaxV_" # mx); |
| defvar ReadVFMinMaxF_MX = !cast<SchedRead>("ReadVFMinMaxF_" # mx); |
| |
| defm "" : VPseudoBinaryV_VF<m, f>, |
| Sched<[WriteVFMinMaxF_MX, ReadVFMinMaxV_MX, ReadVFMinMaxF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VV_VF { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFALUV_MX = !cast<SchedWrite>("WriteVFALUV_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| |
| defm "" : VPseudoBinaryFV_VV<m>, |
| Sched<[WriteVFALUV_MX, ReadVFALUV_MX, ReadVFALUV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFALUF_MX = !cast<SchedWrite>("WriteVFALUF_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| defvar ReadVFALUF_MX = !cast<SchedRead>("ReadVFALUF_" # mx); |
| defm "" : VPseudoBinaryV_VF<m, f>, |
| Sched<[WriteVFALUF_MX, ReadVFALUV_MX, ReadVFALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VV_VF_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFALUV_MX = !cast<SchedWrite>("WriteVFALUV_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| |
| defm "" : VPseudoBinaryFV_VV_RM<m>, |
| Sched<[WriteVFALUV_MX, ReadVFALUV_MX, ReadVFALUV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFALUF_MX = !cast<SchedWrite>("WriteVFALUF_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| defvar ReadVFALUF_MX = !cast<SchedRead>("ReadVFALUF_" # mx); |
| defm "" : VPseudoBinaryV_VF_RM<m, f>, |
| Sched<[WriteVFALUF_MX, ReadVFALUV_MX, ReadVFALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VF { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFALUF_MX = !cast<SchedWrite>("WriteVFALUF_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| defvar ReadVFALUF_MX = !cast<SchedRead>("ReadVFALUF_" # mx); |
| |
| defm "" : VPseudoBinaryV_VF<m, f>, |
| Sched<[WriteVFALUF_MX, ReadVFALUV_MX, ReadVFALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VF_RM { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFALUF_MX = !cast<SchedWrite>("WriteVFALUF_" # mx); |
| defvar ReadVFALUV_MX = !cast<SchedRead>("ReadVFALUV_" # mx); |
| defvar ReadVFALUF_MX = !cast<SchedRead>("ReadVFALUF_" # mx); |
| |
| defm "" : VPseudoBinaryV_VF_RM<m, f>, |
| Sched<[WriteVFALUF_MX, ReadVFALUV_MX, ReadVFALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVALU_VX_VI<Operand ImmType = simm5> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIALUX_MX = !cast<SchedWrite>("WriteVIALUX_" # mx); |
| defvar WriteVIALUI_MX = !cast<SchedWrite>("WriteVIALUI_" # mx); |
| defvar ReadVIALUV_MX = !cast<SchedRead>("ReadVIALUV_" # mx); |
| defvar ReadVIALUX_MX = !cast<SchedRead>("ReadVIALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VX<m>, |
| Sched<[WriteVIALUX_MX, ReadVIALUV_MX, ReadVIALUX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_VI<ImmType, m>, |
| Sched<[WriteVIALUI_MX, ReadVIALUV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWALU_VV_VX { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVIWALUV_MX = !cast<SchedWrite>("WriteVIWALUV_" # mx); |
| defvar WriteVIWALUX_MX = !cast<SchedWrite>("WriteVIWALUX_" # mx); |
| defvar ReadVIWALUV_MX = !cast<SchedRead>("ReadVIWALUV_" # mx); |
| defvar ReadVIWALUX_MX = !cast<SchedRead>("ReadVIWALUX_" # mx); |
| |
| defm "" : VPseudoBinaryW_VV<m>, |
| Sched<[WriteVIWALUV_MX, ReadVIWALUV_MX, ReadVIWALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryW_VX<m>, |
| Sched<[WriteVIWALUX_MX, ReadVIWALUV_MX, ReadVIWALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWMUL_VV_VX { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVIWMulV_MX = !cast<SchedWrite>("WriteVIWMulV_" # mx); |
| defvar WriteVIWMulX_MX = !cast<SchedWrite>("WriteVIWMulX_" # mx); |
| defvar ReadVIWMulV_MX = !cast<SchedRead>("ReadVIWMulV_" # mx); |
| defvar ReadVIWMulX_MX = !cast<SchedRead>("ReadVIWMulX_" # mx); |
| |
| defm "" : VPseudoBinaryW_VV<m>, |
| Sched<[WriteVIWMulV_MX, ReadVIWMulV_MX, ReadVIWMulV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryW_VX<m>, |
| Sched<[WriteVIWMulX_MX, ReadVIWMulV_MX, ReadVIWMulX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWMUL_VV_VF_RM { |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWMulV_MX = !cast<SchedWrite>("WriteVFWMulV_" # mx); |
| defvar ReadVFWMulV_MX = !cast<SchedRead>("ReadVFWMulV_" # mx); |
| |
| defm "" : VPseudoBinaryW_VV_RM<m>, |
| Sched<[WriteVFWMulV_MX, ReadVFWMulV_MX, ReadVFWMulV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPListW in { |
| foreach m = f.MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWMulF_MX = !cast<SchedWrite>("WriteVFWMulF_" # mx); |
| defvar ReadVFWMulV_MX = !cast<SchedRead>("ReadVFWMulV_" # mx); |
| defvar ReadVFWMulF_MX = !cast<SchedRead>("ReadVFWMulF_" # mx); |
| |
| defm "" : VPseudoBinaryW_VF_RM<m, f>, |
| Sched<[WriteVFWMulF_MX, ReadVFWMulV_MX, ReadVFWMulF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVWALU_WV_WX { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVIWALUV_MX = !cast<SchedWrite>("WriteVIWALUV_" # mx); |
| defvar WriteVIWALUX_MX = !cast<SchedWrite>("WriteVIWALUX_" # mx); |
| defvar ReadVIWALUV_MX = !cast<SchedRead>("ReadVIWALUV_" # mx); |
| defvar ReadVIWALUX_MX = !cast<SchedRead>("ReadVIWALUX_" # mx); |
| |
| defm "" : VPseudoBinaryW_WV<m>, |
| Sched<[WriteVIWALUV_MX, ReadVIWALUV_MX, ReadVIWALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryW_WX<m>, |
| Sched<[WriteVIWALUX_MX, ReadVIWALUV_MX, ReadVIWALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVFWALU_VV_VF_RM { |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWALUV_MX = !cast<SchedWrite>("WriteVFWALUV_" # mx); |
| defvar ReadVFWALUV_MX = !cast<SchedRead>("ReadVFWALUV_" # mx); |
| |
| defm "" : VPseudoBinaryW_VV_RM<m>, |
| Sched<[WriteVFWALUV_MX, ReadVFWALUV_MX, ReadVFWALUV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPListW in { |
| foreach m = f.MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWALUF_MX = !cast<SchedWrite>("WriteVFWALUF_" # mx); |
| defvar ReadVFWALUV_MX = !cast<SchedRead>("ReadVFWALUV_" # mx); |
| defvar ReadVFWALUF_MX = !cast<SchedRead>("ReadVFWALUF_" # mx); |
| |
| defm "" : VPseudoBinaryW_VF_RM<m, f>, |
| Sched<[WriteVFWALUF_MX, ReadVFWALUV_MX, ReadVFWALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFWALU_WV_WF_RM { |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWALUV_MX = !cast<SchedWrite>("WriteVFWALUV_" # mx); |
| defvar ReadVFWALUV_MX = !cast<SchedRead>("ReadVFWALUV_" # mx); |
| |
| defm "" : VPseudoBinaryW_WV_RM<m>, |
| Sched<[WriteVFWALUV_MX, ReadVFWALUV_MX, ReadVFWALUV_MX, ReadVMask]>; |
| } |
| foreach f = FPListW in { |
| foreach m = f.MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWALUF_MX = !cast<SchedWrite>("WriteVFWALUF_" # mx); |
| defvar ReadVFWALUV_MX = !cast<SchedRead>("ReadVFWALUV_" # mx); |
| defvar ReadVFWALUF_MX = !cast<SchedRead>("ReadVFWALUF_" # mx); |
| |
| defm "" : VPseudoBinaryW_WF_RM<m, f>, |
| Sched<[WriteVFWALUF_MX, ReadVFWALUV_MX, ReadVFWALUF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVMRG_VM_XM_IM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIMergeV_MX = !cast<SchedWrite>("WriteVIMergeV_" # mx); |
| defvar WriteVIMergeX_MX = !cast<SchedWrite>("WriteVIMergeX_" # mx); |
| defvar WriteVIMergeI_MX = !cast<SchedWrite>("WriteVIMergeI_" # mx); |
| defvar ReadVIMergeV_MX = !cast<SchedRead>("ReadVIMergeV_" # mx); |
| defvar ReadVIMergeX_MX = !cast<SchedRead>("ReadVIMergeX_" # mx); |
| |
| def "_VVM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, m.vrclass, m, 1, "">, |
| Sched<[WriteVIMergeV_MX, ReadVIMergeV_MX, ReadVIMergeV_MX, ReadVMask]>; |
| def "_VXM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, GPR, m, 1, "">, |
| Sched<[WriteVIMergeX_MX, ReadVIMergeV_MX, ReadVIMergeX_MX, ReadVMask]>; |
| def "_VIM" # "_" # m.MX: |
| VPseudoTiedBinaryCarryIn<GetVRegNoV0<m.vrclass>.R, |
| m.vrclass, simm5, m, 1, "">, |
| Sched<[WriteVIMergeI_MX, ReadVIMergeV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCALU_VM_XM_IM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar WriteVICALUI_MX = !cast<SchedWrite>("WriteVICALUI_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoTiedBinaryV_VM<m>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX, ReadVMask]>; |
| defm "" : VPseudoTiedBinaryV_XM<m>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX, ReadVMask]>; |
| defm "" : VPseudoTiedBinaryV_IM<m>, |
| Sched<[WriteVICALUI_MX, ReadVICALUV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCALU_VM_XM { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoTiedBinaryV_VM<m>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX, ReadVMask]>; |
| defm "" : VPseudoTiedBinaryV_XM<m>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCALUM_VM_XM_IM<string Constraint> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar WriteVICALUI_MX = !cast<SchedWrite>("WriteVICALUI_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VM<m, CarryOut=1, CarryIn=1, Constraint=Constraint>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_XM<m, CarryOut=1, CarryIn=1, Constraint=Constraint>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_IM<m, CarryOut=1, CarryIn=1, Constraint=Constraint>, |
| Sched<[WriteVICALUI_MX, ReadVICALUV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCALUM_VM_XM<string Constraint> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VM<m, CarryOut=1, CarryIn=1, Constraint=Constraint>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_XM<m, CarryOut=1, CarryIn=1, Constraint=Constraint>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCALUM_V_X_I<string Constraint> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar WriteVICALUI_MX = !cast<SchedWrite>("WriteVICALUI_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VM<m, CarryOut=1, CarryIn=0, Constraint=Constraint>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX]>; |
| defm "" : VPseudoBinaryV_XM<m, CarryOut=1, CarryIn=0, Constraint=Constraint>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX]>; |
| defm "" : VPseudoBinaryV_IM<m, CarryOut=1, CarryIn=0, Constraint=Constraint>, |
| Sched<[WriteVICALUI_MX, ReadVICALUV_MX]>; |
| } |
| } |
| |
| multiclass VPseudoVCALUM_V_X<string Constraint> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICALUV_MX = !cast<SchedWrite>("WriteVICALUV_" # mx); |
| defvar WriteVICALUX_MX = !cast<SchedWrite>("WriteVICALUX_" # mx); |
| defvar ReadVICALUV_MX = !cast<SchedRead>("ReadVICALUV_" # mx); |
| defvar ReadVICALUX_MX = !cast<SchedRead>("ReadVICALUX_" # mx); |
| |
| defm "" : VPseudoBinaryV_VM<m, CarryOut=1, CarryIn=0, Constraint=Constraint>, |
| Sched<[WriteVICALUV_MX, ReadVICALUV_MX, ReadVICALUV_MX]>; |
| defm "" : VPseudoBinaryV_XM<m, CarryOut=1, CarryIn=0, Constraint=Constraint>, |
| Sched<[WriteVICALUX_MX, ReadVICALUV_MX, ReadVICALUX_MX]>; |
| } |
| } |
| |
| multiclass VPseudoVNCLP_WV_WX_WI_RM { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVNClipV_MX = !cast<SchedWrite>("WriteVNClipV_" # mx); |
| defvar WriteVNClipX_MX = !cast<SchedWrite>("WriteVNClipX_" # mx); |
| defvar WriteVNClipI_MX = !cast<SchedWrite>("WriteVNClipI_" # mx); |
| defvar ReadVNClipV_MX = !cast<SchedRead>("ReadVNClipV_" # mx); |
| defvar ReadVNClipX_MX = !cast<SchedRead>("ReadVNClipX_" # mx); |
| |
| defm "" : VPseudoBinaryV_WV_RM<m>, |
| Sched<[WriteVNClipV_MX, ReadVNClipV_MX, ReadVNClipV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_WX_RM<m>, |
| Sched<[WriteVNClipX_MX, ReadVNClipV_MX, ReadVNClipX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_WI_RM<m>, |
| Sched<[WriteVNClipI_MX, ReadVNClipV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNSHT_WV_WX_WI { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVNShiftV_MX = !cast<SchedWrite>("WriteVNShiftV_" # mx); |
| defvar WriteVNShiftX_MX = !cast<SchedWrite>("WriteVNShiftX_" # mx); |
| defvar WriteVNShiftI_MX = !cast<SchedWrite>("WriteVNShiftI_" # mx); |
| defvar ReadVNShiftV_MX = !cast<SchedRead>("ReadVNShiftV_" # mx); |
| defvar ReadVNShiftX_MX = !cast<SchedRead>("ReadVNShiftX_" # mx); |
| |
| defm "" : VPseudoBinaryV_WV<m>, |
| Sched<[WriteVNShiftV_MX, ReadVNShiftV_MX, ReadVNShiftV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_WX<m>, |
| Sched<[WriteVNShiftX_MX, ReadVNShiftV_MX, ReadVNShiftX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryV_WI<m>, |
| Sched<[WriteVNShiftI_MX, ReadVNShiftV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoTernaryWithTailPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| int sew, |
| string Constraint = "", |
| bit Commutable = 0> { |
| let VLMul = MInfo.value in { |
| defvar mx = MInfo.MX; |
| let isCommutable = Commutable in |
| def "_" # mx # "_E" # sew : VPseudoTernaryNoMaskWithPolicy<RetClass, Op1Class, Op2Class, Constraint>; |
| def "_" # mx # "_E" # sew # "_MASK" : VPseudoTernaryMaskPolicy<RetClass, Op1Class, Op2Class, Constraint>; |
| } |
| } |
| |
| multiclass VPseudoTernaryWithTailPolicyRoundingMode<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| int sew, |
| string Constraint = "", |
| bit Commutable = 0> { |
| let VLMul = MInfo.value in { |
| defvar mx = MInfo.MX; |
| let isCommutable = Commutable in |
| def "_" # mx # "_E" # sew |
| : VPseudoTernaryNoMaskWithPolicyRoundingMode<RetClass, Op1Class, |
| Op2Class, Constraint>; |
| def "_" # mx # "_E" # sew # "_MASK" |
| : VPseudoTernaryMaskPolicyRoundingMode<RetClass, Op1Class, |
| Op2Class, Constraint>; |
| } |
| } |
| |
| multiclass VPseudoTernaryWithPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = "", |
| bit Commutable = 0> { |
| let VLMul = MInfo.value in { |
| let isCommutable = Commutable in |
| def "_" # MInfo.MX : VPseudoTernaryNoMaskWithPolicy<RetClass, Op1Class, Op2Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK" : VPseudoBinaryMaskPolicy<RetClass, Op1Class, Op2Class, Constraint>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoTernaryWithPolicyRoundingMode<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = "", |
| bit Commutable = 0> { |
| let VLMul = MInfo.value in { |
| let isCommutable = Commutable in |
| def "_" # MInfo.MX : |
| VPseudoTernaryNoMaskWithPolicyRoundingMode<RetClass, Op1Class, |
| Op2Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK" : |
| VPseudoBinaryMaskPolicyRoundingMode<RetClass, Op1Class, |
| Op2Class, Constraint, |
| UsesVXRM_=0>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoTernaryV_VV_AAXA<LMULInfo m, string Constraint = ""> { |
| defm _VV : VPseudoTernaryWithPolicy<m.vrclass, m.vrclass, m.vrclass, m, |
| Constraint, Commutable=1>; |
| } |
| |
| multiclass VPseudoTernaryV_VV_AAXA_RM<LMULInfo m, string Constraint = ""> { |
| defm _VV : VPseudoTernaryWithPolicyRoundingMode<m.vrclass, m.vrclass, m.vrclass, m, |
| Constraint, Commutable=1>; |
| } |
| |
| multiclass VPseudoTernaryV_VX_AAXA<LMULInfo m, string Constraint = ""> { |
| defm "_VX" : VPseudoTernaryWithPolicy<m.vrclass, GPR, m.vrclass, m, |
| Constraint, Commutable=1>; |
| } |
| |
| multiclass VPseudoTernaryV_VF_AAXA<LMULInfo m, FPR_Info f, string Constraint = ""> { |
| defm "_V" # f.FX : VPseudoTernaryWithPolicy<m.vrclass, f.fprclass, |
| m.vrclass, m, Constraint, |
| Commutable=1>; |
| } |
| |
| multiclass VPseudoTernaryV_VF_AAXA_RM<LMULInfo m, FPR_Info f, string Constraint = ""> { |
| defm "_V" # f.FX : VPseudoTernaryWithPolicyRoundingMode<m.vrclass, f.fprclass, |
| m.vrclass, m, Constraint, |
| Commutable=1>; |
| } |
| |
| multiclass VPseudoTernaryW_VV<LMULInfo m> { |
| defvar constraint = "@earlyclobber $rd"; |
| defm _VV : VPseudoTernaryWithPolicy<m.wvrclass, m.vrclass, m.vrclass, m, |
| constraint>; |
| } |
| |
| multiclass VPseudoTernaryW_VV_RM<LMULInfo m> { |
| defvar constraint = "@earlyclobber $rd"; |
| defm _VV : VPseudoTernaryWithPolicyRoundingMode<m.wvrclass, m.vrclass, m.vrclass, m, |
| constraint>; |
| } |
| |
| multiclass VPseudoTernaryW_VX<LMULInfo m> { |
| defvar constraint = "@earlyclobber $rd"; |
| defm "_VX" : VPseudoTernaryWithPolicy<m.wvrclass, GPR, m.vrclass, m, |
| constraint>; |
| } |
| |
| multiclass VPseudoTernaryW_VF<LMULInfo m, FPR_Info f> { |
| defvar constraint = "@earlyclobber $rd"; |
| defm "_V" # f.FX : VPseudoTernaryWithPolicy<m.wvrclass, f.fprclass, |
| m.vrclass, m, constraint>; |
| } |
| |
| multiclass VPseudoTernaryW_VF_RM<LMULInfo m, FPR_Info f> { |
| defvar constraint = "@earlyclobber $rd"; |
| defm "_V" # f.FX : VPseudoTernaryWithPolicyRoundingMode<m.wvrclass, f.fprclass, |
| m.vrclass, m, constraint>; |
| } |
| |
| multiclass VPseudoVSLDVWithPolicy<VReg RetClass, |
| RegisterClass Op1Class, |
| DAGOperand Op2Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX : VPseudoTernaryNoMaskWithPolicy<RetClass, Op1Class, Op2Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK" : VPseudoBinaryMaskPolicy<RetClass, Op1Class, Op2Class, Constraint>, |
| RISCVMaskedPseudo<MaskIdx=3>; |
| } |
| } |
| |
| multiclass VPseudoVSLDV_VX<LMULInfo m, string Constraint = ""> { |
| defm _VX : VPseudoVSLDVWithPolicy<m.vrclass, m.vrclass, GPR, m, Constraint>; |
| } |
| |
| multiclass VPseudoVSLDV_VI<Operand ImmType = simm5, LMULInfo m, string Constraint = ""> { |
| defm _VI : VPseudoVSLDVWithPolicy<m.vrclass, m.vrclass, ImmType, m, Constraint>; |
| } |
| |
| multiclass VPseudoVMAC_VV_VX_AAXA<string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVIMulAddV_MX = !cast<SchedWrite>("WriteVIMulAddV_" # mx); |
| defvar WriteVIMulAddX_MX = !cast<SchedWrite>("WriteVIMulAddX_" # mx); |
| defvar ReadVIMulAddV_MX = !cast<SchedRead>("ReadVIMulAddV_" # mx); |
| defvar ReadVIMulAddX_MX = !cast<SchedRead>("ReadVIMulAddX_" # mx); |
| |
| defm "" : VPseudoTernaryV_VV_AAXA<m, Constraint>, |
| Sched<[WriteVIMulAddV_MX, ReadVIMulAddV_MX, ReadVIMulAddV_MX, |
| ReadVIMulAddV_MX, ReadVMask]>; |
| defm "" : VPseudoTernaryV_VX_AAXA<m, Constraint>, |
| Sched<[WriteVIMulAddX_MX, ReadVIMulAddV_MX, ReadVIMulAddV_MX, |
| ReadVIMulAddX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVMAC_VV_VF_AAXA<string Constraint = ""> { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFMulAddV_MX = !cast<SchedWrite>("WriteVFMulAddV_" # mx); |
| defvar ReadVFMulAddV_MX = !cast<SchedRead>("ReadVFMulAddV_" # mx); |
| |
| defm "" : VPseudoTernaryV_VV_AAXA<m, Constraint>, |
| Sched<[WriteVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMulAddF_MX = !cast<SchedWrite>("WriteVFMulAddF_" # mx); |
| defvar ReadVFMulAddV_MX = !cast<SchedRead>("ReadVFMulAddV_" # mx); |
| defvar ReadVFMulAddF_MX = !cast<SchedRead>("ReadVFMulAddF_" # mx); |
| |
| defm "" : VPseudoTernaryV_VF_AAXA<m, f, Constraint>, |
| Sched<[WriteVFMulAddF_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVMAC_VV_VF_AAXA_RM<string Constraint = ""> { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFMulAddV_MX = !cast<SchedWrite>("WriteVFMulAddV_" # mx); |
| defvar ReadVFMulAddV_MX = !cast<SchedRead>("ReadVFMulAddV_" # mx); |
| |
| defm "" : VPseudoTernaryV_VV_AAXA_RM<m, Constraint>, |
| Sched<[WriteVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFMulAddF_MX = !cast<SchedWrite>("WriteVFMulAddF_" # mx); |
| defvar ReadVFMulAddV_MX = !cast<SchedRead>("ReadVFMulAddV_" # mx); |
| defvar ReadVFMulAddF_MX = !cast<SchedRead>("ReadVFMulAddF_" # mx); |
| |
| defm "" : VPseudoTernaryV_VF_AAXA_RM<m, f, Constraint>, |
| Sched<[WriteVFMulAddF_MX, ReadVFMulAddV_MX, ReadVFMulAddV_MX, ReadVFMulAddF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVSLD_VX_VI<Operand ImmType = simm5, string Constraint = ""> { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVISlideX_MX = !cast<SchedWrite>("WriteVISlideX_" # mx); |
| defvar WriteVISlideI_MX = !cast<SchedWrite>("WriteVISlideI_" # mx); |
| defvar ReadVISlideV_MX = !cast<SchedRead>("ReadVISlideV_" # mx); |
| defvar ReadVISlideX_MX = !cast<SchedRead>("ReadVISlideX_" # mx); |
| |
| defm "" : VPseudoVSLDV_VX<m, Constraint>, |
| Sched<[WriteVISlideX_MX, ReadVISlideV_MX, ReadVISlideV_MX, |
| ReadVISlideX_MX, ReadVMask]>; |
| defm "" : VPseudoVSLDV_VI<ImmType, m, Constraint>, |
| Sched<[WriteVISlideI_MX, ReadVISlideV_MX, ReadVISlideV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWMAC_VV_VX { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVIWMulAddV_MX = !cast<SchedWrite>("WriteVIWMulAddV_" # mx); |
| defvar WriteVIWMulAddX_MX = !cast<SchedWrite>("WriteVIWMulAddX_" # mx); |
| defvar ReadVIWMulAddV_MX = !cast<SchedRead>("ReadVIWMulAddV_" # mx); |
| defvar ReadVIWMulAddX_MX = !cast<SchedRead>("ReadVIWMulAddX_" # mx); |
| |
| defm "" : VPseudoTernaryW_VV<m>, |
| Sched<[WriteVIWMulAddV_MX, ReadVIWMulAddV_MX, ReadVIWMulAddV_MX, |
| ReadVIWMulAddV_MX, ReadVMask]>; |
| defm "" : VPseudoTernaryW_VX<m>, |
| Sched<[WriteVIWMulAddX_MX, ReadVIWMulAddV_MX, ReadVIWMulAddV_MX, |
| ReadVIWMulAddX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWMAC_VX { |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVIWMulAddX_MX = !cast<SchedWrite>("WriteVIWMulAddX_" # mx); |
| defvar ReadVIWMulAddV_MX= !cast<SchedRead>("ReadVIWMulAddV_" # mx); |
| defvar ReadVIWMulAddX_MX = !cast<SchedRead>("ReadVIWMulAddX_" # mx); |
| |
| defm "" : VPseudoTernaryW_VX<m>, |
| Sched<[WriteVIWMulAddX_MX, ReadVIWMulAddV_MX, ReadVIWMulAddV_MX, |
| ReadVIWMulAddX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWMAC_VV_VF_RM { |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWMulAddV_MX = !cast<SchedWrite>("WriteVFWMulAddV_" # mx); |
| defvar ReadVFWMulAddV_MX = !cast<SchedRead>("ReadVFWMulAddV_" # mx); |
| |
| defm "" : VPseudoTernaryW_VV_RM<m>, |
| Sched<[WriteVFWMulAddV_MX, ReadVFWMulAddV_MX, |
| ReadVFWMulAddV_MX, ReadVFWMulAddV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPListW in { |
| foreach m = f.MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWMulAddF_MX = !cast<SchedWrite>("WriteVFWMulAddF_" # mx); |
| defvar ReadVFWMulAddV_MX = !cast<SchedRead>("ReadVFWMulAddV_" # mx); |
| defvar ReadVFWMulAddF_MX = !cast<SchedRead>("ReadVFWMulAddF_" # mx); |
| |
| defm "" : VPseudoTernaryW_VF_RM<m, f>, |
| Sched<[WriteVFWMulAddF_MX, ReadVFWMulAddV_MX, |
| ReadVFWMulAddV_MX, ReadVFWMulAddF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVCMPM_VV_VX_VI { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICmpV_MX = !cast<SchedWrite>("WriteVICmpV_" # mx); |
| defvar WriteVICmpX_MX = !cast<SchedWrite>("WriteVICmpX_" # mx); |
| defvar WriteVICmpI_MX = !cast<SchedWrite>("WriteVICmpI_" # mx); |
| defvar ReadVICmpV_MX = !cast<SchedRead>("ReadVICmpV_" # mx); |
| defvar ReadVICmpX_MX = !cast<SchedRead>("ReadVICmpX_" # mx); |
| |
| defm "" : VPseudoBinaryM_VV<m>, |
| Sched<[WriteVICmpV_MX, ReadVICmpV_MX, ReadVICmpV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryM_VX<m>, |
| Sched<[WriteVICmpX_MX, ReadVICmpV_MX, ReadVICmpX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryM_VI<m>, |
| Sched<[WriteVICmpI_MX, ReadVICmpV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCMPM_VV_VX { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICmpV_MX = !cast<SchedWrite>("WriteVICmpV_" # mx); |
| defvar WriteVICmpX_MX = !cast<SchedWrite>("WriteVICmpX_" # mx); |
| defvar ReadVICmpV_MX = !cast<SchedRead>("ReadVICmpV_" # mx); |
| defvar ReadVICmpX_MX = !cast<SchedRead>("ReadVICmpX_" # mx); |
| |
| defm "" : VPseudoBinaryM_VV<m>, |
| Sched<[WriteVICmpV_MX, ReadVICmpV_MX, ReadVICmpV_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryM_VX<m>, |
| Sched<[WriteVICmpX_MX, ReadVICmpV_MX, ReadVICmpX_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCMPM_VV_VF { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCmpV_MX = !cast<SchedWrite>("WriteVFCmpV_" # mx); |
| defvar ReadVFCmpV_MX = !cast<SchedRead>("ReadVFCmpV_" # mx); |
| |
| defm "" : VPseudoBinaryM_VV<m>, |
| Sched<[WriteVFCmpV_MX, ReadVFCmpV_MX, ReadVFCmpV_MX, ReadVMask]>; |
| } |
| |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFCmpF_MX = !cast<SchedWrite>("WriteVFCmpF_" # mx); |
| defvar ReadVFCmpV_MX = !cast<SchedRead>("ReadVFCmpV_" # mx); |
| defvar ReadVFCmpF_MX = !cast<SchedRead>("ReadVFCmpF_" # mx); |
| |
| defm "" : VPseudoBinaryM_VF<m, f>, |
| Sched<[WriteVFCmpF_MX, ReadVFCmpV_MX, ReadVFCmpF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVCMPM_VF { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| defvar WriteVFCmpF_MX = !cast<SchedWrite>("WriteVFCmpF_" # mx); |
| defvar ReadVFCmpV_MX = !cast<SchedRead>("ReadVFCmpV_" # mx); |
| defvar ReadVFCmpF_MX = !cast<SchedRead>("ReadVFCmpF_" # mx); |
| |
| defm "" : VPseudoBinaryM_VF<m, f>, |
| Sched<[WriteVFCmpF_MX, ReadVFCmpV_MX, ReadVFCmpF_MX, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVCMPM_VX_VI { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| defvar WriteVICmpX_MX = !cast<SchedWrite>("WriteVICmpX_" # mx); |
| defvar WriteVICmpI_MX = !cast<SchedWrite>("WriteVICmpI_" # mx); |
| defvar ReadVICmpV_MX = !cast<SchedRead>("ReadVICmpV_" # mx); |
| defvar ReadVICmpX_MX = !cast<SchedRead>("ReadVICmpX_" # mx); |
| |
| defm "" : VPseudoBinaryM_VX<m>, |
| Sched<[WriteVICmpX_MX, ReadVICmpV_MX, ReadVICmpX_MX, ReadVMask]>; |
| defm "" : VPseudoBinaryM_VI<m>, |
| Sched<[WriteVICmpI_MX, ReadVICmpV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVRED_VS { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx>.val in { |
| defvar WriteVIRedV_From_MX_E = !cast<SchedWrite>("WriteVIRedV_From_" # mx # "_E" # e); |
| defm _VS : VPseudoTernaryWithTailPolicy<V_M1.vrclass, m.vrclass, V_M1.vrclass, m, e>, |
| Sched<[WriteVIRedV_From_MX_E, ReadVIRedV, ReadVIRedV, ReadVIRedV, |
| ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVREDMINMAX_VS { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx>.val in { |
| defvar WriteVIRedMinMaxV_From_MX_E = !cast<SchedWrite>("WriteVIRedMinMaxV_From_" # mx # "_E" # e); |
| defm _VS : VPseudoTernaryWithTailPolicy<V_M1.vrclass, m.vrclass, V_M1.vrclass, m, e>, |
| Sched<[WriteVIRedMinMaxV_From_MX_E, ReadVIRedV, ReadVIRedV, |
| ReadVIRedV, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVWRED_VS { |
| foreach m = MxListWRed in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx, isWidening=1>.val in { |
| defvar WriteVIWRedV_From_MX_E = !cast<SchedWrite>("WriteVIWRedV_From_" # mx # "_E" # e); |
| defm _VS : VPseudoTernaryWithTailPolicy<V_M1.vrclass, m.vrclass, V_M1.vrclass, m, e>, |
| Sched<[WriteVIWRedV_From_MX_E, ReadVIWRedV, ReadVIWRedV, |
| ReadVIWRedV, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFRED_VS_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx, isF=1>.val in { |
| defvar WriteVFRedV_From_MX_E = !cast<SchedWrite>("WriteVFRedV_From_" # mx # "_E" # e); |
| defm _VS |
| : VPseudoTernaryWithTailPolicyRoundingMode<V_M1.vrclass, m.vrclass, |
| V_M1.vrclass, m, e>, |
| Sched<[WriteVFRedV_From_MX_E, ReadVFRedV, ReadVFRedV, ReadVFRedV, |
| ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFREDMINMAX_VS { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx, isF=1>.val in { |
| defvar WriteVFRedMinMaxV_From_MX_E = !cast<SchedWrite>("WriteVFRedMinMaxV_From_" # mx # "_E" # e); |
| defm _VS : VPseudoTernaryWithTailPolicy<V_M1.vrclass, m.vrclass, V_M1.vrclass, m, e>, |
| Sched<[WriteVFRedMinMaxV_From_MX_E, ReadVFRedV, ReadVFRedV, ReadVFRedV, |
| ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFREDO_VS_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx, isF=1>.val in { |
| defvar WriteVFRedOV_From_MX_E = !cast<SchedWrite>("WriteVFRedOV_From_" # mx # "_E" # e); |
| defm _VS : VPseudoTernaryWithTailPolicyRoundingMode<V_M1.vrclass, m.vrclass, |
| V_M1.vrclass, m, e>, |
| Sched<[WriteVFRedOV_From_MX_E, ReadVFRedOV, ReadVFRedOV, |
| ReadVFRedOV, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoVFWRED_VS_RM { |
| foreach m = MxListFWRed in { |
| defvar mx = m.MX; |
| foreach e = SchedSEWSet<mx, isF=1, isWidening=1>.val in { |
| defvar WriteVFWRedV_From_MX_E = !cast<SchedWrite>("WriteVFWRedV_From_" # mx # "_E" # e); |
| defm _VS |
| : VPseudoTernaryWithTailPolicyRoundingMode<V_M1.vrclass, m.vrclass, |
| V_M1.vrclass, m, e>, |
| Sched<[WriteVFWRedV_From_MX_E, ReadVFWRedV, ReadVFWRedV, |
| ReadVFWRedV, ReadVMask]>; |
| } |
| } |
| } |
| |
| multiclass VPseudoConversion<VReg RetClass, |
| VReg Op1Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX : VPseudoUnaryNoMask<RetClass, Op1Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK" : VPseudoUnaryMask<RetClass, Op1Class, |
| Constraint>, |
| RISCVMaskedPseudo<MaskIdx=2>; |
| } |
| } |
| |
| multiclass VPseudoConversionRoundingMode<VReg RetClass, |
| VReg Op1Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX : VPseudoUnaryNoMaskRoundingMode<RetClass, Op1Class, Constraint>; |
| def "_" # MInfo.MX # "_MASK" : VPseudoUnaryMaskRoundingMode<RetClass, Op1Class, |
| Constraint>, |
| RISCVMaskedPseudo<MaskIdx=2>; |
| } |
| } |
| |
| |
| multiclass VPseudoConversionRM<VReg RetClass, |
| VReg Op1Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX : VPseudoUnaryNoMask_FRM<RetClass, Op1Class, |
| Constraint>; |
| def "_" # MInfo.MX # "_MASK" : VPseudoUnaryMask_FRM<RetClass, Op1Class, |
| Constraint>, |
| RISCVMaskedPseudo<MaskIdx=2>; |
| } |
| } |
| |
| multiclass VPseudoConversionNoExcept<VReg RetClass, |
| VReg Op1Class, |
| LMULInfo MInfo, |
| string Constraint = ""> { |
| let VLMul = MInfo.value in { |
| def "_" # MInfo.MX # "_MASK" : VPseudoUnaryMask_NoExcept<RetClass, Op1Class, Constraint>; |
| } |
| } |
| |
| multiclass VPseudoVCVTI_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtFToIV_MX = !cast<SchedWrite>("WriteVFCvtFToIV_" # mx); |
| defvar ReadVFCvtFToIV_MX = !cast<SchedRead>("ReadVFCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversion<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtFToIV_MX, ReadVFCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCVTI_V_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtFToIV_MX = !cast<SchedWrite>("WriteVFCvtFToIV_" # mx); |
| defvar ReadVFCvtFToIV_MX = !cast<SchedRead>("ReadVFCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversionRoundingMode<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtFToIV_MX, ReadVFCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCVTI_RM_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtFToIV_MX = !cast<SchedWrite>("WriteVFCvtFToIV_" # mx); |
| defvar ReadVFCvtFToIV_MX = !cast<SchedRead>("ReadVFCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversionRM<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtFToIV_MX, ReadVFCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVFROUND_NOEXCEPT_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtFToIV_MX = !cast<SchedWrite>("WriteVFCvtFToIV_" # mx); |
| defvar ReadVFCvtFToIV_MX = !cast<SchedRead>("ReadVFCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversionNoExcept<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtFToIV_MX, ReadVFCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCVTF_V_RM { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtIToFV_MX = !cast<SchedWrite>("WriteVFCvtIToFV_" # mx); |
| defvar ReadVFCvtIToFV_MX = !cast<SchedRead>("ReadVFCvtIToFV_" # mx); |
| |
| defm _V : VPseudoConversionRoundingMode<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtIToFV_MX, ReadVFCvtIToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVCVTF_RM_V { |
| foreach m = MxListF in { |
| defvar mx = m.MX; |
| defvar WriteVFCvtIToFV_MX = !cast<SchedWrite>("WriteVFCvtIToFV_" # mx); |
| defvar ReadVFCvtIToFV_MX = !cast<SchedRead>("ReadVFCvtIToFV_" # mx); |
| |
| defm _V : VPseudoConversionRM<m.vrclass, m.vrclass, m>, |
| Sched<[WriteVFCvtIToFV_MX, ReadVFCvtIToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWCVTI_V { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWCvtFToIV_MX = !cast<SchedWrite>("WriteVFWCvtFToIV_" # mx); |
| defvar ReadVFWCvtFToIV_MX = !cast<SchedRead>("ReadVFWCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversion<m.wvrclass, m.vrclass, m, constraint>, |
| Sched<[WriteVFWCvtFToIV_MX, ReadVFWCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWCVTI_V_RM { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWCvtFToIV_MX = !cast<SchedWrite>("WriteVFWCvtFToIV_" # mx); |
| defvar ReadVFWCvtFToIV_MX = !cast<SchedRead>("ReadVFWCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversionRoundingMode<m.wvrclass, m.vrclass, m, constraint>, |
| Sched<[WriteVFWCvtFToIV_MX, ReadVFWCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWCVTI_RM_V { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWCvtFToIV_MX = !cast<SchedWrite>("WriteVFWCvtFToIV_" # mx); |
| defvar ReadVFWCvtFToIV_MX = !cast<SchedRead>("ReadVFWCvtFToIV_" # mx); |
| |
| defm _V : VPseudoConversionRM<m.wvrclass, m.vrclass, m, constraint>, |
| Sched<[WriteVFWCvtFToIV_MX, ReadVFWCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWCVTF_V { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVFWCvtIToFV_MX = !cast<SchedWrite>("WriteVFWCvtIToFV_" # mx); |
| defvar ReadVFWCvtIToFV_MX = !cast<SchedRead>("ReadVFWCvtIToFV_" # mx); |
| |
| defm _V : VPseudoConversion<m.wvrclass, m.vrclass, m, constraint>, |
| Sched<[WriteVFWCvtIToFV_MX, ReadVFWCvtIToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVWCVTD_V { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFWCvtFToFV_MX = !cast<SchedWrite>("WriteVFWCvtFToFV_" # mx); |
| defvar ReadVFWCvtFToFV_MX = !cast<SchedRead>("ReadVFWCvtFToFV_" # mx); |
| |
| defm _V : VPseudoConversion<m.wvrclass, m.vrclass, m, constraint>, |
| Sched<[WriteVFWCvtFToFV_MX, ReadVFWCvtFToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTI_W { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtFToIV_MX = !cast<SchedWrite>("WriteVFNCvtFToIV_" # mx); |
| defvar ReadVFNCvtFToIV_MX = !cast<SchedRead>("ReadVFNCvtFToIV_" # mx); |
| |
| defm _W : VPseudoConversion<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtFToIV_MX, ReadVFNCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTI_W_RM { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtFToIV_MX = !cast<SchedWrite>("WriteVFNCvtFToIV_" # mx); |
| defvar ReadVFNCvtFToIV_MX = !cast<SchedRead>("ReadVFNCvtFToIV_" # mx); |
| |
| defm _W : VPseudoConversionRoundingMode<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtFToIV_MX, ReadVFNCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTI_RM_W { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtFToIV_MX = !cast<SchedWrite>("WriteVFNCvtFToIV_" # mx); |
| defvar ReadVFNCvtFToIV_MX = !cast<SchedRead>("ReadVFNCvtFToIV_" # mx); |
| |
| defm _W : VPseudoConversionRM<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtFToIV_MX, ReadVFNCvtFToIV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTF_W_RM { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtIToFV_MX = !cast<SchedWrite>("WriteVFNCvtIToFV_" # mx); |
| defvar ReadVFNCvtIToFV_MX = !cast<SchedRead>("ReadVFNCvtIToFV_" # mx); |
| |
| defm _W : VPseudoConversionRoundingMode<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtIToFV_MX, ReadVFNCvtIToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTF_RM_W { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtIToFV_MX = !cast<SchedWrite>("WriteVFNCvtIToFV_" # mx); |
| defvar ReadVFNCvtIToFV_MX = !cast<SchedRead>("ReadVFNCvtIToFV_" # mx); |
| |
| defm _W : VPseudoConversionRM<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtIToFV_MX, ReadVFNCvtIToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTD_W { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtFToFV_MX = !cast<SchedWrite>("WriteVFNCvtFToFV_" # mx); |
| defvar ReadVFNCvtFToFV_MX = !cast<SchedRead>("ReadVFNCvtFToFV_" # mx); |
| |
| defm _W : VPseudoConversion<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtFToFV_MX, ReadVFNCvtFToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoVNCVTD_W_RM { |
| defvar constraint = "@earlyclobber $rd"; |
| foreach m = MxListFW in { |
| defvar mx = m.MX; |
| defvar WriteVFNCvtFToFV_MX = !cast<SchedWrite>("WriteVFNCvtFToFV_" # mx); |
| defvar ReadVFNCvtFToFV_MX = !cast<SchedRead>("ReadVFNCvtFToFV_" # mx); |
| |
| defm _W : VPseudoConversionRoundingMode<m.vrclass, m.wvrclass, m, constraint>, |
| Sched<[WriteVFNCvtFToFV_MX, ReadVFNCvtFToFV_MX, ReadVMask]>; |
| } |
| } |
| |
| multiclass VPseudoUSSegLoad { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| let VLMul = lmul.value, SEW=eew in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| def nf # "E" # eew # "_V_" # LInfo : |
| VPseudoUSSegLoadNoMask<vreg, eew, nf>, VLSEGSched<nf, eew, LInfo>; |
| def nf # "E" # eew # "_V_" # LInfo # "_MASK" : |
| VPseudoUSSegLoadMask<vreg, eew, nf>, VLSEGSched<nf, eew, LInfo>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoUSSegLoadFF { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| let VLMul = lmul.value, SEW=eew in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| def nf # "E" # eew # "FF_V_" # LInfo : |
| VPseudoUSSegLoadFFNoMask<vreg, eew, nf>, VLSEGFFSched<nf, eew, LInfo>; |
| def nf # "E" # eew # "FF_V_" # LInfo # "_MASK" : |
| VPseudoUSSegLoadFFMask<vreg, eew, nf>, VLSEGFFSched<nf, eew, LInfo>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoSSegLoad { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| let VLMul = lmul.value, SEW=eew in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| def nf # "E" # eew # "_V_" # LInfo : VPseudoSSegLoadNoMask<vreg, eew, nf>, |
| VLSSEGSched<nf, eew, LInfo>; |
| def nf # "E" # eew # "_V_" # LInfo # "_MASK" : VPseudoSSegLoadMask<vreg, eew, nf>, |
| VLSSEGSched<nf, eew, LInfo>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoISegLoad<bit Ordered> { |
| foreach idxEEW = EEWList in { |
| foreach dataEEW = EEWList in { |
| foreach dataEMUL = MxSet<dataEEW>.m in { |
| defvar dataEMULOctuple = dataEMUL.octuple; |
| // Calculate emul = eew * lmul / sew |
| defvar idxEMULOctuple = !srl(!mul(idxEEW, dataEMULOctuple), !logtwo(dataEEW)); |
| if !and(!ge(idxEMULOctuple, 1), !le(idxEMULOctuple, 64)) then { |
| defvar DataLInfo = dataEMUL.MX; |
| defvar IdxLInfo = octuple_to_str<idxEMULOctuple>.ret; |
| defvar idxEMUL = !cast<LMULInfo>("V_" # IdxLInfo); |
| defvar DataVreg = dataEMUL.vrclass; |
| defvar IdxVreg = idxEMUL.vrclass; |
| defvar Order = !if(Ordered, "O", "U"); |
| let VLMul = dataEMUL.value in { |
| foreach nf = NFSet<dataEMUL>.L in { |
| defvar Vreg = SegRegClass<dataEMUL, nf>.RC; |
| def nf # "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo : |
| VPseudoISegLoadNoMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, |
| nf, Ordered>, |
| VLXSEGSched<nf, dataEEW, Order, DataLInfo>; |
| def nf # "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo # "_MASK" : |
| VPseudoISegLoadMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, |
| nf, Ordered>, |
| VLXSEGSched<nf, dataEEW, Order, DataLInfo>; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoUSSegStore { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| let VLMul = lmul.value, SEW=eew in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| def nf # "E" # eew # "_V_" # LInfo : VPseudoUSSegStoreNoMask<vreg, eew, nf>, |
| VSSEGSched<nf, eew, LInfo>; |
| def nf # "E" # eew # "_V_" # LInfo # "_MASK" : VPseudoUSSegStoreMask<vreg, eew, nf>, |
| VSSEGSched<nf, eew, LInfo>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoSSegStore { |
| foreach eew = EEWList in { |
| foreach lmul = MxSet<eew>.m in { |
| defvar LInfo = lmul.MX; |
| let VLMul = lmul.value, SEW=eew in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| def nf # "E" # eew # "_V_" # LInfo : VPseudoSSegStoreNoMask<vreg, eew, nf>, |
| VSSSEGSched<nf, eew, LInfo>; |
| def nf # "E" # eew # "_V_" # LInfo # "_MASK" : VPseudoSSegStoreMask<vreg, eew, nf>, |
| VSSSEGSched<nf, eew, LInfo>; |
| } |
| } |
| } |
| } |
| } |
| |
| multiclass VPseudoISegStore<bit Ordered> { |
| foreach idxEEW = EEWList in { |
| foreach dataEEW = EEWList in { |
| foreach dataEMUL = MxSet<dataEEW>.m in { |
| defvar dataEMULOctuple = dataEMUL.octuple; |
| // Calculate emul = eew * lmul / sew |
| defvar idxEMULOctuple = !srl(!mul(idxEEW, dataEMULOctuple), !logtwo(dataEEW)); |
| if !and(!ge(idxEMULOctuple, 1), !le(idxEMULOctuple, 64)) then { |
| defvar DataLInfo = dataEMUL.MX; |
| defvar IdxLInfo = octuple_to_str<idxEMULOctuple>.ret; |
| defvar idxEMUL = !cast<LMULInfo>("V_" # IdxLInfo); |
| defvar DataVreg = dataEMUL.vrclass; |
| defvar IdxVreg = idxEMUL.vrclass; |
| defvar Order = !if(Ordered, "O", "U"); |
| let VLMul = dataEMUL.value in { |
| foreach nf = NFSet<dataEMUL>.L in { |
| defvar Vreg = SegRegClass<dataEMUL, nf>.RC; |
| def nf # "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo : |
| VPseudoISegStoreNoMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, |
| nf, Ordered>, |
| VSXSEGSched<nf, idxEEW, Order, DataLInfo>; |
| def nf # "EI" # idxEEW # "_V_" # IdxLInfo # "_" # DataLInfo # "_MASK" : |
| VPseudoISegStoreMask<Vreg, IdxVreg, idxEEW, idxEMUL.value, |
| nf, Ordered>, |
| VSXSEGSched<nf, idxEEW, Order, DataLInfo>; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Helpers to define the intrinsic patterns. |
| //===----------------------------------------------------------------------===// |
| |
| class VPatUnaryNoMask<string intrinsic_name, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op2_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op2_reg_class, |
| bit isSEWAware = 0> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>( |
| !if(isSEWAware, |
| inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew), |
| inst#"_"#kind#"_"#vlmul.MX)) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| GPR:$vl, log2sew, TU_MU)>; |
| |
| class VPatUnaryNoMaskRoundingMode<string intrinsic_name, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op2_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op2_reg_class, |
| bit isSEWAware = 0> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>( |
| !if(isSEWAware, |
| inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew), |
| inst#"_"#kind#"_"#vlmul.MX)) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (XLenVT timm:$round), |
| GPR:$vl, log2sew, TU_MU)>; |
| |
| |
| class VPatUnaryMask<string intrinsic_name, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op2_reg_class, |
| bit isSEWAware = 0> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (mask_type V0), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>( |
| !if(isSEWAware, |
| inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)#"_MASK", |
| inst#"_"#kind#"_"#vlmul.MX#"_MASK")) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (mask_type V0), GPR:$vl, log2sew, (XLenVT timm:$policy))>; |
| |
| class VPatUnaryMaskRoundingMode<string intrinsic_name, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op2_reg_class, |
| bit isSEWAware = 0> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>( |
| !if(isSEWAware, |
| inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)#"_MASK", |
| inst#"_"#kind#"_"#vlmul.MX#"_MASK")) |
| (result_type result_reg_class:$merge), |
| (op2_type op2_reg_class:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| GPR:$vl, log2sew, (XLenVT timm:$policy))>; |
| |
| |
| class VPatMaskUnaryNoMask<string intrinsic_name, |
| string inst, |
| MTypeInfo mti> : |
| Pat<(mti.Mask (!cast<Intrinsic>(intrinsic_name) |
| (mti.Mask VR:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_M_"#mti.BX) |
| (mti.Mask (IMPLICIT_DEF)), |
| (mti.Mask VR:$rs2), |
| GPR:$vl, mti.Log2SEW, TU_MU)>; |
| |
| class VPatMaskUnaryMask<string intrinsic_name, |
| string inst, |
| MTypeInfo mti> : |
| Pat<(mti.Mask (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (mti.Mask VR:$merge), |
| (mti.Mask VR:$rs2), |
| (mti.Mask V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_M_"#mti.BX#"_MASK") |
| (mti.Mask VR:$merge), |
| (mti.Mask VR:$rs2), |
| (mti.Mask V0), GPR:$vl, mti.Log2SEW, TU_MU)>; |
| |
| class VPatUnaryAnyMask<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op1_reg_class> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (mask_type VR:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (mask_type VR:$rs2), |
| GPR:$vl, log2sew)>; |
| |
| class VPatBinaryM<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew)>; |
| |
| class VPatBinaryNoMaskTU<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew, TU_MU)>; |
| |
| class VPatBinaryNoMaskRoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type (undef)), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst) |
| (result_type (IMPLICIT_DEF)), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, TA_MA)>; |
| |
| class VPatBinaryNoMaskTURoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, TU_MU)>; |
| |
| |
| // Same as above but source operands are swapped. |
| class VPatBinaryNoMaskSwapped<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (op2_type op2_kind:$rs2), |
| (op1_type op1_reg_class:$rs1), |
| VLOpFrag)), |
| (!cast<Instruction>(inst) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew)>; |
| |
| class VPatBinaryMask<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_MASK") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew)>; |
| |
| class VPatBinaryMaskTA<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_MASK") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatBinaryMaskTARoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_MASK") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| // Same as above but source operands are swapped. |
| class VPatBinaryMaskSwapped<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (op1_type op1_reg_class:$rs1), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_MASK") |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew)>; |
| |
| class VPatTiedBinaryNoMask<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type (undef)), |
| (result_type result_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_TIED") |
| (result_type result_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew, TAIL_AGNOSTIC)>; |
| |
| class VPatTiedBinaryNoMaskRoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type (undef)), |
| (result_type result_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_TIED") |
| (result_type result_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, TAIL_AGNOSTIC)>; |
| |
| class VPatTiedBinaryNoMaskTU<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_TIED") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew, TU_MU)>; |
| |
| class VPatTiedBinaryNoMaskTURoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name) |
| (result_type result_reg_class:$merge), |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_TIED") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, TU_MU)>; |
| |
| class VPatTiedBinaryMask<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_MASK_TIED") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTiedBinaryMaskRoundingMode<string intrinsic_name, |
| string inst, |
| ValueType result_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic_name#"_mask") |
| (result_type result_reg_class:$merge), |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_MASK_TIED") |
| (result_type result_reg_class:$merge), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTernaryNoMask<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| GPR:$vl, sew)>; |
| |
| class VPatTernaryNoMaskTA<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)) |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| GPR:$vl, log2sew, TAIL_AGNOSTIC)>; |
| |
| class VPatTernaryNoMaskTARoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)) |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (XLenVT timm:$round), |
| GPR:$vl, log2sew, TAIL_AGNOSTIC)>; |
| |
| class VPatTernaryNoMaskWithPolicy<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTernaryNoMaskWithPolicyRoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (XLenVT timm:$round), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (XLenVT timm:$round), |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTernaryMask<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic#"_mask") |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX # "_MASK") |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (mask_type V0), |
| GPR:$vl, sew)>; |
| |
| class VPatTernaryMaskPolicy<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic#"_mask") |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX # "_MASK") |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (mask_type V0), |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTernaryMaskPolicyRoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic#"_mask") |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX # "_MASK") |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (mask_type V0), |
| (XLenVT timm:$round), |
| GPR:$vl, sew, (XLenVT timm:$policy))>; |
| |
| class VPatTernaryMaskTA<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic#"_mask") |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)# "_MASK") |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (mask_type V0), |
| GPR:$vl, log2sew, TAIL_AGNOSTIC)>; |
| |
| class VPatTernaryMaskTARoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> : |
| Pat<(result_type (!cast<Intrinsic>(intrinsic#"_mask") |
| (result_type result_reg_class:$rs3), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| (XLenVT timm:$round), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX#"_E"#!shl(1, log2sew)# "_MASK") |
| result_reg_class:$rs3, |
| (op1_type op1_reg_class:$rs1), |
| op2_kind:$rs2, |
| (mask_type V0), |
| (XLenVT timm:$round), |
| GPR:$vl, log2sew, TAIL_AGNOSTIC)>; |
| |
| multiclass VPatUnaryS_M<string intrinsic_name, |
| string inst> { |
| foreach mti = AllMasks in { |
| def : Pat<(XLenVT (!cast<Intrinsic>(intrinsic_name) |
| (mti.Mask VR:$rs1), VLOpFrag)), |
| (!cast<Instruction>(inst#"_M_"#mti.BX) $rs1, |
| GPR:$vl, mti.Log2SEW)>; |
| def : Pat<(XLenVT (!cast<Intrinsic>(intrinsic_name # "_mask") |
| (mti.Mask VR:$rs1), (mti.Mask V0), VLOpFrag)), |
| (!cast<Instruction>(inst#"_M_"#mti.BX#"_MASK") $rs1, |
| (mti.Mask V0), GPR:$vl, mti.Log2SEW)>; |
| } |
| } |
| |
| multiclass VPatUnaryV_V_AnyMask<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| def : VPatUnaryAnyMask<intrinsic, instruction, "VM", |
| vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatUnaryM_M<string intrinsic, |
| string inst> { |
| foreach mti = AllMasks in { |
| def : VPatMaskUnaryNoMask<intrinsic, inst, mti>; |
| def : VPatMaskUnaryMask<intrinsic, inst, mti>; |
| } |
| } |
| |
| multiclass VPatUnaryV_M<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : VPatUnaryNoMask<intrinsic, instruction, "M", vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, VR>; |
| def : VPatUnaryMask<intrinsic, instruction, "M", vti.Vector, vti.Mask, |
| vti.Mask, vti.Log2SEW, vti.LMul, vti.RegClass, VR>; |
| } |
| } |
| } |
| |
| multiclass VPatUnaryV_VF<string intrinsic, string instruction, string suffix, |
| list<VTypeInfoToFraction> fractionList> { |
| foreach vtiTofti = fractionList in { |
| defvar vti = vtiTofti.Vti; |
| defvar fti = vtiTofti.Fti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<fti>.Predicates) in { |
| def : VPatUnaryNoMask<intrinsic, instruction, suffix, |
| vti.Vector, fti.Vector, |
| vti.Log2SEW, vti.LMul, vti.RegClass, fti.RegClass>; |
| def : VPatUnaryMask<intrinsic, instruction, suffix, |
| vti.Vector, fti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, fti.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatUnaryV_V<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : VPatUnaryNoMask<intrinsic, instruction, "V", |
| vti.Vector, vti.Vector, vti.Log2SEW, |
| vti.LMul, vti.RegClass, vti.RegClass, isSEWAware>; |
| def : VPatUnaryMask<intrinsic, instruction, "V", |
| vti.Vector, vti.Vector, vti.Mask, vti.Log2SEW, |
| vti.LMul, vti.RegClass, vti.RegClass, isSEWAware>; |
| } |
| } |
| } |
| |
| multiclass VPatUnaryV_V_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : VPatUnaryNoMaskRoundingMode<intrinsic, instruction, "V", |
| vti.Vector, vti.Vector, vti.Log2SEW, |
| vti.LMul, vti.RegClass, vti.RegClass, isSEWAware>; |
| def : VPatUnaryMaskRoundingMode<intrinsic, instruction, "V", |
| vti.Vector, vti.Vector, vti.Mask, vti.Log2SEW, |
| vti.LMul, vti.RegClass, vti.RegClass, isSEWAware>; |
| } |
| } |
| } |
| |
| multiclass VPatNullaryV<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : Pat<(vti.Vector (!cast<Intrinsic>(intrinsic) |
| (vti.Vector vti.RegClass:$merge), |
| VLOpFrag)), |
| (!cast<Instruction>(instruction#"_V_" # vti.LMul.MX) |
| vti.RegClass:$merge, GPR:$vl, vti.Log2SEW, TU_MU)>; |
| def : Pat<(vti.Vector (!cast<Intrinsic>(intrinsic # "_mask") |
| (vti.Vector vti.RegClass:$merge), |
| (vti.Mask V0), VLOpFrag, (XLenVT timm:$policy))), |
| (!cast<Instruction>(instruction#"_V_" # vti.LMul.MX # "_MASK") |
| vti.RegClass:$merge, (vti.Mask V0), |
| GPR:$vl, vti.Log2SEW, (XLenVT timm:$policy))>; |
| } |
| } |
| } |
| |
| multiclass VPatNullaryM<string intrinsic, string inst> { |
| foreach mti = AllMasks in |
| def : Pat<(mti.Mask (!cast<Intrinsic>(intrinsic) |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_M_"#mti.BX) |
| GPR:$vl, mti.Log2SEW)>; |
| } |
| |
| multiclass VPatBinaryM<string intrinsic, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatBinaryM<intrinsic, inst, result_type, op1_type, op2_type, |
| sew, op1_reg_class, op2_kind>; |
| def : VPatBinaryMask<intrinsic, inst, result_type, op1_type, op2_type, |
| mask_type, sew, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatBinary<string intrinsic, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatBinaryNoMaskTU<intrinsic, inst, result_type, op1_type, op2_type, |
| sew, result_reg_class, op1_reg_class, op2_kind>; |
| def : VPatBinaryMaskTA<intrinsic, inst, result_type, op1_type, op2_type, |
| mask_type, sew, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatBinaryRoundingMode<string intrinsic, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatBinaryNoMaskRoundingMode<intrinsic, inst, result_type, op1_type, op2_type, |
| sew, op1_reg_class, op2_kind>; |
| def : VPatBinaryNoMaskTURoundingMode<intrinsic, inst, result_type, op1_type, op2_type, |
| sew, result_reg_class, op1_reg_class, op2_kind>; |
| def : VPatBinaryMaskTARoundingMode<intrinsic, inst, result_type, op1_type, op2_type, |
| mask_type, sew, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatBinarySwapped<string intrinsic, |
| string inst, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatBinaryNoMaskSwapped<intrinsic, inst, result_type, op1_type, op2_type, |
| sew, op1_reg_class, op2_kind>; |
| def : VPatBinaryMaskSwapped<intrinsic, inst, result_type, op1_type, op2_type, |
| mask_type, sew, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatBinaryCarryInTAIL<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| (result_type result_reg_class:$merge), |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew)>; |
| } |
| |
| multiclass VPatBinaryCarryIn<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| (mask_type V0), GPR:$vl, sew)>; |
| } |
| |
| multiclass VPatBinaryMaskOut<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg op1_reg_class, |
| DAGOperand op2_kind> { |
| def : Pat<(result_type (!cast<Intrinsic>(intrinsic) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>(inst#"_"#kind#"_"#vlmul.MX) |
| (op1_type op1_reg_class:$rs1), |
| (op2_type op2_kind:$rs2), |
| GPR:$vl, sew)>; |
| } |
| |
| multiclass VPatConversionTA<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op1_reg_class> { |
| def : VPatUnaryNoMask<intrinsic, inst, kind, result_type, op1_type, |
| sew, vlmul, result_reg_class, op1_reg_class>; |
| def : VPatUnaryMask<intrinsic, inst, kind, result_type, op1_type, |
| mask_type, sew, vlmul, result_reg_class, op1_reg_class>; |
| } |
| |
| multiclass VPatConversionTARoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| VReg op1_reg_class> { |
| def : VPatUnaryNoMaskRoundingMode<intrinsic, inst, kind, result_type, op1_type, |
| sew, vlmul, result_reg_class, op1_reg_class>; |
| def : VPatUnaryMaskRoundingMode<intrinsic, inst, kind, result_type, op1_type, |
| mask_type, sew, vlmul, result_reg_class, op1_reg_class>; |
| } |
| |
| multiclass VPatBinaryV_VV<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinary<intrinsic, |
| !if(isSEWAware, |
| instruction # "_VV_" # vti.LMul.MX # "_E" # vti.SEW, |
| instruction # "_VV_" # vti.LMul.MX), |
| vti.Vector, vti.Vector, vti.Vector,vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryV_VV_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| !if(isSEWAware, |
| instruction # "_VV_" # vti.LMul.MX # "_E" # vti.SEW, |
| instruction # "_VV_" # vti.LMul.MX), |
| vti.Vector, vti.Vector, vti.Vector,vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryV_VV_INT<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in { |
| defvar ivti = GetIntVTypeInfo<vti>.Vti; |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinary<intrinsic, |
| instruction # "_VV_" # vti.LMul.MX # "_E" # vti.SEW, |
| vti.Vector, vti.Vector, ivti.Vector, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_VV_INT_EEW<string intrinsic, string instruction, |
| int eew, list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in { |
| // emul = lmul * eew / sew |
| defvar vlmul = vti.LMul; |
| defvar octuple_lmul = vlmul.octuple; |
| defvar octuple_emul = !srl(!mul(octuple_lmul, eew), vti.Log2SEW); |
| if !and(!ge(octuple_emul, 1), !le(octuple_emul, 64)) then { |
| defvar emul_str = octuple_to_str<octuple_emul>.ret; |
| defvar ivti = !cast<VTypeInfo>("VI" # eew # emul_str); |
| defvar inst = instruction # "_VV_" # vti.LMul.MX # "_E" # vti.SEW # "_" # emul_str; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<ivti>.Predicates) in |
| defm : VPatBinary<intrinsic, inst, |
| vti.Vector, vti.Vector, ivti.Vector, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, ivti.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatBinaryV_VX<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in { |
| defvar kind = "V"#vti.ScalarSuffix; |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinary<intrinsic, |
| !if(isSEWAware, |
| instruction#"_"#kind#"_"#vti.LMul.MX#"_E"#vti.SEW, |
| instruction#"_"#kind#"_"#vti.LMul.MX), |
| vti.Vector, vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> { |
| foreach vti = vtilist in { |
| defvar kind = "V"#vti.ScalarSuffix; |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| !if(isSEWAware, |
| instruction#"_"#kind#"_"#vti.LMul.MX#"_E"#vti.SEW, |
| instruction#"_"#kind#"_"#vti.LMul.MX), |
| vti.Vector, vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_VX_INT<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinary<intrinsic, instruction # "_VX_" # vti.LMul.MX, |
| vti.Vector, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, GPR>; |
| } |
| |
| multiclass VPatBinaryV_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand imm_type> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinary<intrinsic, instruction # "_VI_" # vti.LMul.MX, |
| vti.Vector, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, imm_type>; |
| } |
| |
| multiclass VPatBinaryV_VI_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, |
| Operand imm_type> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| instruction # "_VI_" # vti.LMul.MX, |
| vti.Vector, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.RegClass, |
| vti.RegClass, imm_type>; |
| } |
| |
| multiclass VPatBinaryM_MM<string intrinsic, string instruction> { |
| foreach mti = AllMasks in |
| let Predicates = [HasVInstructions] in |
| def : VPatBinaryM<intrinsic, instruction # "_MM_" # mti.LMul.MX, |
| mti.Mask, mti.Mask, mti.Mask, |
| mti.Log2SEW, VR, VR>; |
| } |
| |
| multiclass VPatBinaryW_VV<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction # "_VV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Vti.RegClass, Vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryW_VV_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, instruction # "_VV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Vti.RegClass, Vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryW_VX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "V"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Vti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryW_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "V"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Vti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryW_WV<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in { |
| def : VPatTiedBinaryNoMask<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| def : VPatBinaryNoMaskTU<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Vector, Vti.Log2SEW, |
| Wti.RegClass, Wti.RegClass, Vti.RegClass>; |
| let AddedComplexity = 1 in { |
| def : VPatTiedBinaryNoMaskTU<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| def : VPatTiedBinaryMask<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| } |
| def : VPatBinaryMaskTA<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Wti.RegClass, Vti.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatBinaryW_WV_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in { |
| def : VPatTiedBinaryNoMaskRoundingMode<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| def : VPatBinaryNoMaskTURoundingMode<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Vector, Vti.Log2SEW, |
| Wti.RegClass, Wti.RegClass, Vti.RegClass>; |
| let AddedComplexity = 1 in { |
| def : VPatTiedBinaryNoMaskTURoundingMode<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| def : VPatTiedBinaryMaskRoundingMode<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, Vti.RegClass>; |
| } |
| def : VPatBinaryMaskTARoundingMode<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Wti.RegClass, Vti.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatBinaryW_WX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "W"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Wti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryW_WX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "W"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Wti.Vector, Wti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Wti.RegClass, |
| Wti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_WV<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction # "_WV_" # Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, Vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_WV_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| instruction # "_WV_" # Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, Vti.Vector, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, Vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_WX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "W"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryV_WX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| defvar kind = "W"#Vti.ScalarSuffix; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| instruction#"_"#kind#"_"#Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, Vti.Scalar, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, Vti.ScalarRegClass>; |
| } |
| } |
| |
| |
| multiclass VPatBinaryV_WI<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinary<intrinsic, instruction # "_WI_" # Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, XLenVT, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, uimm5>; |
| } |
| } |
| |
| multiclass VPatBinaryV_WI_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach VtiToWti = vtilist in { |
| defvar Vti = VtiToWti.Vti; |
| defvar Wti = VtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<Vti>.Predicates, |
| GetVTypePredicates<Wti>.Predicates) in |
| defm : VPatBinaryRoundingMode<intrinsic, |
| instruction # "_WI_" # Vti.LMul.MX, |
| Vti.Vector, Wti.Vector, XLenVT, Vti.Mask, |
| Vti.Log2SEW, Vti.RegClass, |
| Wti.RegClass, uimm5>; |
| } |
| } |
| |
| multiclass VPatBinaryV_VM<string intrinsic, string instruction, |
| bit CarryOut = 0, |
| list<VTypeInfo> vtilist = AllIntegerVectors> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryIn<intrinsic, instruction, "VVM", |
| !if(CarryOut, vti.Mask, vti.Vector), |
| vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryV_XM<string intrinsic, string instruction, |
| bit CarryOut = 0, |
| list<VTypeInfo> vtilist = AllIntegerVectors> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryIn<intrinsic, instruction, |
| "V"#vti.ScalarSuffix#"M", |
| !if(CarryOut, vti.Mask, vti.Vector), |
| vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| |
| multiclass VPatBinaryV_IM<string intrinsic, string instruction, |
| bit CarryOut = 0> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryIn<intrinsic, instruction, "VIM", |
| !if(CarryOut, vti.Mask, vti.Vector), |
| vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, simm5>; |
| } |
| |
| multiclass VPatBinaryV_VM_TAIL<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryInTAIL<intrinsic, instruction, "VVM", |
| vti.Vector, |
| vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryV_XM_TAIL<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryInTAIL<intrinsic, instruction, |
| "V"#vti.ScalarSuffix#"M", |
| vti.Vector, |
| vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| |
| multiclass VPatBinaryV_IM_TAIL<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryCarryInTAIL<intrinsic, instruction, "VIM", |
| vti.Vector, |
| vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, vti.RegClass, simm5>; |
| } |
| |
| multiclass VPatBinaryV_V<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryMaskOut<intrinsic, instruction, "VV", |
| vti.Mask, vti.Vector, vti.Vector, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryV_X<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryMaskOut<intrinsic, instruction, "VX", |
| vti.Mask, vti.Vector, XLenVT, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, GPR>; |
| } |
| |
| multiclass VPatBinaryV_I<string intrinsic, string instruction> { |
| foreach vti = AllIntegerVectors in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryMaskOut<intrinsic, instruction, "VI", |
| vti.Mask, vti.Vector, XLenVT, |
| vti.Log2SEW, vti.LMul, |
| vti.RegClass, simm5>; |
| } |
| |
| multiclass VPatBinaryM_VV<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryM<intrinsic, instruction # "_VV_" # vti.LMul.MX, |
| vti.Mask, vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, VR, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinarySwappedM_VV<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinarySwapped<intrinsic, instruction # "_VV_" # vti.LMul.MX, |
| vti.Mask, vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, VR, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatBinaryM_VX<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in { |
| defvar kind = "V"#vti.ScalarSuffix; |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryM<intrinsic, instruction#"_"#kind#"_"#vti.LMul.MX, |
| vti.Mask, vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, VR, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| } |
| |
| multiclass VPatBinaryM_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatBinaryM<intrinsic, instruction # "_VI_" # vti.LMul.MX, |
| vti.Mask, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, VR, |
| vti.RegClass, simm5>; |
| } |
| |
| multiclass VPatBinaryV_VV_VX_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand ImmType = simm5> |
| : VPatBinaryV_VV<intrinsic, instruction, vtilist>, |
| VPatBinaryV_VX<intrinsic, instruction, vtilist>, |
| VPatBinaryV_VI<intrinsic, instruction, vtilist, ImmType>; |
| |
| multiclass VPatBinaryV_VV_VX_VI_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand ImmType = simm5> |
| : VPatBinaryV_VV_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryV_VX_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryV_VI_RM<intrinsic, instruction, vtilist, ImmType>; |
| |
| multiclass VPatBinaryV_VV_VX<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> |
| : VPatBinaryV_VV<intrinsic, instruction, vtilist, isSEWAware>, |
| VPatBinaryV_VX<intrinsic, instruction, vtilist, isSEWAware>; |
| |
| multiclass VPatBinaryV_VV_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, bit isSEWAware = 0> |
| : VPatBinaryV_VV_RM<intrinsic, instruction, vtilist, isSEWAware>, |
| VPatBinaryV_VX_RM<intrinsic, instruction, vtilist, isSEWAware>; |
| |
| multiclass VPatBinaryV_VX_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatBinaryV_VX<intrinsic, instruction, vtilist>, |
| VPatBinaryV_VI<intrinsic, instruction, vtilist, simm5>; |
| |
| multiclass VPatBinaryW_VV_VX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryW_VV<intrinsic, instruction, vtilist>, |
| VPatBinaryW_VX<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryW_VV_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryW_VV_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryW_VX_RM<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryW_WV_WX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryW_WV<intrinsic, instruction, vtilist>, |
| VPatBinaryW_WX<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryW_WV_WX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryW_WV_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryW_WX_RM<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryV_WV_WX_WI<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryV_WV<intrinsic, instruction, vtilist>, |
| VPatBinaryV_WX<intrinsic, instruction, vtilist>, |
| VPatBinaryV_WI<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryV_WV_WX_WI_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatBinaryV_WV_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryV_WX_RM<intrinsic, instruction, vtilist>, |
| VPatBinaryV_WI_RM<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryV_VM_XM_IM<string intrinsic, string instruction> |
| : VPatBinaryV_VM_TAIL<intrinsic, instruction>, |
| VPatBinaryV_XM_TAIL<intrinsic, instruction>, |
| VPatBinaryV_IM_TAIL<intrinsic, instruction>; |
| |
| multiclass VPatBinaryM_VM_XM_IM<string intrinsic, string instruction> |
| : VPatBinaryV_VM<intrinsic, instruction, CarryOut=1>, |
| VPatBinaryV_XM<intrinsic, instruction, CarryOut=1>, |
| VPatBinaryV_IM<intrinsic, instruction, CarryOut=1>; |
| |
| multiclass VPatBinaryM_V_X_I<string intrinsic, string instruction> |
| : VPatBinaryV_V<intrinsic, instruction>, |
| VPatBinaryV_X<intrinsic, instruction>, |
| VPatBinaryV_I<intrinsic, instruction>; |
| |
| multiclass VPatBinaryV_VM_XM<string intrinsic, string instruction> |
| : VPatBinaryV_VM_TAIL<intrinsic, instruction>, |
| VPatBinaryV_XM_TAIL<intrinsic, instruction>; |
| |
| multiclass VPatBinaryM_VM_XM<string intrinsic, string instruction> |
| : VPatBinaryV_VM<intrinsic, instruction, CarryOut=1>, |
| VPatBinaryV_XM<intrinsic, instruction, CarryOut=1>; |
| |
| multiclass VPatBinaryM_V_X<string intrinsic, string instruction> |
| : VPatBinaryV_V<intrinsic, instruction>, |
| VPatBinaryV_X<intrinsic, instruction>; |
| |
| multiclass VPatTernary<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMask<intrinsic, inst, kind, result_type, op1_type, op2_type, |
| sew, vlmul, result_reg_class, op1_reg_class, |
| op2_kind>; |
| def : VPatTernaryMask<intrinsic, inst, kind, result_type, op1_type, op2_type, |
| mask_type, sew, vlmul, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatTernaryNoMaskNoPolicy<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMask<intrinsic, inst, kind, result_type, op1_type, op2_type, |
| sew, vlmul, result_reg_class, op1_reg_class, |
| op2_kind>; |
| def : VPatTernaryMaskPolicy<intrinsic, inst, kind, result_type, op1_type, op2_type, |
| mask_type, sew, vlmul, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatTernaryWithPolicy<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMaskWithPolicy<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, sew, vlmul, result_reg_class, |
| op1_reg_class, op2_kind>; |
| def : VPatTernaryMaskPolicy<intrinsic, inst, kind, result_type, op1_type, op2_type, |
| mask_type, sew, vlmul, result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatTernaryWithPolicyRoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMaskWithPolicyRoundingMode<intrinsic, inst, kind, result_type, |
| op1_type, op2_type, sew, vlmul, |
| result_reg_class, op1_reg_class, |
| op2_kind>; |
| def : VPatTernaryMaskPolicyRoundingMode<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, mask_type, sew, vlmul, |
| result_reg_class, op1_reg_class, |
| op2_kind>; |
| } |
| |
| multiclass VPatTernaryTA<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMaskTA<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, log2sew, vlmul, result_reg_class, |
| op1_reg_class, op2_kind>; |
| def : VPatTernaryMaskTA<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, mask_type, log2sew, vlmul, |
| result_reg_class, op1_reg_class, op2_kind>; |
| } |
| |
| multiclass VPatTernaryTARoundingMode<string intrinsic, |
| string inst, |
| string kind, |
| ValueType result_type, |
| ValueType op1_type, |
| ValueType op2_type, |
| ValueType mask_type, |
| int log2sew, |
| LMULInfo vlmul, |
| VReg result_reg_class, |
| RegisterClass op1_reg_class, |
| DAGOperand op2_kind> { |
| def : VPatTernaryNoMaskTARoundingMode<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, log2sew, vlmul, result_reg_class, |
| op1_reg_class, op2_kind>; |
| def : VPatTernaryMaskTARoundingMode<intrinsic, inst, kind, result_type, op1_type, |
| op2_type, mask_type, log2sew, vlmul, |
| result_reg_class, op1_reg_class, op2_kind>; |
| } |
| |
| multiclass VPatTernaryV_VV_AAXA<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, "VV", |
| vti.Vector, vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatTernaryV_VV_AAXA_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicyRoundingMode<intrinsic, instruction, "VV", |
| vti.Vector, vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatTernaryV_VX<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, "VX", |
| vti.Vector, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, GPR>; |
| } |
| |
| multiclass VPatTernaryV_VX_AAXA<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, |
| "V"#vti.ScalarSuffix, |
| vti.Vector, vti.Scalar, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.ScalarRegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatTernaryV_VX_AAXA_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicyRoundingMode<intrinsic, instruction, |
| "V"#vti.ScalarSuffix, |
| vti.Vector, vti.Scalar, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.ScalarRegClass, vti.RegClass>; |
| } |
| |
| multiclass VPatTernaryV_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand Imm_type> { |
| foreach vti = vtilist in |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, "VI", |
| vti.Vector, vti.Vector, XLenVT, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, Imm_type>; |
| } |
| |
| multiclass VPatTernaryW_VV<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach vtiToWti = vtilist in { |
| defvar vti = vtiToWti.Vti; |
| defvar wti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<wti>.Predicates) in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, "VV", |
| wti.Vector, vti.Vector, vti.Vector, |
| vti.Mask, vti.Log2SEW, vti.LMul, |
| wti.RegClass, vti.RegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatTernaryW_VV_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach vtiToWti = vtilist in { |
| defvar vti = vtiToWti.Vti; |
| defvar wti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<wti>.Predicates) in |
| defm : VPatTernaryWithPolicyRoundingMode<intrinsic, instruction, "VV", |
| wti.Vector, vti.Vector, vti.Vector, |
| vti.Mask, vti.Log2SEW, vti.LMul, |
| wti.RegClass, vti.RegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatTernaryW_VX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach vtiToWti = vtilist in { |
| defvar vti = vtiToWti.Vti; |
| defvar wti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<wti>.Predicates) in |
| defm : VPatTernaryWithPolicy<intrinsic, instruction, |
| "V"#vti.ScalarSuffix, |
| wti.Vector, vti.Scalar, vti.Vector, |
| vti.Mask, vti.Log2SEW, vti.LMul, |
| wti.RegClass, vti.ScalarRegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatTernaryW_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> { |
| foreach vtiToWti = vtilist in { |
| defvar vti = vtiToWti.Vti; |
| defvar wti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<wti>.Predicates) in |
| defm : VPatTernaryWithPolicyRoundingMode<intrinsic, instruction, |
| "V"#vti.ScalarSuffix, |
| wti.Vector, vti.Scalar, vti.Vector, |
| vti.Mask, vti.Log2SEW, vti.LMul, |
| wti.RegClass, vti.ScalarRegClass, |
| vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatTernaryV_VV_VX_AAXA<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatTernaryV_VV_AAXA<intrinsic, instruction, vtilist>, |
| VPatTernaryV_VX_AAXA<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatTernaryV_VV_VX_AAXA_RM<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatTernaryV_VV_AAXA_RM<intrinsic, instruction, vtilist>, |
| VPatTernaryV_VX_AAXA_RM<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatTernaryV_VX_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand Imm_type = simm5> |
| : VPatTernaryV_VX<intrinsic, instruction, vtilist>, |
| VPatTernaryV_VI<intrinsic, instruction, vtilist, Imm_type>; |
| |
| |
| multiclass VPatBinaryM_VV_VX_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatBinaryM_VV<intrinsic, instruction, vtilist>, |
| VPatBinaryM_VX<intrinsic, instruction, vtilist>, |
| VPatBinaryM_VI<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatTernaryW_VV_VX<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatTernaryW_VV<intrinsic, instruction, vtilist>, |
| VPatTernaryW_VX<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatTernaryW_VV_VX_RM<string intrinsic, string instruction, |
| list<VTypeInfoToWide> vtilist> |
| : VPatTernaryW_VV_RM<intrinsic, instruction, vtilist>, |
| VPatTernaryW_VX_RM<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryM_VV_VX<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatBinaryM_VV<intrinsic, instruction, vtilist>, |
| VPatBinaryM_VX<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryM_VX_VI<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist> |
| : VPatBinaryM_VX<intrinsic, instruction, vtilist>, |
| VPatBinaryM_VI<intrinsic, instruction, vtilist>; |
| |
| multiclass VPatBinaryV_VV_VX_VI_INT<string intrinsic, string instruction, |
| list<VTypeInfo> vtilist, Operand ImmType = simm5> |
| : VPatBinaryV_VV_INT<intrinsic#"_vv", instruction, vtilist>, |
| VPatBinaryV_VX_INT<intrinsic#"_vx", instruction, vtilist>, |
| VPatBinaryV_VI<intrinsic#"_vx", instruction, vtilist, ImmType>; |
| |
| multiclass VPatReductionV_VS<string intrinsic, string instruction, bit IsFloat = 0> { |
| foreach vti = !if(IsFloat, NoGroupFloatVectors, NoGroupIntegerVectors) in { |
| defvar vectorM1 = !cast<VTypeInfo>(!if(IsFloat, "VF", "VI") # vti.SEW # "M1"); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryTA<intrinsic, instruction, "VS", |
| vectorM1.Vector, vti.Vector, |
| vectorM1.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| VR, vti.RegClass, VR>; |
| } |
| foreach gvti = !if(IsFloat, GroupFloatVectors, GroupIntegerVectors) in { |
| let Predicates = GetVTypePredicates<gvti>.Predicates in |
| defm : VPatTernaryTA<intrinsic, instruction, "VS", |
| gvti.VectorM1, gvti.Vector, |
| gvti.VectorM1, gvti.Mask, |
| gvti.Log2SEW, gvti.LMul, |
| VR, gvti.RegClass, VR>; |
| } |
| } |
| |
| multiclass VPatReductionV_VS_RM<string intrinsic, string instruction, bit IsFloat = 0> { |
| foreach vti = !if(IsFloat, NoGroupFloatVectors, NoGroupIntegerVectors) in { |
| defvar vectorM1 = !cast<VTypeInfo>(!if(IsFloat, "VF", "VI") # vti.SEW # "M1"); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryTARoundingMode<intrinsic, instruction, "VS", |
| vectorM1.Vector, vti.Vector, |
| vectorM1.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| VR, vti.RegClass, VR>; |
| } |
| foreach gvti = !if(IsFloat, GroupFloatVectors, GroupIntegerVectors) in { |
| let Predicates = GetVTypePredicates<gvti>.Predicates in |
| defm : VPatTernaryTARoundingMode<intrinsic, instruction, "VS", |
| gvti.VectorM1, gvti.Vector, |
| gvti.VectorM1, gvti.Mask, |
| gvti.Log2SEW, gvti.LMul, |
| VR, gvti.RegClass, VR>; |
| } |
| } |
| |
| multiclass VPatReductionW_VS<string intrinsic, string instruction, bit IsFloat = 0> { |
| foreach vti = !if(IsFloat, AllFloatVectors, AllIntegerVectors) in { |
| defvar wtiSEW = !mul(vti.SEW, 2); |
| if !le(wtiSEW, 64) then { |
| defvar wtiM1 = !cast<VTypeInfo>(!if(IsFloat, "VF", "VI") # wtiSEW # "M1"); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryTA<intrinsic, instruction, "VS", |
| wtiM1.Vector, vti.Vector, |
| wtiM1.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| wtiM1.RegClass, vti.RegClass, |
| wtiM1.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatReductionW_VS_RM<string intrinsic, string instruction, bit IsFloat = 0> { |
| foreach vti = !if(IsFloat, AllFloatVectors, AllIntegerVectors) in { |
| defvar wtiSEW = !mul(vti.SEW, 2); |
| if !le(wtiSEW, 64) then { |
| defvar wtiM1 = !cast<VTypeInfo>(!if(IsFloat, "VF", "VI") # wtiSEW # "M1"); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| defm : VPatTernaryTARoundingMode<intrinsic, instruction, "VS", |
| wtiM1.Vector, vti.Vector, |
| wtiM1.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, |
| wtiM1.RegClass, vti.RegClass, |
| wtiM1.RegClass>; |
| } |
| } |
| } |
| |
| multiclass VPatConversionVI_VF<string intrinsic, |
| string instruction> { |
| foreach fvti = AllFloatVectors in { |
| defvar ivti = GetIntVTypeInfo<fvti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<ivti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "V", |
| ivti.Vector, fvti.Vector, ivti.Mask, fvti.Log2SEW, |
| fvti.LMul, ivti.RegClass, fvti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVI_VF_RM<string intrinsic, |
| string instruction> { |
| foreach fvti = AllFloatVectors in { |
| defvar ivti = GetIntVTypeInfo<fvti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<ivti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "V", |
| ivti.Vector, fvti.Vector, ivti.Mask, fvti.Log2SEW, |
| fvti.LMul, ivti.RegClass, fvti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVF_VI_RM<string intrinsic, |
| string instruction> { |
| foreach fvti = AllFloatVectors in { |
| defvar ivti = GetIntVTypeInfo<fvti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<ivti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "V", |
| fvti.Vector, ivti.Vector, fvti.Mask, ivti.Log2SEW, |
| ivti.LMul, fvti.RegClass, ivti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionWI_VF<string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar iwti = GetIntVTypeInfo<fvtiToFWti.Wti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<iwti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "V", |
| iwti.Vector, fvti.Vector, iwti.Mask, fvti.Log2SEW, |
| fvti.LMul, iwti.RegClass, fvti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionWI_VF_RM<string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar iwti = GetIntVTypeInfo<fvtiToFWti.Wti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<iwti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "V", |
| iwti.Vector, fvti.Vector, iwti.Mask, fvti.Log2SEW, |
| fvti.LMul, iwti.RegClass, fvti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionWF_VI<string intrinsic, string instruction> { |
| foreach vtiToWti = AllWidenableIntToFloatVectors in { |
| defvar vti = vtiToWti.Vti; |
| defvar fwti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "V", |
| fwti.Vector, vti.Vector, fwti.Mask, vti.Log2SEW, |
| vti.LMul, fwti.RegClass, vti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionWF_VF<string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar fwti = fvtiToFWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "V", |
| fwti.Vector, fvti.Vector, fwti.Mask, fvti.Log2SEW, |
| fvti.LMul, fwti.RegClass, fvti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVI_WF <string intrinsic, string instruction> { |
| foreach vtiToWti = AllWidenableIntToFloatVectors in { |
| defvar vti = vtiToWti.Vti; |
| defvar fwti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "W", |
| vti.Vector, fwti.Vector, vti.Mask, vti.Log2SEW, |
| vti.LMul, vti.RegClass, fwti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVI_WF_RM <string intrinsic, string instruction> { |
| foreach vtiToWti = AllWidenableIntToFloatVectors in { |
| defvar vti = vtiToWti.Vti; |
| defvar fwti = vtiToWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<vti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "W", |
| vti.Vector, fwti.Vector, vti.Mask, vti.Log2SEW, |
| vti.LMul, vti.RegClass, fwti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVF_WI_RM <string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar iwti = GetIntVTypeInfo<fvtiToFWti.Wti>.Vti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<iwti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "W", |
| fvti.Vector, iwti.Vector, fvti.Mask, fvti.Log2SEW, |
| fvti.LMul, fvti.RegClass, iwti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVF_WF <string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar fwti = fvtiToFWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTA<intrinsic, instruction, "W", |
| fvti.Vector, fwti.Vector, fvti.Mask, fvti.Log2SEW, |
| fvti.LMul, fvti.RegClass, fwti.RegClass>; |
| } |
| } |
| |
| multiclass VPatConversionVF_WF_RM <string intrinsic, string instruction> { |
| foreach fvtiToFWti = AllWidenableFloatVectors in { |
| defvar fvti = fvtiToFWti.Vti; |
| defvar fwti = fvtiToFWti.Wti; |
| let Predicates = !listconcat(GetVTypePredicates<fvti>.Predicates, |
| GetVTypePredicates<fwti>.Predicates) in |
| defm : VPatConversionTARoundingMode<intrinsic, instruction, "W", |
| fvti.Vector, fwti.Vector, fvti.Mask, fvti.Log2SEW, |
| fvti.LMul, fvti.RegClass, fwti.RegClass>; |
| } |
| } |
| |
| multiclass VPatCompare_VI<string intrinsic, string inst, |
| ImmLeaf ImmType> { |
| foreach vti = AllIntegerVectors in { |
| defvar Intr = !cast<Intrinsic>(intrinsic); |
| defvar Pseudo = !cast<Instruction>(inst#"_VI_"#vti.LMul.MX); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| def : Pat<(vti.Mask (Intr (vti.Vector vti.RegClass:$rs1), |
| (vti.Scalar ImmType:$rs2), |
| VLOpFrag)), |
| (Pseudo vti.RegClass:$rs1, (DecImm ImmType:$rs2), |
| GPR:$vl, vti.Log2SEW)>; |
| defvar IntrMask = !cast<Intrinsic>(intrinsic # "_mask"); |
| defvar PseudoMask = !cast<Instruction>(inst#"_VI_"#vti.LMul.MX#"_MASK"); |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| def : Pat<(vti.Mask (IntrMask (vti.Mask VR:$merge), |
| (vti.Vector vti.RegClass:$rs1), |
| (vti.Scalar ImmType:$rs2), |
| (vti.Mask V0), |
| VLOpFrag)), |
| (PseudoMask VR:$merge, vti.RegClass:$rs1, (DecImm ImmType:$rs2), |
| (vti.Mask V0), GPR:$vl, vti.Log2SEW)>; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // Pseudo instructions |
| //===----------------------------------------------------------------------===// |
| |
| let Predicates = [HasVInstructions] in { |
| |
| //===----------------------------------------------------------------------===// |
| // Pseudo Instructions for CodeGen |
| //===----------------------------------------------------------------------===// |
| |
| let hasSideEffects = 0, mayLoad = 0, mayStore = 0, isCodeGenOnly = 1 in { |
| def PseudoReadVLENB : Pseudo<(outs GPR:$rd), (ins), |
| [(set GPR:$rd, (riscv_read_vlenb))]>, |
| PseudoInstExpansion<(CSRRS GPR:$rd, SysRegVLENB.Encoding, X0)>, |
| Sched<[WriteRdVLENB]>; |
| } |
| |
| let hasSideEffects = 0, mayLoad = 0, mayStore = 0, isCodeGenOnly = 1, |
| Uses = [VL] in |
| def PseudoReadVL : Pseudo<(outs GPR:$rd), (ins), []>, |
| PseudoInstExpansion<(CSRRS GPR:$rd, SysRegVL.Encoding, X0)>; |
| |
| foreach lmul = MxList in { |
| foreach nf = NFSet<lmul>.L in { |
| defvar vreg = SegRegClass<lmul, nf>.RC; |
| let hasSideEffects = 0, mayLoad = 0, mayStore = 1, isCodeGenOnly = 1, |
| Size = !mul(4, !sub(!mul(nf, 2), 1)) in { |
| def "PseudoVSPILL" # nf # "_" # lmul.MX : |
| Pseudo<(outs), (ins vreg:$rs1, GPR:$rs2), []>; |
| } |
| let hasSideEffects = 0, mayLoad = 1, mayStore = 0, isCodeGenOnly = 1, |
| Size = !mul(4, !sub(!mul(nf, 2), 1)) in { |
| def "PseudoVRELOAD" # nf # "_" # lmul.MX : |
| Pseudo<(outs vreg:$rs1), (ins GPR:$rs2), []>; |
| } |
| } |
| } |
| |
| /// Empty pseudo for RISCVInitUndefPass |
| let hasSideEffects = 0, mayLoad = 0, mayStore = 0, Size = 0, |
| isCodeGenOnly = 1 in { |
| def PseudoRVVInitUndefM1 : Pseudo<(outs VR:$vd), (ins), [], "">; |
| def PseudoRVVInitUndefM2 : Pseudo<(outs VRM2:$vd), (ins), [], "">; |
| def PseudoRVVInitUndefM4 : Pseudo<(outs VRM4:$vd), (ins), [], "">; |
| def PseudoRVVInitUndefM8 : Pseudo<(outs VRM8:$vd), (ins), [], "">; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 6. Configuration-Setting Instructions |
| //===----------------------------------------------------------------------===// |
| |
| // Pseudos. |
| let hasSideEffects = 1, mayLoad = 0, mayStore = 0, Defs = [VL, VTYPE] in { |
| // Due to rs1=X0 having special meaning, we need a GPRNoX0 register class for |
| // the when we aren't using one of the special X0 encodings. Otherwise it could |
| // be accidentally be made X0 by MachineIR optimizations. To satisfy the |
| // verifier, we also need a GPRX0 instruction for the special encodings. |
| def PseudoVSETVLI : Pseudo<(outs GPR:$rd), (ins GPRNoX0:$rs1, VTypeIOp11:$vtypei), []>, |
| Sched<[WriteVSETVLI, ReadVSETVLI]>; |
| def PseudoVSETVLIX0 : Pseudo<(outs GPR:$rd), (ins GPRX0:$rs1, VTypeIOp11:$vtypei), []>, |
| Sched<[WriteVSETVLI, ReadVSETVLI]>; |
| def PseudoVSETIVLI : Pseudo<(outs GPR:$rd), (ins uimm5:$rs1, VTypeIOp10:$vtypei), []>, |
| Sched<[WriteVSETIVLI]>; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 7. Vector Loads and Stores |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 7.4 Vector Unit-Stride Instructions |
| //===----------------------------------------------------------------------===// |
| |
| // Pseudos Unit-Stride Loads and Stores |
| defm PseudoVL : VPseudoUSLoad; |
| defm PseudoVS : VPseudoUSStore; |
| |
| defm PseudoVLM : VPseudoLoadMask; |
| defm PseudoVSM : VPseudoStoreMask; |
| |
| //===----------------------------------------------------------------------===// |
| // 7.5 Vector Strided Instructions |
| //===----------------------------------------------------------------------===// |
| |
| // Vector Strided Loads and Stores |
| defm PseudoVLS : VPseudoSLoad; |
| defm PseudoVSS : VPseudoSStore; |
| |
| //===----------------------------------------------------------------------===// |
| // 7.6 Vector Indexed Instructions |
| //===----------------------------------------------------------------------===// |
| |
| // Vector Indexed Loads and Stores |
| defm PseudoVLUX : VPseudoILoad<Ordered=false>; |
| defm PseudoVLOX : VPseudoILoad<Ordered=true>; |
| defm PseudoVSOX : VPseudoIStore<Ordered=true>; |
| defm PseudoVSUX : VPseudoIStore<Ordered=false>; |
| |
| //===----------------------------------------------------------------------===// |
| // 7.7. Unit-stride Fault-Only-First Loads |
| //===----------------------------------------------------------------------===// |
| |
| // vleff may update VL register |
| let hasSideEffects = 1, Defs = [VL] in |
| defm PseudoVL : VPseudoFFLoad; |
| |
| //===----------------------------------------------------------------------===// |
| // 7.8. Vector Load/Store Segment Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVLSEG : VPseudoUSSegLoad; |
| defm PseudoVLSSEG : VPseudoSSegLoad; |
| defm PseudoVLOXSEG : VPseudoISegLoad<Ordered=true>; |
| defm PseudoVLUXSEG : VPseudoISegLoad<Ordered=false>; |
| defm PseudoVSSEG : VPseudoUSSegStore; |
| defm PseudoVSSSEG : VPseudoSSegStore; |
| defm PseudoVSOXSEG : VPseudoISegStore<Ordered=true>; |
| defm PseudoVSUXSEG : VPseudoISegStore<Ordered=false>; |
| |
| // vlseg<nf>e<eew>ff.v may update VL register |
| let hasSideEffects = 1, Defs = [VL] in { |
| defm PseudoVLSEG : VPseudoUSSegLoadFF; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 11. Vector Integer Arithmetic Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 11.1. Vector Single-Width Integer Add and Subtract |
| //===----------------------------------------------------------------------===// |
| defm PseudoVADD : VPseudoVALU_VV_VX_VI; |
| defm PseudoVSUB : VPseudoVALU_VV_VX; |
| defm PseudoVRSUB : VPseudoVALU_VX_VI; |
| |
| foreach vti = AllIntegerVectors in { |
| // Match vrsub with 2 vector operands to vsub.vv by swapping operands. This |
| // Occurs when legalizing vrsub.vx intrinsics for i64 on RV32 since we need |
| // to use a more complex splat sequence. Add the pattern for all VTs for |
| // consistency. |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : Pat<(vti.Vector (int_riscv_vrsub (vti.Vector vti.RegClass:$merge), |
| (vti.Vector vti.RegClass:$rs2), |
| (vti.Vector vti.RegClass:$rs1), |
| VLOpFrag)), |
| (!cast<Instruction>("PseudoVSUB_VV_"#vti.LMul.MX) |
| vti.RegClass:$merge, |
| vti.RegClass:$rs1, |
| vti.RegClass:$rs2, |
| GPR:$vl, |
| vti.Log2SEW, TU_MU)>; |
| def : Pat<(vti.Vector (int_riscv_vrsub_mask (vti.Vector vti.RegClass:$merge), |
| (vti.Vector vti.RegClass:$rs2), |
| (vti.Vector vti.RegClass:$rs1), |
| (vti.Mask V0), |
| VLOpFrag, |
| (XLenVT timm:$policy))), |
| (!cast<Instruction>("PseudoVSUB_VV_"#vti.LMul.MX#"_MASK") |
| vti.RegClass:$merge, |
| vti.RegClass:$rs1, |
| vti.RegClass:$rs2, |
| (vti.Mask V0), |
| GPR:$vl, |
| vti.Log2SEW, |
| (XLenVT timm:$policy))>; |
| |
| // Match VSUB with a small immediate to vadd.vi by negating the immediate. |
| def : Pat<(vti.Vector (int_riscv_vsub (vti.Vector (undef)), |
| (vti.Vector vti.RegClass:$rs1), |
| (vti.Scalar simm5_plus1:$rs2), |
| VLOpFrag)), |
| (!cast<Instruction>("PseudoVADD_VI_"#vti.LMul.MX) (vti.Vector (IMPLICIT_DEF)), |
| vti.RegClass:$rs1, |
| (NegImm simm5_plus1:$rs2), |
| GPR:$vl, |
| vti.Log2SEW, TU_MU)>; |
| def : Pat<(vti.Vector (int_riscv_vsub_mask (vti.Vector vti.RegClass:$merge), |
| (vti.Vector vti.RegClass:$rs1), |
| (vti.Scalar simm5_plus1:$rs2), |
| (vti.Mask V0), |
| VLOpFrag, |
| (XLenVT timm:$policy))), |
| (!cast<Instruction>("PseudoVADD_VI_"#vti.LMul.MX#"_MASK") |
| vti.RegClass:$merge, |
| vti.RegClass:$rs1, |
| (NegImm simm5_plus1:$rs2), |
| (vti.Mask V0), |
| GPR:$vl, |
| vti.Log2SEW, |
| (XLenVT timm:$policy))>; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 11.2. Vector Widening Integer Add/Subtract |
| //===----------------------------------------------------------------------===// |
| defm PseudoVWADDU : VPseudoVWALU_VV_VX; |
| defm PseudoVWSUBU : VPseudoVWALU_VV_VX; |
| defm PseudoVWADD : VPseudoVWALU_VV_VX; |
| defm PseudoVWSUB : VPseudoVWALU_VV_VX; |
| defm PseudoVWADDU : VPseudoVWALU_WV_WX; |
| defm PseudoVWSUBU : VPseudoVWALU_WV_WX; |
| defm PseudoVWADD : VPseudoVWALU_WV_WX; |
| defm PseudoVWSUB : VPseudoVWALU_WV_WX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.3. Vector Integer Extension |
| //===----------------------------------------------------------------------===// |
| defm PseudoVZEXT_VF2 : PseudoVEXT_VF2; |
| defm PseudoVZEXT_VF4 : PseudoVEXT_VF4; |
| defm PseudoVZEXT_VF8 : PseudoVEXT_VF8; |
| defm PseudoVSEXT_VF2 : PseudoVEXT_VF2; |
| defm PseudoVSEXT_VF4 : PseudoVEXT_VF4; |
| defm PseudoVSEXT_VF8 : PseudoVEXT_VF8; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.4. Vector Integer Add-with-Carry / Subtract-with-Borrow Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVADC : VPseudoVCALU_VM_XM_IM; |
| defm PseudoVMADC : VPseudoVCALUM_VM_XM_IM<"@earlyclobber $rd">; |
| defm PseudoVMADC : VPseudoVCALUM_V_X_I<"@earlyclobber $rd">; |
| |
| defm PseudoVSBC : VPseudoVCALU_VM_XM; |
| defm PseudoVMSBC : VPseudoVCALUM_VM_XM<"@earlyclobber $rd">; |
| defm PseudoVMSBC : VPseudoVCALUM_V_X<"@earlyclobber $rd">; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.5. Vector Bitwise Logical Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVAND : VPseudoVALU_VV_VX_VI; |
| defm PseudoVOR : VPseudoVALU_VV_VX_VI; |
| defm PseudoVXOR : VPseudoVALU_VV_VX_VI; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.6. Vector Single-Width Bit Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVSLL : VPseudoVSHT_VV_VX_VI<uimm5>; |
| defm PseudoVSRL : VPseudoVSHT_VV_VX_VI<uimm5>; |
| defm PseudoVSRA : VPseudoVSHT_VV_VX_VI<uimm5>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.7. Vector Narrowing Integer Right Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVNSRL : VPseudoVNSHT_WV_WX_WI; |
| defm PseudoVNSRA : VPseudoVNSHT_WV_WX_WI; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.8. Vector Integer Comparison Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMSEQ : VPseudoVCMPM_VV_VX_VI; |
| defm PseudoVMSNE : VPseudoVCMPM_VV_VX_VI; |
| defm PseudoVMSLTU : VPseudoVCMPM_VV_VX; |
| defm PseudoVMSLT : VPseudoVCMPM_VV_VX; |
| defm PseudoVMSLEU : VPseudoVCMPM_VV_VX_VI; |
| defm PseudoVMSLE : VPseudoVCMPM_VV_VX_VI; |
| defm PseudoVMSGTU : VPseudoVCMPM_VX_VI; |
| defm PseudoVMSGT : VPseudoVCMPM_VX_VI; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.9. Vector Integer Min/Max Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMINU : VPseudoVMINMAX_VV_VX; |
| defm PseudoVMIN : VPseudoVMINMAX_VV_VX; |
| defm PseudoVMAXU : VPseudoVMINMAX_VV_VX; |
| defm PseudoVMAX : VPseudoVMINMAX_VV_VX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.10. Vector Single-Width Integer Multiply Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMUL : VPseudoVMUL_VV_VX; |
| defm PseudoVMULH : VPseudoVMUL_VV_VX; |
| defm PseudoVMULHU : VPseudoVMUL_VV_VX; |
| defm PseudoVMULHSU : VPseudoVMUL_VV_VX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.11. Vector Integer Divide Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVDIVU : VPseudoVDIV_VV_VX; |
| defm PseudoVDIV : VPseudoVDIV_VV_VX; |
| defm PseudoVREMU : VPseudoVDIV_VV_VX; |
| defm PseudoVREM : VPseudoVDIV_VV_VX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.12. Vector Widening Integer Multiply Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVWMUL : VPseudoVWMUL_VV_VX; |
| defm PseudoVWMULU : VPseudoVWMUL_VV_VX; |
| defm PseudoVWMULSU : VPseudoVWMUL_VV_VX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.13. Vector Single-Width Integer Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMACC : VPseudoVMAC_VV_VX_AAXA; |
| defm PseudoVNMSAC : VPseudoVMAC_VV_VX_AAXA; |
| defm PseudoVMADD : VPseudoVMAC_VV_VX_AAXA; |
| defm PseudoVNMSUB : VPseudoVMAC_VV_VX_AAXA; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.14. Vector Widening Integer Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVWMACCU : VPseudoVWMAC_VV_VX; |
| defm PseudoVWMACC : VPseudoVWMAC_VV_VX; |
| defm PseudoVWMACCSU : VPseudoVWMAC_VV_VX; |
| defm PseudoVWMACCUS : VPseudoVWMAC_VX; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.15. Vector Integer Merge Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMERGE : VPseudoVMRG_VM_XM_IM; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.16. Vector Integer Move Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMV_V : VPseudoUnaryVMV_V_X_I; |
| |
| //===----------------------------------------------------------------------===// |
| // 12. Vector Fixed-Point Arithmetic Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 12.1. Vector Single-Width Saturating Add and Subtract |
| //===----------------------------------------------------------------------===// |
| let Defs = [VXSAT], hasSideEffects = 1 in { |
| defm PseudoVSADDU : VPseudoVSALU_VV_VX_VI; |
| defm PseudoVSADD : VPseudoVSALU_VV_VX_VI; |
| defm PseudoVSSUBU : VPseudoVSALU_VV_VX; |
| defm PseudoVSSUB : VPseudoVSALU_VV_VX; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 12.2. Vector Single-Width Averaging Add and Subtract |
| //===----------------------------------------------------------------------===// |
| defm PseudoVAADDU : VPseudoVAALU_VV_VX_RM; |
| defm PseudoVAADD : VPseudoVAALU_VV_VX_RM; |
| defm PseudoVASUBU : VPseudoVAALU_VV_VX_RM; |
| defm PseudoVASUB : VPseudoVAALU_VV_VX_RM; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation |
| //===----------------------------------------------------------------------===// |
| let Defs = [VXSAT], hasSideEffects = 1 in { |
| defm PseudoVSMUL : VPseudoVSMUL_VV_VX_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 12.4. Vector Single-Width Scaling Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVSSRL : VPseudoVSSHT_VV_VX_VI_RM<uimm5>; |
| defm PseudoVSSRA : VPseudoVSSHT_VV_VX_VI_RM<uimm5>; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.5. Vector Narrowing Fixed-Point Clip Instructions |
| //===----------------------------------------------------------------------===// |
| let Defs = [VXSAT], hasSideEffects = 1 in { |
| defm PseudoVNCLIP : VPseudoVNCLP_WV_WX_WI_RM; |
| defm PseudoVNCLIPU : VPseudoVNCLP_WV_WX_WI_RM; |
| } |
| |
| } // Predicates = [HasVInstructions] |
| |
| //===----------------------------------------------------------------------===// |
| // 13. Vector Floating-Point Instructions |
| //===----------------------------------------------------------------------===// |
| |
| let Predicates = [HasVInstructionsAnyF] in { |
| //===----------------------------------------------------------------------===// |
| // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasPostISelHook = 1 in { |
| defm PseudoVFADD : VPseudoVALU_VV_VF_RM; |
| defm PseudoVFSUB : VPseudoVALU_VV_VF_RM; |
| defm PseudoVFRSUB : VPseudoVALU_VF_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.3. Vector Widening Floating-Point Add/Subtract Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFWADD : VPseudoVFWALU_VV_VF_RM; |
| defm PseudoVFWSUB : VPseudoVFWALU_VV_VF_RM; |
| defm PseudoVFWADD : VPseudoVFWALU_WV_WF_RM; |
| defm PseudoVFWSUB : VPseudoVFWALU_WV_WF_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFMUL : VPseudoVFMUL_VV_VF_RM; |
| defm PseudoVFDIV : VPseudoVFDIV_VV_VF_RM; |
| defm PseudoVFRDIV : VPseudoVFRDIV_VF_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.5. Vector Widening Floating-Point Multiply |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0 in { |
| defm PseudoVFWMUL : VPseudoVWMUL_VV_VF_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFMACC : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFNMACC : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFMSAC : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFNMSAC : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFMADD : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFNMADD : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFMSUB : VPseudoVMAC_VV_VF_AAXA_RM; |
| defm PseudoVFNMSUB : VPseudoVMAC_VV_VF_AAXA_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFWMACC : VPseudoVWMAC_VV_VF_RM; |
| defm PseudoVFWNMACC : VPseudoVWMAC_VV_VF_RM; |
| defm PseudoVFWMSAC : VPseudoVWMAC_VV_VF_RM; |
| defm PseudoVFWNMSAC : VPseudoVWMAC_VV_VF_RM; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.8. Vector Floating-Point Square-Root Instruction |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0 in |
| defm PseudoVFSQRT : VPseudoVSQR_V_RM; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in |
| defm PseudoVFRSQRT7 : VPseudoVRCP_V; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.10. Vector Floating-Point Reciprocal Estimate Instruction |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, hasSideEffects = 0 in |
| defm PseudoVFREC7 : VPseudoVRCP_V_RM; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.11. Vector Floating-Point Min/Max Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in { |
| defm PseudoVFMIN : VPseudoVMAX_VV_VF; |
| defm PseudoVFMAX : VPseudoVMAX_VV_VF; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.12. Vector Floating-Point Sign-Injection Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVFSGNJ : VPseudoVSGNJ_VV_VF; |
| defm PseudoVFSGNJN : VPseudoVSGNJ_VV_VF; |
| defm PseudoVFSGNJX : VPseudoVSGNJ_VV_VF; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.13. Vector Floating-Point Compare Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in { |
| defm PseudoVMFEQ : VPseudoVCMPM_VV_VF; |
| defm PseudoVMFNE : VPseudoVCMPM_VV_VF; |
| defm PseudoVMFLT : VPseudoVCMPM_VV_VF; |
| defm PseudoVMFLE : VPseudoVCMPM_VV_VF; |
| defm PseudoVMFGT : VPseudoVCMPM_VF; |
| defm PseudoVMFGE : VPseudoVCMPM_VF; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.14. Vector Floating-Point Classify Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVFCLASS : VPseudoVCLS_V; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.15. Vector Floating-Point Merge Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVFMERGE : VPseudoVMRG_FM; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.16. Vector Floating-Point Move Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVFMV_V : VPseudoVMV_F; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in { |
| let hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFCVT_XU_F : VPseudoVCVTI_V_RM; |
| defm PseudoVFCVT_X_F : VPseudoVCVTI_V_RM; |
| } |
| |
| defm PseudoVFCVT_RM_XU_F : VPseudoVCVTI_RM_V; |
| defm PseudoVFCVT_RM_X_F : VPseudoVCVTI_RM_V; |
| |
| defm PseudoVFCVT_RTZ_XU_F : VPseudoVCVTI_V; |
| defm PseudoVFCVT_RTZ_X_F : VPseudoVCVTI_V; |
| |
| defm PseudoVFROUND_NOEXCEPT : VPseudoVFROUND_NOEXCEPT_V; |
| let hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFCVT_F_XU : VPseudoVCVTF_V_RM; |
| defm PseudoVFCVT_F_X : VPseudoVCVTF_V_RM; |
| } |
| defm PseudoVFCVT_RM_F_XU : VPseudoVCVTF_RM_V; |
| defm PseudoVFCVT_RM_F_X : VPseudoVCVTF_RM_V; |
| } // mayRaiseFPException = true |
| |
| //===----------------------------------------------------------------------===// |
| // 13.18. Widening Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in { |
| let hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFWCVT_XU_F : VPseudoVWCVTI_V_RM; |
| defm PseudoVFWCVT_X_F : VPseudoVWCVTI_V_RM; |
| } |
| defm PseudoVFWCVT_RM_XU_F : VPseudoVWCVTI_RM_V; |
| defm PseudoVFWCVT_RM_X_F : VPseudoVWCVTI_RM_V; |
| |
| defm PseudoVFWCVT_RTZ_XU_F : VPseudoVWCVTI_V; |
| defm PseudoVFWCVT_RTZ_X_F : VPseudoVWCVTI_V; |
| |
| defm PseudoVFWCVT_F_XU : VPseudoVWCVTF_V; |
| defm PseudoVFWCVT_F_X : VPseudoVWCVTF_V; |
| |
| defm PseudoVFWCVT_F_F : VPseudoVWCVTD_V; |
| } // mayRaiseFPException = true |
| |
| //===----------------------------------------------------------------------===// |
| // 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true in { |
| let hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFNCVT_XU_F : VPseudoVNCVTI_W_RM; |
| defm PseudoVFNCVT_X_F : VPseudoVNCVTI_W_RM; |
| } |
| defm PseudoVFNCVT_RM_XU_F : VPseudoVNCVTI_RM_W; |
| defm PseudoVFNCVT_RM_X_F : VPseudoVNCVTI_RM_W; |
| |
| defm PseudoVFNCVT_RTZ_XU_F : VPseudoVNCVTI_W; |
| defm PseudoVFNCVT_RTZ_X_F : VPseudoVNCVTI_W; |
| |
| let hasSideEffects = 0, hasPostISelHook = 1 in { |
| defm PseudoVFNCVT_F_XU : VPseudoVNCVTF_W_RM; |
| defm PseudoVFNCVT_F_X : VPseudoVNCVTF_W_RM; |
| } |
| defm PseudoVFNCVT_RM_F_XU : VPseudoVNCVTF_RM_W; |
| defm PseudoVFNCVT_RM_F_X : VPseudoVNCVTF_RM_W; |
| |
| let hasSideEffects = 0, hasPostISelHook = 1 in |
| defm PseudoVFNCVT_F_F : VPseudoVNCVTD_W_RM; |
| |
| defm PseudoVFNCVT_ROD_F_F : VPseudoVNCVTD_W; |
| } // mayRaiseFPException = true |
| } // Predicates = [HasVInstructionsAnyF] |
| |
| //===----------------------------------------------------------------------===// |
| // 14. Vector Reduction Operations |
| //===----------------------------------------------------------------------===// |
| |
| let Predicates = [HasVInstructions] in { |
| //===----------------------------------------------------------------------===// |
| // 14.1. Vector Single-Width Integer Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVREDSUM : VPseudoVRED_VS; |
| defm PseudoVREDAND : VPseudoVRED_VS; |
| defm PseudoVREDOR : VPseudoVRED_VS; |
| defm PseudoVREDXOR : VPseudoVRED_VS; |
| defm PseudoVREDMINU : VPseudoVREDMINMAX_VS; |
| defm PseudoVREDMIN : VPseudoVREDMINMAX_VS; |
| defm PseudoVREDMAXU : VPseudoVREDMINMAX_VS; |
| defm PseudoVREDMAX : VPseudoVREDMINMAX_VS; |
| |
| //===----------------------------------------------------------------------===// |
| // 14.2. Vector Widening Integer Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| let IsRVVWideningReduction = 1 in { |
| defm PseudoVWREDSUMU : VPseudoVWRED_VS; |
| defm PseudoVWREDSUM : VPseudoVWRED_VS; |
| } |
| } // Predicates = [HasVInstructions] |
| |
| let Predicates = [HasVInstructionsAnyF] in { |
| //===----------------------------------------------------------------------===// |
| // 14.3. Vector Single-Width Floating-Point Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| let mayRaiseFPException = true, |
| hasSideEffects = 0 in { |
| defm PseudoVFREDOSUM : VPseudoVFREDO_VS_RM; |
| defm PseudoVFREDUSUM : VPseudoVFRED_VS_RM; |
| } |
| let mayRaiseFPException = true in { |
| defm PseudoVFREDMIN : VPseudoVFREDMINMAX_VS; |
| defm PseudoVFREDMAX : VPseudoVFREDMINMAX_VS; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 14.4. Vector Widening Floating-Point Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| let IsRVVWideningReduction = 1, |
| hasSideEffects = 0, |
| mayRaiseFPException = true in { |
| defm PseudoVFWREDUSUM : VPseudoVFWRED_VS_RM; |
| defm PseudoVFWREDOSUM : VPseudoVFWRED_VS_RM; |
| } |
| |
| } // Predicates = [HasVInstructionsAnyF] |
| |
| //===----------------------------------------------------------------------===// |
| // 15. Vector Mask Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 15.1 Vector Mask-Register Logical Instructions |
| //===----------------------------------------------------------------------===// |
| |
| defm PseudoVMAND: VPseudoVALU_MM; |
| defm PseudoVMNAND: VPseudoVALU_MM; |
| defm PseudoVMANDN: VPseudoVALU_MM; |
| defm PseudoVMXOR: VPseudoVALU_MM; |
| defm PseudoVMOR: VPseudoVALU_MM; |
| defm PseudoVMNOR: VPseudoVALU_MM; |
| defm PseudoVMORN: VPseudoVALU_MM; |
| defm PseudoVMXNOR: VPseudoVALU_MM; |
| |
| // Pseudo instructions |
| defm PseudoVMCLR : VPseudoNullaryPseudoM<"VMXOR">; |
| defm PseudoVMSET : VPseudoNullaryPseudoM<"VMXNOR">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.2. Vector mask population count vcpop |
| //===----------------------------------------------------------------------===// |
| |
| defm PseudoVCPOP: VPseudoVPOP_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.3. vfirst find-first-set mask bit |
| //===----------------------------------------------------------------------===// |
| |
| defm PseudoVFIRST: VPseudoV1ST_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.4. vmsbf.m set-before-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMSBF: VPseudoVSFS_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.5. vmsif.m set-including-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMSIF: VPseudoVSFS_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.6. vmsof.m set-only-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm PseudoVMSOF: VPseudoVSFS_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.8. Vector Iota Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVIOTA_M: VPseudoVIOT_M; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.9. Vector Element Index Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVID : VPseudoVID_V; |
| |
| //===----------------------------------------------------------------------===// |
| // 16. Vector Permutation Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 16.1. Integer Scalar Move Instructions |
| //===----------------------------------------------------------------------===// |
| |
| let Predicates = [HasVInstructions] in { |
| let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in { |
| foreach m = MxList in { |
| defvar mx = m.MX; |
| let VLMul = m.value in { |
| let HasSEWOp = 1, BaseInstr = VMV_X_S in |
| def PseudoVMV_X_S # "_" # mx: |
| Pseudo<(outs GPR:$rd), (ins m.vrclass:$rs2, ixlenimm:$sew), []>, |
| Sched<[WriteVIMovVX, ReadVIMovVX]>, |
| RISCVVPseudo; |
| let HasVLOp = 1, HasSEWOp = 1, BaseInstr = VMV_S_X, |
| Constraints = "$rd = $rs1" in |
| def PseudoVMV_S_X # "_" # mx: Pseudo<(outs m.vrclass:$rd), |
| (ins m.vrclass:$rs1, GPR:$rs2, |
| AVL:$vl, ixlenimm:$sew), |
| []>, |
| Sched<[WriteVIMovXV, ReadVIMovXV, ReadVIMovXX]>, |
| RISCVVPseudo; |
| } |
| } |
| } |
| } // Predicates = [HasVInstructions] |
| |
| //===----------------------------------------------------------------------===// |
| // 16.2. Floating-Point Scalar Move Instructions |
| //===----------------------------------------------------------------------===// |
| |
| let Predicates = [HasVInstructionsAnyF] in { |
| let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in { |
| foreach f = FPList in { |
| foreach m = f.MxList in { |
| defvar mx = m.MX; |
| let VLMul = m.value in { |
| let HasSEWOp = 1, BaseInstr = VFMV_F_S in |
| def "PseudoVFMV_" # f.FX # "_S_" # mx : |
| Pseudo<(outs f.fprclass:$rd), |
| (ins m.vrclass:$rs2, ixlenimm:$sew), []>, |
| Sched<[WriteVFMovVF, ReadVFMovVF]>, |
| RISCVVPseudo; |
| let HasVLOp = 1, HasSEWOp = 1, BaseInstr = VFMV_S_F, |
| Constraints = "$rd = $rs1" in |
| def "PseudoVFMV_S_" # f.FX # "_" # mx : |
| Pseudo<(outs m.vrclass:$rd), |
| (ins m.vrclass:$rs1, f.fprclass:$rs2, |
| AVL:$vl, ixlenimm:$sew), |
| []>, |
| Sched<[WriteVFMovFV, ReadVFMovFV, ReadVFMovFX]>, |
| RISCVVPseudo; |
| } |
| } |
| } |
| } |
| } // Predicates = [HasVInstructionsAnyF] |
| |
| //===----------------------------------------------------------------------===// |
| // 16.3. Vector Slide Instructions |
| //===----------------------------------------------------------------------===// |
| let Predicates = [HasVInstructions] in { |
| defm PseudoVSLIDEUP : VPseudoVSLD_VX_VI<uimm5, "@earlyclobber $rd">; |
| defm PseudoVSLIDEDOWN : VPseudoVSLD_VX_VI<uimm5>; |
| defm PseudoVSLIDE1UP : VPseudoVSLD1_VX<"@earlyclobber $rd">; |
| defm PseudoVSLIDE1DOWN : VPseudoVSLD1_VX; |
| } // Predicates = [HasVInstructions] |
| |
| let Predicates = [HasVInstructionsAnyF] in { |
| defm PseudoVFSLIDE1UP : VPseudoVSLD1_VF<"@earlyclobber $rd">; |
| defm PseudoVFSLIDE1DOWN : VPseudoVSLD1_VF; |
| } // Predicates = [HasVInstructionsAnyF] |
| |
| //===----------------------------------------------------------------------===// |
| // 16.4. Vector Register Gather Instructions |
| //===----------------------------------------------------------------------===// |
| defm PseudoVRGATHER : VPseudoVGTR_VV_VX_VI<uimm5, "@earlyclobber $rd">; |
| defm PseudoVRGATHEREI16 : VPseudoVGTR_VV_EEW<eew=16, |
| Constraint="@earlyclobber $rd">; |
| |
| //===----------------------------------------------------------------------===// |
| // 16.5. Vector Compress Instruction |
| //===----------------------------------------------------------------------===// |
| defm PseudoVCOMPRESS : VPseudoVCPR_V; |
| |
| //===----------------------------------------------------------------------===// |
| // Patterns. |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 11. Vector Integer Arithmetic Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 11.1. Vector Single-Width Integer Add and Subtract |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vadd", "PseudoVADD", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vsub", "PseudoVSUB", AllIntegerVectors>; |
| defm : VPatBinaryV_VX_VI<"int_riscv_vrsub", "PseudoVRSUB", AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.2. Vector Widening Integer Add/Subtract |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwaddu", "PseudoVWADDU", AllWidenableIntVectors>; |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwsubu", "PseudoVWSUBU", AllWidenableIntVectors>; |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwadd", "PseudoVWADD", AllWidenableIntVectors>; |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwsub", "PseudoVWSUB", AllWidenableIntVectors>; |
| defm : VPatBinaryW_WV_WX<"int_riscv_vwaddu_w", "PseudoVWADDU", AllWidenableIntVectors>; |
| defm : VPatBinaryW_WV_WX<"int_riscv_vwsubu_w", "PseudoVWSUBU", AllWidenableIntVectors>; |
| defm : VPatBinaryW_WV_WX<"int_riscv_vwadd_w", "PseudoVWADD", AllWidenableIntVectors>; |
| defm : VPatBinaryW_WV_WX<"int_riscv_vwsub_w", "PseudoVWSUB", AllWidenableIntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.3. Vector Integer Extension |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_VF<"int_riscv_vzext", "PseudoVZEXT", "VF2", |
| AllFractionableVF2IntVectors>; |
| defm : VPatUnaryV_VF<"int_riscv_vzext", "PseudoVZEXT", "VF4", |
| AllFractionableVF4IntVectors>; |
| defm : VPatUnaryV_VF<"int_riscv_vzext", "PseudoVZEXT", "VF8", |
| AllFractionableVF8IntVectors>; |
| defm : VPatUnaryV_VF<"int_riscv_vsext", "PseudoVSEXT", "VF2", |
| AllFractionableVF2IntVectors>; |
| defm : VPatUnaryV_VF<"int_riscv_vsext", "PseudoVSEXT", "VF4", |
| AllFractionableVF4IntVectors>; |
| defm : VPatUnaryV_VF<"int_riscv_vsext", "PseudoVSEXT", "VF8", |
| AllFractionableVF8IntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.4. Vector Integer Add-with-Carry / Subtract-with-Borrow Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VM_XM_IM<"int_riscv_vadc", "PseudoVADC">; |
| defm : VPatBinaryM_VM_XM_IM<"int_riscv_vmadc_carry_in", "PseudoVMADC">; |
| defm : VPatBinaryM_V_X_I<"int_riscv_vmadc", "PseudoVMADC">; |
| |
| defm : VPatBinaryV_VM_XM<"int_riscv_vsbc", "PseudoVSBC">; |
| defm : VPatBinaryM_VM_XM<"int_riscv_vmsbc_borrow_in", "PseudoVMSBC">; |
| defm : VPatBinaryM_V_X<"int_riscv_vmsbc", "PseudoVMSBC">; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.5. Vector Bitwise Logical Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vand", "PseudoVAND", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vor", "PseudoVOR", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vxor", "PseudoVXOR", AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.6. Vector Single-Width Bit Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vsll", "PseudoVSLL", AllIntegerVectors, |
| uimm5>; |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vsrl", "PseudoVSRL", AllIntegerVectors, |
| uimm5>; |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vsra", "PseudoVSRA", AllIntegerVectors, |
| uimm5>; |
| |
| foreach vti = AllIntegerVectors in { |
| // Emit shift by 1 as an add since it might be faster. |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : Pat<(vti.Vector (int_riscv_vsll (vti.Vector undef), |
| (vti.Vector vti.RegClass:$rs1), |
| (XLenVT 1), VLOpFrag)), |
| (!cast<Instruction>("PseudoVADD_VV_"#vti.LMul.MX) |
| (vti.Vector (IMPLICIT_DEF)), vti.RegClass:$rs1, |
| vti.RegClass:$rs1, GPR:$vl, vti.Log2SEW, TU_MU)>; |
| def : Pat<(vti.Vector (int_riscv_vsll_mask (vti.Vector vti.RegClass:$merge), |
| (vti.Vector vti.RegClass:$rs1), |
| (XLenVT 1), |
| (vti.Mask V0), |
| VLOpFrag, |
| (XLenVT timm:$policy))), |
| (!cast<Instruction>("PseudoVADD_VV_"#vti.LMul.MX#"_MASK") |
| vti.RegClass:$merge, |
| vti.RegClass:$rs1, |
| vti.RegClass:$rs1, |
| (vti.Mask V0), |
| GPR:$vl, |
| vti.Log2SEW, |
| (XLenVT timm:$policy))>; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 11.7. Vector Narrowing Integer Right Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_WV_WX_WI<"int_riscv_vnsrl", "PseudoVNSRL", AllWidenableIntVectors>; |
| defm : VPatBinaryV_WV_WX_WI<"int_riscv_vnsra", "PseudoVNSRA", AllWidenableIntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.8. Vector Integer Comparison Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryM_VV_VX_VI<"int_riscv_vmseq", "PseudoVMSEQ", AllIntegerVectors>; |
| defm : VPatBinaryM_VV_VX_VI<"int_riscv_vmsne", "PseudoVMSNE", AllIntegerVectors>; |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmsltu", "PseudoVMSLTU", AllIntegerVectors>; |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmslt", "PseudoVMSLT", AllIntegerVectors>; |
| defm : VPatBinaryM_VV_VX_VI<"int_riscv_vmsleu", "PseudoVMSLEU", AllIntegerVectors>; |
| defm : VPatBinaryM_VV_VX_VI<"int_riscv_vmsle", "PseudoVMSLE", AllIntegerVectors>; |
| |
| defm : VPatBinaryM_VX_VI<"int_riscv_vmsgtu", "PseudoVMSGTU", AllIntegerVectors>; |
| defm : VPatBinaryM_VX_VI<"int_riscv_vmsgt", "PseudoVMSGT", AllIntegerVectors>; |
| |
| // Match vmsgt with 2 vector operands to vmslt with the operands swapped. |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmsgtu", "PseudoVMSLTU", AllIntegerVectors>; |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmsgt", "PseudoVMSLT", AllIntegerVectors>; |
| |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmsgeu", "PseudoVMSLEU", AllIntegerVectors>; |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmsge", "PseudoVMSLE", AllIntegerVectors>; |
| |
| // Match vmslt(u).vx intrinsics to vmsle(u).vi if the scalar is -15 to 16 and |
| // non-zero. Zero can be .vx with x0. This avoids the user needing to know that |
| // there is no vmslt(u).vi instruction. Similar for vmsge(u).vx intrinsics |
| // using vmslt(u).vi. |
| defm : VPatCompare_VI<"int_riscv_vmslt", "PseudoVMSLE", simm5_plus1_nonzero>; |
| defm : VPatCompare_VI<"int_riscv_vmsltu", "PseudoVMSLEU", simm5_plus1_nonzero>; |
| |
| // We need to handle 0 for vmsge.vi using vmslt.vi because there is no vmsge.vx. |
| defm : VPatCompare_VI<"int_riscv_vmsge", "PseudoVMSGT", simm5_plus1>; |
| defm : VPatCompare_VI<"int_riscv_vmsgeu", "PseudoVMSGTU", simm5_plus1_nonzero>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.9. Vector Integer Min/Max Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX<"int_riscv_vminu", "PseudoVMINU", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmin", "PseudoVMIN", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmaxu", "PseudoVMAXU", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmax", "PseudoVMAX", AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.10. Vector Single-Width Integer Multiply Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmul", "PseudoVMUL", AllIntegerVectors>; |
| |
| defvar IntegerVectorsExceptI64 = !filter(vti, AllIntegerVectors, |
| !ne(vti.SEW, 64)); |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulh", "PseudoVMULH", |
| IntegerVectorsExceptI64>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulhu", "PseudoVMULHU", |
| IntegerVectorsExceptI64>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulhsu", "PseudoVMULHSU", |
| IntegerVectorsExceptI64>; |
| |
| // vmulh, vmulhu, vmulhsu are not included for EEW=64 in Zve64*. |
| defvar I64IntegerVectors = !filter(vti, AllIntegerVectors, !eq(vti.SEW, 64)); |
| let Predicates = [HasVInstructionsFullMultiply] in { |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulh", "PseudoVMULH", |
| I64IntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulhu", "PseudoVMULHU", |
| I64IntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vmulhsu", "PseudoVMULHSU", |
| I64IntegerVectors>; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 11.11. Vector Integer Divide Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX<"int_riscv_vdivu", "PseudoVDIVU", AllIntegerVectors, isSEWAware=1>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vdiv", "PseudoVDIV", AllIntegerVectors, isSEWAware=1>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vremu", "PseudoVREMU", AllIntegerVectors, isSEWAware=1>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vrem", "PseudoVREM", AllIntegerVectors, isSEWAware=1>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.12. Vector Widening Integer Multiply Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwmul", "PseudoVWMUL", AllWidenableIntVectors>; |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwmulu", "PseudoVWMULU", AllWidenableIntVectors>; |
| defm : VPatBinaryW_VV_VX<"int_riscv_vwmulsu", "PseudoVWMULSU", AllWidenableIntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.13. Vector Single-Width Integer Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatTernaryV_VV_VX_AAXA<"int_riscv_vmadd", "PseudoVMADD", AllIntegerVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA<"int_riscv_vnmsub", "PseudoVNMSUB", AllIntegerVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA<"int_riscv_vmacc", "PseudoVMACC", AllIntegerVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA<"int_riscv_vnmsac", "PseudoVNMSAC", AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.14. Vector Widening Integer Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatTernaryW_VV_VX<"int_riscv_vwmaccu", "PseudoVWMACCU", AllWidenableIntVectors>; |
| defm : VPatTernaryW_VV_VX<"int_riscv_vwmacc", "PseudoVWMACC", AllWidenableIntVectors>; |
| defm : VPatTernaryW_VV_VX<"int_riscv_vwmaccsu", "PseudoVWMACCSU", AllWidenableIntVectors>; |
| defm : VPatTernaryW_VX<"int_riscv_vwmaccus", "PseudoVWMACCUS", AllWidenableIntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.15. Vector Integer Merge Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VM_XM_IM<"int_riscv_vmerge", "PseudoVMERGE">; |
| |
| //===----------------------------------------------------------------------===// |
| // 11.16. Vector Integer Move Instructions |
| //===----------------------------------------------------------------------===// |
| foreach vti = AllVectors in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| def : Pat<(vti.Vector (int_riscv_vmv_v_v (vti.Vector vti.RegClass:$passthru), |
| (vti.Vector vti.RegClass:$rs1), |
| VLOpFrag)), |
| (!cast<Instruction>("PseudoVMV_V_V_"#vti.LMul.MX) |
| $passthru, $rs1, GPR:$vl, vti.Log2SEW, TU_MU)>; |
| |
| // vmv.v.x/vmv.v.i are handled in RISCInstrVInstrInfoVVLPatterns.td |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 12. Vector Fixed-Point Arithmetic Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 12.1. Vector Single-Width Saturating Add and Subtract |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vsaddu", "PseudoVSADDU", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_VI<"int_riscv_vsadd", "PseudoVSADD", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vssubu", "PseudoVSSUBU", AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vssub", "PseudoVSSUB", AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.2. Vector Single-Width Averaging Add and Subtract |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vaaddu", "PseudoVAADDU", |
| AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vasubu", "PseudoVASUBU", |
| AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vasub", "PseudoVASUB", |
| AllIntegerVectors>; |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vaadd", "PseudoVAADD", |
| AllIntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.3. Vector Single-Width Fractional Multiply with Rounding and Saturation |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vsmul", "PseudoVSMUL", |
| IntegerVectorsExceptI64>; |
| // vsmul.vv and vsmul.vx are not included in EEW=64 in Zve64*. |
| let Predicates = [HasVInstructionsFullMultiply] in |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vsmul", "PseudoVSMUL", |
| I64IntegerVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.4. Vector Single-Width Scaling Shift Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI_RM<"int_riscv_vssrl", "PseudoVSSRL", |
| AllIntegerVectors, uimm5>; |
| defm : VPatBinaryV_VV_VX_VI_RM<"int_riscv_vssra", "PseudoVSSRA", |
| AllIntegerVectors, uimm5>; |
| |
| //===----------------------------------------------------------------------===// |
| // 12.5. Vector Narrowing Fixed-Point Clip Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_WV_WX_WI_RM<"int_riscv_vnclipu", "PseudoVNCLIPU", |
| AllWidenableIntVectors>; |
| defm : VPatBinaryV_WV_WX_WI_RM<"int_riscv_vnclip", "PseudoVNCLIP", |
| AllWidenableIntVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13. Vector Floating-Point Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 13.2. Vector Single-Width Floating-Point Add/Subtract Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vfadd", "PseudoVFADD", |
| AllFloatVectors>; |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vfsub", "PseudoVFSUB", |
| AllFloatVectors>; |
| defm : VPatBinaryV_VX_RM<"int_riscv_vfrsub", "PseudoVFRSUB", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.3. Vector Widening Floating-Point Add/Subtract Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryW_VV_VX_RM<"int_riscv_vfwadd", "PseudoVFWADD", |
| AllWidenableFloatVectors>; |
| defm : VPatBinaryW_VV_VX_RM<"int_riscv_vfwsub", "PseudoVFWSUB", |
| AllWidenableFloatVectors>; |
| defm : VPatBinaryW_WV_WX_RM<"int_riscv_vfwadd_w", "PseudoVFWADD", |
| AllWidenableFloatVectors>; |
| defm : VPatBinaryW_WV_WX_RM<"int_riscv_vfwsub_w", "PseudoVFWSUB", |
| AllWidenableFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.4. Vector Single-Width Floating-Point Multiply/Divide Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vfmul", "PseudoVFMUL", |
| AllFloatVectors>; |
| defm : VPatBinaryV_VV_VX_RM<"int_riscv_vfdiv", "PseudoVFDIV", |
| AllFloatVectors, isSEWAware=1>; |
| defm : VPatBinaryV_VX_RM<"int_riscv_vfrdiv", "PseudoVFRDIV", |
| AllFloatVectors, isSEWAware=1>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.5. Vector Widening Floating-Point Multiply |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryW_VV_VX_RM<"int_riscv_vfwmul", "PseudoVFWMUL", |
| AllWidenableFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.6. Vector Single-Width Floating-Point Fused Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfmacc", "PseudoVFMACC", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfnmacc", "PseudoVFNMACC", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfmsac", "PseudoVFMSAC", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfnmsac", "PseudoVFNMSAC", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfmadd", "PseudoVFMADD", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfnmadd", "PseudoVFNMADD", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfmsub", "PseudoVFMSUB", AllFloatVectors>; |
| defm : VPatTernaryV_VV_VX_AAXA_RM<"int_riscv_vfnmsub", "PseudoVFNMSUB", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.7. Vector Widening Floating-Point Fused Multiply-Add Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatTernaryW_VV_VX_RM<"int_riscv_vfwmacc", "PseudoVFWMACC", |
| AllWidenableFloatVectors>; |
| defm : VPatTernaryW_VV_VX_RM<"int_riscv_vfwnmacc", "PseudoVFWNMACC", |
| AllWidenableFloatVectors>; |
| defm : VPatTernaryW_VV_VX_RM<"int_riscv_vfwmsac", "PseudoVFWMSAC", |
| AllWidenableFloatVectors>; |
| defm : VPatTernaryW_VV_VX_RM<"int_riscv_vfwnmsac", "PseudoVFWNMSAC", |
| AllWidenableFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.8. Vector Floating-Point Square-Root Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_V_RM<"int_riscv_vfsqrt", "PseudoVFSQRT", AllFloatVectors, isSEWAware=1>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.9. Vector Floating-Point Reciprocal Square-Root Estimate Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_V<"int_riscv_vfrsqrt7", "PseudoVFRSQRT7", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.10. Vector Floating-Point Reciprocal Estimate Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_V_RM<"int_riscv_vfrec7", "PseudoVFREC7", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.11. Vector Floating-Point Min/Max Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX<"int_riscv_vfmin", "PseudoVFMIN", AllFloatVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vfmax", "PseudoVFMAX", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.12. Vector Floating-Point Sign-Injection Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX<"int_riscv_vfsgnj", "PseudoVFSGNJ", AllFloatVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vfsgnjn", "PseudoVFSGNJN", AllFloatVectors>; |
| defm : VPatBinaryV_VV_VX<"int_riscv_vfsgnjx", "PseudoVFSGNJX", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.13. Vector Floating-Point Compare Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmfeq", "PseudoVMFEQ", AllFloatVectors>; |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmfle", "PseudoVMFLE", AllFloatVectors>; |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmflt", "PseudoVMFLT", AllFloatVectors>; |
| defm : VPatBinaryM_VV_VX<"int_riscv_vmfne", "PseudoVMFNE", AllFloatVectors>; |
| defm : VPatBinaryM_VX<"int_riscv_vmfgt", "PseudoVMFGT", AllFloatVectors>; |
| defm : VPatBinaryM_VX<"int_riscv_vmfge", "PseudoVMFGE", AllFloatVectors>; |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmfgt", "PseudoVMFLT", AllFloatVectors>; |
| defm : VPatBinarySwappedM_VV<"int_riscv_vmfge", "PseudoVMFLE", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.14. Vector Floating-Point Classify Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatConversionVI_VF<"int_riscv_vfclass", "PseudoVFCLASS">; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.15. Vector Floating-Point Merge Instruction |
| //===----------------------------------------------------------------------===// |
| // We can use vmerge.vvm to support vector-vector vfmerge. |
| // NOTE: Clang previously used int_riscv_vfmerge for vector-vector, but now uses |
| // int_riscv_vmerge. Support both for compatibility. |
| foreach vti = AllFloatVectors in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in { |
| defm : VPatBinaryCarryInTAIL<"int_riscv_vmerge", "PseudoVMERGE", "VVM", |
| vti.Vector, |
| vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| defm : VPatBinaryCarryInTAIL<"int_riscv_vfmerge", "PseudoVMERGE", "VVM", |
| vti.Vector, |
| vti.Vector, vti.Vector, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.RegClass>; |
| defm : VPatBinaryCarryInTAIL<"int_riscv_vfmerge", "PseudoVFMERGE", |
| "V"#vti.ScalarSuffix#"M", |
| vti.Vector, |
| vti.Vector, vti.Scalar, vti.Mask, |
| vti.Log2SEW, vti.LMul, vti.RegClass, |
| vti.RegClass, vti.ScalarRegClass>; |
| } |
| } |
| |
| foreach fvti = AllFloatVectors in { |
| defvar instr = !cast<Instruction>("PseudoVMERGE_VIM_"#fvti.LMul.MX); |
| let Predicates = GetVTypePredicates<fvti>.Predicates in |
| def : Pat<(fvti.Vector (int_riscv_vfmerge (fvti.Vector fvti.RegClass:$merge), |
| (fvti.Vector fvti.RegClass:$rs2), |
| (fvti.Scalar (fpimm0)), |
| (fvti.Mask V0), VLOpFrag)), |
| (instr fvti.RegClass:$merge, fvti.RegClass:$rs2, 0, |
| (fvti.Mask V0), GPR:$vl, fvti.Log2SEW)>; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 13.17. Single-Width Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatConversionVI_VF_RM<"int_riscv_vfcvt_x_f_v", "PseudoVFCVT_X_F">; |
| defm : VPatConversionVI_VF_RM<"int_riscv_vfcvt_xu_f_v", "PseudoVFCVT_XU_F">; |
| defm : VPatConversionVI_VF<"int_riscv_vfcvt_rtz_xu_f_v", "PseudoVFCVT_RTZ_XU_F">; |
| defm : VPatConversionVI_VF<"int_riscv_vfcvt_rtz_x_f_v", "PseudoVFCVT_RTZ_X_F">; |
| defm : VPatConversionVF_VI_RM<"int_riscv_vfcvt_f_x_v", "PseudoVFCVT_F_X">; |
| defm : VPatConversionVF_VI_RM<"int_riscv_vfcvt_f_xu_v", "PseudoVFCVT_F_XU">; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.18. Widening Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatConversionWI_VF_RM<"int_riscv_vfwcvt_xu_f_v", "PseudoVFWCVT_XU_F">; |
| defm : VPatConversionWI_VF_RM<"int_riscv_vfwcvt_x_f_v", "PseudoVFWCVT_X_F">; |
| defm : VPatConversionWI_VF<"int_riscv_vfwcvt_rtz_xu_f_v", "PseudoVFWCVT_RTZ_XU_F">; |
| defm : VPatConversionWI_VF<"int_riscv_vfwcvt_rtz_x_f_v", "PseudoVFWCVT_RTZ_X_F">; |
| defm : VPatConversionWF_VI<"int_riscv_vfwcvt_f_xu_v", "PseudoVFWCVT_F_XU">; |
| defm : VPatConversionWF_VI<"int_riscv_vfwcvt_f_x_v", "PseudoVFWCVT_F_X">; |
| defm : VPatConversionWF_VF<"int_riscv_vfwcvt_f_f_v", "PseudoVFWCVT_F_F">; |
| |
| //===----------------------------------------------------------------------===// |
| // 13.19. Narrowing Floating-Point/Integer Type-Convert Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatConversionVI_WF_RM<"int_riscv_vfncvt_xu_f_w", "PseudoVFNCVT_XU_F">; |
| defm : VPatConversionVI_WF_RM<"int_riscv_vfncvt_x_f_w", "PseudoVFNCVT_X_F">; |
| defm : VPatConversionVI_WF<"int_riscv_vfncvt_rtz_xu_f_w", "PseudoVFNCVT_RTZ_XU_F">; |
| defm : VPatConversionVI_WF<"int_riscv_vfncvt_rtz_x_f_w", "PseudoVFNCVT_RTZ_X_F">; |
| defm : VPatConversionVF_WI_RM <"int_riscv_vfncvt_f_xu_w", "PseudoVFNCVT_F_XU">; |
| defm : VPatConversionVF_WI_RM <"int_riscv_vfncvt_f_x_w", "PseudoVFNCVT_F_X">; |
| defm : VPatConversionVF_WF_RM<"int_riscv_vfncvt_f_f_w", "PseudoVFNCVT_F_F">; |
| defm : VPatConversionVF_WF<"int_riscv_vfncvt_rod_f_f_w", "PseudoVFNCVT_ROD_F_F">; |
| |
| //===----------------------------------------------------------------------===// |
| // 14. Vector Reduction Operations |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 14.1. Vector Single-Width Integer Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatReductionV_VS<"int_riscv_vredsum", "PseudoVREDSUM">; |
| defm : VPatReductionV_VS<"int_riscv_vredand", "PseudoVREDAND">; |
| defm : VPatReductionV_VS<"int_riscv_vredor", "PseudoVREDOR">; |
| defm : VPatReductionV_VS<"int_riscv_vredxor", "PseudoVREDXOR">; |
| defm : VPatReductionV_VS<"int_riscv_vredminu", "PseudoVREDMINU">; |
| defm : VPatReductionV_VS<"int_riscv_vredmin", "PseudoVREDMIN">; |
| defm : VPatReductionV_VS<"int_riscv_vredmaxu", "PseudoVREDMAXU">; |
| defm : VPatReductionV_VS<"int_riscv_vredmax", "PseudoVREDMAX">; |
| |
| //===----------------------------------------------------------------------===// |
| // 14.2. Vector Widening Integer Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatReductionW_VS<"int_riscv_vwredsumu", "PseudoVWREDSUMU">; |
| defm : VPatReductionW_VS<"int_riscv_vwredsum", "PseudoVWREDSUM">; |
| |
| //===----------------------------------------------------------------------===// |
| // 14.3. Vector Single-Width Floating-Point Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatReductionV_VS_RM<"int_riscv_vfredosum", "PseudoVFREDOSUM", IsFloat=1>; |
| defm : VPatReductionV_VS_RM<"int_riscv_vfredusum", "PseudoVFREDUSUM", IsFloat=1>; |
| defm : VPatReductionV_VS<"int_riscv_vfredmin", "PseudoVFREDMIN", IsFloat=1>; |
| defm : VPatReductionV_VS<"int_riscv_vfredmax", "PseudoVFREDMAX", IsFloat=1>; |
| |
| //===----------------------------------------------------------------------===// |
| // 14.4. Vector Widening Floating-Point Reduction Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatReductionW_VS_RM<"int_riscv_vfwredusum", "PseudoVFWREDUSUM", IsFloat=1>; |
| defm : VPatReductionW_VS_RM<"int_riscv_vfwredosum", "PseudoVFWREDOSUM", IsFloat=1>; |
| |
| //===----------------------------------------------------------------------===// |
| // 15. Vector Mask Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 15.1 Vector Mask-Register Logical Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryM_MM<"int_riscv_vmand", "PseudoVMAND">; |
| defm : VPatBinaryM_MM<"int_riscv_vmnand", "PseudoVMNAND">; |
| defm : VPatBinaryM_MM<"int_riscv_vmandn", "PseudoVMANDN">; |
| defm : VPatBinaryM_MM<"int_riscv_vmxor", "PseudoVMXOR">; |
| defm : VPatBinaryM_MM<"int_riscv_vmor", "PseudoVMOR">; |
| defm : VPatBinaryM_MM<"int_riscv_vmnor", "PseudoVMNOR">; |
| defm : VPatBinaryM_MM<"int_riscv_vmorn", "PseudoVMORN">; |
| defm : VPatBinaryM_MM<"int_riscv_vmxnor", "PseudoVMXNOR">; |
| |
| // pseudo instructions |
| defm : VPatNullaryM<"int_riscv_vmclr", "PseudoVMCLR">; |
| defm : VPatNullaryM<"int_riscv_vmset", "PseudoVMSET">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.2. Vector count population in mask vcpop.m |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryS_M<"int_riscv_vcpop", "PseudoVCPOP">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.3. vfirst find-first-set mask bit |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryS_M<"int_riscv_vfirst", "PseudoVFIRST">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.4. vmsbf.m set-before-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryM_M<"int_riscv_vmsbf", "PseudoVMSBF">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.5. vmsif.m set-including-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryM_M<"int_riscv_vmsif", "PseudoVMSIF">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.6. vmsof.m set-only-first mask bit |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryM_M<"int_riscv_vmsof", "PseudoVMSOF">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.8. Vector Iota Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_M<"int_riscv_viota", "PseudoVIOTA">; |
| |
| //===----------------------------------------------------------------------===// |
| // 15.9. Vector Element Index Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatNullaryV<"int_riscv_vid", "PseudoVID">; |
| |
| |
| //===----------------------------------------------------------------------===// |
| // 16. Vector Permutation Instructions |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // 16.1. Integer Scalar Move Instructions |
| //===----------------------------------------------------------------------===// |
| |
| foreach vti = AllIntegerVectors in { |
| let Predicates = GetVTypePredicates<vti>.Predicates in |
| def : Pat<(XLenVT (riscv_vmv_x_s (vti.Vector vti.RegClass:$rs2))), |
| (!cast<Instruction>("PseudoVMV_X_S_" # vti.LMul.MX) $rs2, vti.Log2SEW)>; |
| // vmv.s.x is handled with a custom node in RISCVInstrInfoVVLPatterns.td |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 16.2. Floating-Point Scalar Move Instructions |
| //===----------------------------------------------------------------------===// |
| |
| foreach fvti = AllFloatVectors in { |
| let Predicates = GetVTypePredicates<fvti>.Predicates in { |
| def : Pat<(fvti.Vector (int_riscv_vfmv_s_f (fvti.Vector fvti.RegClass:$rs1), |
| (fvti.Scalar fvti.ScalarRegClass:$rs2), VLOpFrag)), |
| (!cast<Instruction>("PseudoVFMV_S_"#fvti.ScalarSuffix#"_" # |
| fvti.LMul.MX) |
| (fvti.Vector $rs1), |
| (fvti.Scalar fvti.ScalarRegClass:$rs2), |
| GPR:$vl, fvti.Log2SEW)>; |
| |
| def : Pat<(fvti.Vector (int_riscv_vfmv_s_f (fvti.Vector fvti.RegClass:$rs1), |
| (fvti.Scalar (fpimm0)), VLOpFrag)), |
| (!cast<Instruction>("PseudoVMV_S_X_" # fvti.LMul.MX) |
| (fvti.Vector $rs1), (XLenVT X0), GPR:$vl, fvti.Log2SEW)>; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // 16.3. Vector Slide Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatTernaryV_VX_VI<"int_riscv_vslideup", "PseudoVSLIDEUP", AllIntegerVectors, uimm5>; |
| defm : VPatTernaryV_VX_VI<"int_riscv_vslidedown", "PseudoVSLIDEDOWN", AllIntegerVectors, uimm5>; |
| defm : VPatBinaryV_VX<"int_riscv_vslide1up", "PseudoVSLIDE1UP", AllIntegerVectors>; |
| defm : VPatBinaryV_VX<"int_riscv_vslide1down", "PseudoVSLIDE1DOWN", AllIntegerVectors>; |
| |
| defm : VPatTernaryV_VX_VI<"int_riscv_vslideup", "PseudoVSLIDEUP", AllFloatVectors, uimm5>; |
| defm : VPatTernaryV_VX_VI<"int_riscv_vslidedown", "PseudoVSLIDEDOWN", AllFloatVectors, uimm5>; |
| defm : VPatBinaryV_VX<"int_riscv_vfslide1up", "PseudoVFSLIDE1UP", AllFloatVectors>; |
| defm : VPatBinaryV_VX<"int_riscv_vfslide1down", "PseudoVFSLIDE1DOWN", AllFloatVectors>; |
| |
| //===----------------------------------------------------------------------===// |
| // 16.4. Vector Register Gather Instructions |
| //===----------------------------------------------------------------------===// |
| defm : VPatBinaryV_VV_VX_VI_INT<"int_riscv_vrgather", "PseudoVRGATHER", |
| AllIntegerVectors, uimm5>; |
| defm : VPatBinaryV_VV_INT_EEW<"int_riscv_vrgatherei16_vv", "PseudoVRGATHEREI16", |
| eew=16, vtilist=AllIntegerVectors>; |
| |
| defm : VPatBinaryV_VV_VX_VI_INT<"int_riscv_vrgather", "PseudoVRGATHER", |
| AllFloatVectors, uimm5>; |
| defm : VPatBinaryV_VV_INT_EEW<"int_riscv_vrgatherei16_vv", "PseudoVRGATHEREI16", |
| eew=16, vtilist=AllFloatVectors>; |
| //===----------------------------------------------------------------------===// |
| // 16.5. Vector Compress Instruction |
| //===----------------------------------------------------------------------===// |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllIntegerVectors>; |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllIntegerVectors>; |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllIntegerVectors>; |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllFloatVectors>; |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllFloatVectors>; |
| defm : VPatUnaryV_V_AnyMask<"int_riscv_vcompress", "PseudoVCOMPRESS", AllFloatVectors>; |
| |
| // Include the non-intrinsic ISel patterns |
| include "RISCVInstrInfoVVLPatterns.td" |
| include "RISCVInstrInfoVSDPatterns.td" |