xref: /freebsd/contrib/llvm-project/llvm/lib/Target/ARM/ARMScheduleM55.td (revision 5f757f3ff9144b609b3c433dfd370cc6bdc191ad)

//==- ARMScheduleM55.td - Arm Cortex-M55 Scheduling Definitions -*- 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 defines the scheduling model for the Arm Cortex-M55 processors.
//
//===----------------------------------------------------------------------===//

// ===---------------------------------------------------------------------===//
// Cortex-M55 is a lot like the M4/M33 in terms of scheduling. It technically
// has an extra pipeline stage but that is unimportant for scheduling, just
// starting our model a stage later. The main points of interest over an
// Cortex-M4 are MVE instructions and the ability to dual issue thumb1
// instructions.
//
//
// MVE
//
// The EPU pipelines now include both MVE and FP instructions. It has four
// pipelines across 4 stages (E1-E4). These pipelines are "control",
// "load/store", "integer" and "float/mul". We start the schedule at E2 to line
// up with the rest of the pipeline we model, and take the latency as the time
// between reading registers (almost always in E2) and register write (or
// forward, if it allows it). This mean that a lot of instructions (including
// loads) actually take 1 cycle (amazingly).
//
// Each MVE instruction needs to take 2 beats, each performing 64bits of the
// 128bit vector operation. So long as the beats are to different pipelines,
// the execution of the first-beat-of-the-second-instruction can overlap with
// the second-beat-of-the-first. For example a sequence of VLDR;VADD;VMUL;VSTR
// can look like this is a pipeline:
//          1    2    3    4    5
// LD/ST  : VLDR VLDR      VSTR VSTR
// INTEGER:      VADD VADD
// FP/MUL :           VMUL VMUL
//
// But a sequence of VLDR;VLDRB;VADD;VSTR because the loads cannot overlap,
// looks like:
//          1     2     3     4     5    6
// LD/ST  : VLDR  VLDR  VLDRB VLDRB VSTR VSTR
// INTEGER:                   VADD  VADD
//
// For this schedule, we currently model latencies and pipelines well for each
// instruction. MVE instruction take two beats, modelled using
// ReleaseAtCycles=[2].
//
//
// Dual Issue
//
// Cortex-M55 can dual issue two 16-bit T1 instructions providing one is one of
// NOPs, ITs, Brs, ADDri/SUBri, UXTB/H, SXTB/H and MOVri's. NOPs and IT's are
// not relevant (they will not appear when scheduling), Brs are only at the end
// of the block. The others are more useful, and where the problems arise.
//
// The first problem comes from the fact that we will only be seeing Thumb2
// instructions at the point in the pipeline where we do the scheduling. The
// Thumb2SizeReductionPass has not been run yet. Especially pre-ra scheduling
// (where the scheduler has the most freedom) we can only really guess at which
// instructions will become thumb1 instructions. We are quite optimistic, and
// may get some things wrong as a result.
//
// The other problem is one of telling llvm what to do exactly. The way we
// attempt to meld this is:
//  Set IssueWidth to 2 to allow 2 instructions per cycle.
//  All instructions we cannot dual issue are "SingleIssue=1" (MVE/FP and T2
//    instructions)
//  We guess at another set of instructions that will become T1 instruction.
//    These become the primary instruction in a dual issue pair (the normal
//    one). These use normal resources and latencies, but set SingleIssue = 0.
//  We guess at another set of instructions that will be shrank down into T1 DI
//    instructions (add, sub, mov's, etc), which become the secondary. These
//    don't use a resource, and set SingleIssue = 0.
//
// So our guessing is a bit rough. It may be possible to improve this by moving
// T2SizeReduction pass earlier in the pipeline, for example, so that at least
// Post-RA scheduling sees what is T1/T2. It may also be possible to write a
// custom instruction matcher for more accurately guess at T1 instructions.


def CortexM55Model : SchedMachineModel {
  let MicroOpBufferSize = 0;      // Explicitly set to zero since M55 is in-order.
  let IssueWidth = 2;             // There is some dual-issue support in M55.
  let MispredictPenalty = 3;      // Default is 10
  let LoadLatency = 4;            // Default is 4
  let PostRAScheduler = 1;
  let FullInstRWOverlapCheck = 1;

  let CompleteModel = 0;
  let UnsupportedFeatures = [IsARM, HasNEON, HasDotProd, HasMatMulInt8, HasZCZ,
                             IsNotMClass, HasV8, HasV8_3a, HasTrustZone, HasDFB,
                             IsWindows];
}


let SchedModel = CortexM55Model in {

//===----------------------------------------------------------------------===//
// Define each kind of processor resource and number available.

// Modeling each pipeline as a ProcResource using the BufferSize = 0 since
// M55 is in-order.
def M55UnitALU : ProcResource<1> { let BufferSize = 0; } // Int ALU
def M55UnitVecALU : ProcResource<1> { let BufferSize = 0; } // MVE integer pipe
def M55UnitVecFPALU : ProcResource<1> { let BufferSize = 0; } // MVE float pipe
def M55UnitLoadStore : ProcResource<1> { let BufferSize = 0; } // MVE load/store pipe
def M55UnitVecSys : ProcResource<1> { let BufferSize = 0; } // MVE control/sys pipe

// Some VMOV's can go down either pipeline. FIXME: This M55Write2IntFPE2 is
// intended to model the VMOV taking either Int or FP for 2 cycles. It is not
// clear if the llvm scheduler is using it like we want though.
def M55UnitVecIntFP: ProcResGroup<[M55UnitVecALU, M55UnitVecFPALU]>;


//===----------------------------------------------------------------------===//
// Subtarget-specific SchedWrite types which both map the ProcResources and
// set the latency.

//=====//
// ALU //
//=====//

// Generic writes for Flags, GRPs and other extra operands (eg post-inc, vadc flags, vaddlv etc)
def M55WriteLat0  : SchedWriteRes<[]>  { let Latency = 0; let NumMicroOps = 0; }
def M55WriteLat1  : SchedWriteRes<[]>  { let Latency = 1; let NumMicroOps = 0; }
def M55WriteLat2  : SchedWriteRes<[]>  { let Latency = 2; let NumMicroOps = 0; }

// DX instructions are ALU instructions that take a single cycle. The
// instructions that may be shrank to T1 (and can be dual issued) are
// SingleIssue = 0. The others are SingleIssue = 1.
let SingleIssue = 0, Latency = 1 in {
    def : WriteRes<WriteALU, [M55UnitALU]>;
    def : WriteRes<WriteCMP, [M55UnitALU]>;
    def : WriteRes<WriteBr, [M55UnitALU]>;
    def : WriteRes<WriteBrL, [M55UnitALU]>;
    def : WriteRes<WriteBrTbl, [M55UnitALU]>;
    def : WriteRes<WriteST, [M55UnitALU]>;
    def M55WriteDX_DI : SchedWriteRes<[M55UnitALU]>;
}
let SingleIssue = 1, Latency = 1 in {
    def : WriteRes<WritePreLd, [M55UnitALU]>;
    def M55WriteDX_SI : SchedWriteRes<[M55UnitALU]>;
}

def : InstRW<[M55WriteDX_SI], (instregex "t2BF[CI]", "t2CPS", "t2DBG",
          "t2MRS", "t2MSR", "t2SEL", "t2SG", "t2TT")>;
def : InstRW<[M55WriteDX_SI], (instregex "t2SUBS_PC_LR", "COPY")>;
def : InstRW<[M55WriteDX_SI], (instregex "t2CS(EL|INC|INV|NEG)")>;
// Thumb 2 instructions that could be reduced to a thumb 1 instruction and can
// be dual issued with one of the above. This list is optimistic.
def : InstRW<[M55WriteDX_DI], (instregex "t2ADDC?rr$", "t2ADDrr$",
           "t2ADDSrr$", "t2ANDrr$", "t2ASRr[ir]$", "t2BICrr$", "t2CMNzrr$",
           "t2CMPr[ir]$", "t2EORrr$", "t2LSLr[ir]$", "t2LSRr[ir]$", "t2MVNr$",
           "t2ORRrr$", "t2REV(16|SH)?$", "t2RORrr$", "t2RSBr[ir]$", "t2RSBSri$",
           "t2SBCrr$", "t2SUBS?rr$", "t2TEQrr$", "t2TSTrr$", "t2STRi12$",
           "t2STRs$", "t2STRBi12$", "t2STRBs$", "t2STRHi12$", "t2STRHs$",
           "t2STR_POST$", "t2STMIA$", "t2STMIA_UPD$", "t2STMDB$", "t2STMDB_UPD$")>;
def : InstRW<[M55WriteDX_DI], (instregex "t2SETPAN$", "tADC$", "tADDhirr$",
           "tADDrSP$", "tADDrSPi$", "tADDrr$", "tADDspi$", "tADDspr$", "tADR$",
           "tAND$", "tASRri$", "tASRrr$", "tBIC$", "tBKPT$", "tCBNZ$", "tCBZ$",
           "tCMNz$", "tCMPhir$", "tCMPi8$", "tCMPr$", "tCPS$", "tEOR$", "tHINT$",
           "tHLT$", "tLSLri$", "tLSLrr$", "tLSRri$", "tLSRrr$", "tMOVSr$",
           "tMUL$", "tMVN$", "tORR$", "tPICADD$", "tPOP$", "tPUSH$", "tREV$",
           "tREV16$", "tREVSH$", "tROR$", "tRSB$", "tSBC$", "tSETEND$",
           "tSTMIA_UPD$", "tSTRBi$", "tSTRBr$", "tSTRHi$", "tSTRHr$", "tSTRi$",
           "tSTRr$", "tSTRspi$", "tSUBrr$", "tSUBspi$", "tSVC$", "tTRAP$",
           "tTST$", "tUDF$")>;
def : InstRW<[M55WriteDX_DI], (instregex "tB$", "tBLXNSr$", "tBLXr$", "tBX$",
           "tBXNS$", "tBcc$")>;


// CX instructions take 2 (or more) cycles. Again T1 instructions may be dual
// issues (SingleIssue = 0)
let SingleIssue = 0, Latency = 2 in {
    def : WriteRes<WriteLd, [M55UnitALU]>;
    def M55WriteCX_DI  : SchedWriteRes<[M55UnitALU]>;
}
let SingleIssue = 1, Latency = 2 in {
    def : WriteRes<WriteALUsi, [M55UnitALU]>;
    def : WriteRes<WriteALUsr, [M55UnitALU]>;
    def : WriteRes<WriteALUSsr, [M55UnitALU]>;
    def : WriteRes<WriteCMPsi, [M55UnitALU]>;
    def : WriteRes<WriteCMPsr, [M55UnitALU]>;
    def : WriteRes<WriteDIV, [M55UnitALU]>;
    def M55WriteCX_SI  : SchedWriteRes<[M55UnitALU]>;
}

def : SchedAlias<WriteMUL16, M55WriteCX_SI>;
def : SchedAlias<WriteMUL32, M55WriteCX_SI>;
def : SchedAlias<WriteMUL64Lo, M55WriteCX_SI>;
def : WriteRes<WriteMUL64Hi, []> { let Latency = 2; }
def : SchedAlias<WriteMAC16, M55WriteCX_SI>;
def : SchedAlias<WriteMAC32, M55WriteCX_SI>;
def : SchedAlias<WriteMAC64Lo, M55WriteCX_SI>;
def : WriteRes<WriteMAC64Hi, []> { let Latency = 2; }

def : InstRW<[M55WriteCX_SI], (instregex "t2CDP", "t2CLREX", "t2[DI][MS]B",
           "t2MCR", "t2MOVSs[ir]", "t2MRC", "t2MUL", "t2STC")>;
def : InstRW<[M55WriteCX_SI], (instregex "t2Q", "t2[SU](ADD|ASX|BFX|DIV)",
           "t2[SU]H(ADD|ASX|SUB|SAX)", "t2SM[LM]", "t2S(SAT|SUB|SAX)", "t2UQ",
           "t2USA", "t2USUB", "t2UXTA[BH]")>;
def : InstRW<[M55WriteCX_SI], (instregex "t2LD[AC]", "t2STL", "t2STRD")>;
def : InstRW<[M55WriteCX_SI], (instregex "MVE_[SU]Q?R?SH[LR]$")>;
def : InstRW<[M55WriteCX_SI, M55WriteLat2], (instregex "MVE_ASRL", "MVE_LSLL",
            "MVE_LSRL", "MVE_[SU]Q?R?SH[LR]L")>;
// This may be higher in practice, but that likely doesn't make a difference
// for scheduling
def : InstRW<[M55WriteCX_SI], (instregex "t2CLRM")>;

def : InstRW<[M55WriteCX_DI], (instregex "t2LDR[BH]?i12$", "t2LDRS?[BH]?s$",
           "t2LDM")>;
def : InstRW<[M55WriteCX_DI], (instregex "tLDM", "tLDRBi$", "tLDRBr$",
           "tLDRHi$", "tLDRHr$", "tLDRSB$", "tLDRSH$", "tLDRi$", "tLDRpci$",
           "tLDRr$", "tLDRspi$")>;

// Dual Issue instructions
let Latency = 1, SingleIssue = 0 in {
    def : WriteRes<WriteNoop, []>;
    def M55WriteDI : SchedWriteRes<[]>;
}

def : InstRW<[M55WriteDI], (instregex "tADDi[38]$", "tSUBi[38]$", "tMOVi8$",
           "tMOVr$", "tUXT[BH]$", "tSXT[BH]$")>;
// Thumb 2 instructions that could be reduced to a dual issuable Thumb 1
// instruction above.
def : InstRW<[M55WriteDI], (instregex "t2ADDS?ri$", "t2MOV[ir]$", "t2MOVi16$",
           "t2MOVr$", "t2SUBS?ri$", "t2[US]XT[BH]$")>;
def : InstRW<[M55WriteDI], (instregex "t2IT", "IT")>;


def : InstRW<[M55WriteLat0], (instregex "t2LoopDec")>;

// Forwarding

// No forwarding in the ALU normally
def : ReadAdvance<ReadALU, 0>;
def : ReadAdvance<ReadALUsr, 0>;
def : ReadAdvance<ReadMUL, 0>;
def : ReadAdvance<ReadMAC, 0>;

//=============//
// MVE and VFP //
//=============//

// The Writes that take ReleaseAtCycles=[2] are MVE instruction, the others VFP.

let SingleIssue = 1, Latency = 1 in {
  def M55WriteLSE2 : SchedWriteRes<[M55UnitLoadStore]>;
  def M55WriteIntE2 : SchedWriteRes<[M55UnitVecALU]>;
  def M55WriteFloatE2 : SchedWriteRes<[M55UnitVecFPALU]>;
  def M55WriteSysE2 : SchedWriteRes<[M55UnitVecSys]>;

  def M55Write2LSE2 : SchedWriteRes<[M55UnitLoadStore]> { let ReleaseAtCycles=[2]; }
  def M55Write2IntE2 : SchedWriteRes<[M55UnitVecALU]> { let ReleaseAtCycles=[2]; }
  def M55Write2FloatE2 : SchedWriteRes<[M55UnitVecFPALU]> { let ReleaseAtCycles=[2]; }
  def M55Write2IntFPE2 : SchedWriteRes<[M55UnitVecIntFP]> { let ReleaseAtCycles=[2]; }
}

let SingleIssue = 1, Latency = 2 in {
  def M55WriteLSE3 : SchedWriteRes<[M55UnitLoadStore]>;
  def M55WriteIntE3 : SchedWriteRes<[M55UnitVecALU]>;
  def M55WriteFloatE3 : SchedWriteRes<[M55UnitVecFPALU]>;

  def M55Write2LSE3 : SchedWriteRes<[M55UnitLoadStore]> { let ReleaseAtCycles=[2]; }
  def M55Write2IntE3 : SchedWriteRes<[M55UnitVecALU]> { let ReleaseAtCycles=[2]; }
  def M55Write2FloatE3 : SchedWriteRes<[M55UnitVecFPALU]> { let ReleaseAtCycles=[2]; }
}

let SingleIssue = 1, Latency = 3 in {
  def M55Write2IntE3Plus1 : SchedWriteRes<[M55UnitVecALU]> { let ReleaseAtCycles=[2]; }

  // Same as M55Write2IntE3/M55Write2FloatE3 above, but longer latency and no forwarding into stores
  def M55Write2IntE4NoFwd : SchedWriteRes<[M55UnitVecALU]> { let ReleaseAtCycles=[2]; }
  def M55Write2FloatE4NoFwd : SchedWriteRes<[M55UnitVecFPALU]> { let ReleaseAtCycles=[2]; }
}
let SingleIssue = 1, Latency = 4 in {
  def M55Write2IntE3Plus2 : SchedWriteRes<[M55UnitVecALU]> { let ReleaseAtCycles=[2]; }
  def M55WriteFloatE3Plus2 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 9 in {
  def M55WriteFloatE3Plus7 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 15 in {
  def M55WriteFloatE3Plus13 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 16 in {
  def M55WriteFloatE3Plus14 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 21 in {
  def M55WriteFloatE3Plus19 : SchedWriteRes<[M55UnitVecFPALU]>;
}
// VMUL (Double precision) + VADD (Double precision)
let SingleIssue = 1, Latency = 24 in {
  def M55WriteFloatE3Plus22 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 30 in {
  def M55WriteFloatE3Plus28 : SchedWriteRes<[M55UnitVecFPALU]>;
}
let SingleIssue = 1, Latency = 36 in {
  def M55WriteFloatE3Plus34 : SchedWriteRes<[M55UnitVecFPALU]>;
}

def M55Read0 : SchedReadAdvance<0>;
def M55Read1 : SchedReadAdvance<1, [M55Write2LSE3, M55Write2IntE3, M55Write2FloatE3]>;
def M55GatherQRead : SchedReadAdvance<-4>;

// MVE instructions

// Loads and Stores of different kinds

// Normal loads
def : InstRW<[M55Write2LSE2], (instregex "MVE_VLDR(B|H|W)(S|U)(8|16|32)$")>;
// Pre/post inc loads
def : InstRW<[M55WriteLat1, M55Write2LSE2], (instregex "MVE_VLDR(B|H|W)(S|U)(8|16|32)_(post|pre)$")>;
// Gather loads
def : InstRW<[M55Write2LSE3, M55Read0, M55GatherQRead], (instregex "MVE_VLDR(B|H|W|D)(S|U)(8|16|32|64)_rq")>;
def : InstRW<[M55Write2LSE3, M55GatherQRead], (instregex "MVE_VLDR(B|H|W|D)(S|U)(8|16|32|64)_qi$")>;
def : InstRW<[M55WriteLat1, M55Write2LSE3, M55GatherQRead], (instregex "MVE_VLDR(W|D)U(32|64)_qi_pre$")>;
// Interleaving loads
def : InstRW<[M55Write2LSE2], (instregex "MVE_VLD[24][0-3]_(8|16|32)$")>;
// Interleaving loads with wb
def : InstRW<[M55Write2LSE2, M55WriteLat1], (instregex "MVE_VLD[24][0-3]_(8|16|32)_wb$")>;

// Normal stores
def : InstRW<[M55Write2LSE2, M55Read1], (instregex "MVE_VSTR(B|H|W)U?(8|16|32)$")>;
// Pre/post inc stores
def : InstRW<[M55Write2LSE2, M55Read1], (instregex "MVE_VSTR(B|H|W)U?(8|16|32)_(post|pre)$")>;
// Scatter stores
def : InstRW<[M55Write2LSE2, M55Read0, M55Read0, M55GatherQRead], (instregex "MVE_VSTR(B|H|W|D)(8|16|32|64)_rq")>;
def : InstRW<[M55Write2LSE2, M55Read0, M55GatherQRead], (instregex "MVE_VSTR(B|H|W|D)(8|16|32|64)_qi")>;
// Interleaving stores
def : InstRW<[M55Write2LSE2], (instregex "MVE_VST(2|4)")>;

// Integer pipe operations

def : InstRW<[M55Write2IntE3Plus1], (instregex "MVE_VABAV")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VABD(u|s)")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VABS(u|s)")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_VADC")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VADD(_qr_)?i")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VAND")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VBIC")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VBRSR")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VCADDi")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VCLS")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VCLZ")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_V(D|I)?W?DUP")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VEOR")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VHADD")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VHCADD")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VHSUB")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_V(MAX|MIN)A?(s|u)")>;
def : InstRW<[M55Write2IntE3Plus2], (instregex "MVE_V(MAX|MIN)A?V(s|u)8")>;
def : InstRW<[M55Write2IntE3Plus1], (instregex "MVE_V(MAX|MIN)A?V(s|u)16")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_V(MAX|MIN)A?V(s|u)32")>;
def : InstRW<[M55Write2IntE4NoFwd], (instregex "MVE_VMOVN")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VMOVL")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_VMULL[BT]p")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VMVN")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VNEG(u|s)")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VORN")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VORR")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VPSEL")>;
def : InstRW<[M55Write2IntE2], (instregex "MQPRCopy")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VQABS")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VQADD")>;
def : InstRW<[M55Write2IntE4NoFwd], (instregex "MVE_VQMOV")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VQNEG")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VSHL")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_V[QR]SHL")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_VQRSHL")>;
def : InstRW<[M55Write2IntE4NoFwd], (instregex "MVE_VQ?R?SHRU?N")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VSHR_")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_VRSHR_")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VQSUB")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VREV")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VRHADD")>;
def : InstRW<[M55Write2IntE3], (instregex "MVE_VSBC")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VSLI")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VSRI")>;
def : InstRW<[M55Write2IntE2], (instregex "MVE_VSUB(_qr_)?i")>;

// FP/Mul pipe operations.

def : InstRW<[M55Write2FloatE2], (instregex "MVE_VABDf")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VABSf")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VADDf")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VADD_qr_f")>;
def : InstRW<[M55Write2FloatE3, M55WriteLat1], (instregex "MVE_VADDLV")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VADDV")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VCADDf")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCMLA")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCMUL")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VCMP(i|s|u)", "MVE_VPTv(4|8|16)(i|s|u)")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VCMPf", "MVE_VPTv(4|8)f")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCVTf16(u|s)16")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCVTf32(u|s)32")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCVT(u|s)16f16")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCVT(u|s)32f32")>;
def : InstRW<[M55Write2FloatE4NoFwd], (instregex "MVE_VCVTf16f32")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VCVTf32f16")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VFM(A|S)")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_V(MIN|MAX)NM")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VMOV_from_lane")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VMOV_rr_q")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VMOVi")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VMUL(_qr_)?[if]")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VQ?R?D?MULH")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VQ?D?MULL[TB]?[su]")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VQDMULL_qr_")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VQ?R?D?ML(A|S)[^L]")>;
def : InstRW<[M55Write2FloatE3, M55WriteLat1], (instregex "MVE_VR?ML(A|S)L")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VNEGf")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VRINTf")>;
def : InstRW<[M55Write2FloatE2], (instregex "MVE_VSUBf")>;
def : InstRW<[M55Write2FloatE3], (instregex "MVE_VSUB_qr_f")>;

// Some VMOV's can go down either pipeline.
def : InstRW<[M55Write2IntFPE2], (instregex "MVE_VMOV_to_lane", "MVE_VMOV_q_rr")>;

def : InstRW<[M55WriteSysE2], (instregex "MVE_VCTP")>;
def : InstRW<[M55WriteSysE2], (instregex "MVE_VPNOT")>;
def : InstRW<[M55WriteSysE2], (instregex "MVE_VPST")>;


// VFP instructions

def : SchedAlias<WriteFPCVT, M55WriteFloatE3>;
def : SchedAlias<WriteFPMOV, M55WriteFloatE3>;
def : SchedAlias<WriteFPALU32, M55WriteFloatE3>;
def : SchedAlias<WriteFPALU64, M55WriteFloatE3Plus13>;
def : SchedAlias<WriteFPMUL32, M55WriteFloatE3>;
def : SchedAlias<WriteFPMUL64, M55WriteFloatE3Plus19>;
def : SchedAlias<WriteFPMAC32, M55WriteFloatE3Plus2>;
def : SchedAlias<WriteFPMAC64, M55WriteFloatE3Plus34>;
def : SchedAlias<WriteFPDIV32, M55WriteFloatE3Plus14>;
def : SchedAlias<WriteFPDIV64, M55WriteFloatE3Plus28>;
def : SchedAlias<WriteFPSQRT32, M55WriteFloatE3Plus14>;
def : SchedAlias<WriteFPSQRT64, M55WriteFloatE3Plus28>;
def : ReadAdvance<ReadFPMUL, 0>;
def : ReadAdvance<ReadFPMAC, 0>;

def : InstRW<[M55WriteLSE3], (instregex "VLD")>;
def : InstRW<[M55WriteLSE2], (instregex "VST")>;
def : InstRW<[M55WriteLSE3], (instregex "VLLD", "VLST")>;

def : InstRW<[M55WriteFloatE3], (instregex "VABS(H|S|D)")>;
def : InstRW<[M55WriteFloatE3], (instregex "VCVT(A|M|N|P|R|X|Z)(S|U)(H|S|D)")>;
def : InstRW<[M55WriteFloatE3], (instregex "VCVT(B|T)(DH|HD)")>;
def : InstRW<[M55WriteFloatE2], (instregex "VCMPZ?(E|H|S|D)")>;
def : InstRW<[M55WriteFloatE3Plus7], (instregex "VDIVH")>;
def : InstRW<[M55WriteFloatE3], (instregex "VFN?M(A|S)(H|S)")>; // VFMA
def : InstRW<[M55WriteFloatE3Plus22], (instregex "VFN?M(A|S)D")>; // VFMA
def : InstRW<[M55WriteFloatE3], (instregex "VFP_V(MAX|MIN)NM")>;
def : InstRW<[M55WriteFloatE3], (instregex "VINSH$", "VMOVH$", "VMOVHR$", "VMOVSR$", "VMOVDRR$")>; // VINS, VMOVX, to-FP reg movs
def : InstRW<[M55WriteFloatE2], (instregex "VMOVD$", "VMOVS$", "VMOVR")>; // Other VMOV's
def : InstRW<[M55WriteFloatE2], (instregex "FCONSTH", "FCONSTS", "FCONSTD")>;
def : InstRW<[M55WriteFloatE2], (instregex "VGETLNi32", "VSETLNi32")>;
def : InstRW<[M55WriteFloatE2], (instregex "VMSR", "VMRS")>;
def : InstRW<[M55WriteFloatE3Plus2], (instregex "VN?ML(A|S)H")>; // VMLA
def : InstRW<[M55WriteFloatE3], (instregex "VNEG(H|S|D)")>;
def : InstRW<[M55WriteFloatE3], (instregex "VRINT(A|M|N|P|R|X|Z)(H|S|D)")>;
def : InstRW<[M55WriteFloatE3], (instregex "VSEL..(H|S|D)")>;
def : InstRW<[M55WriteFloatE3Plus7], (instregex "VSQRTH")>;

def : WriteRes<WriteVLD1, []>;
def : WriteRes<WriteVLD2, []>;
def : WriteRes<WriteVLD3, []>;
def : WriteRes<WriteVLD4, []>;
def : WriteRes<WriteVST1, []>;
def : WriteRes<WriteVST2, []>;
def : WriteRes<WriteVST3, []>;
def : WriteRes<WriteVST4, []>;

}