//=- AArch64SchedOryon.td - Qualcomm Oryon CPU 001 ---*- 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 Qualcomm Oryon
// family of processors.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// Pipeline Description.
def OryonModel : SchedMachineModel {
let IssueWidth = 14;
let MicroOpBufferSize = 376;
let LoadLatency = 4;
let MispredictPenalty = 13; // 13 cycles for mispredicted branch.
let LoopMicroOpBufferSize = 0; // Do not have a LoopMicroOpBuffer
let PostRAScheduler = 1; // Using PostRA sched.
let CompleteModel = 1;
list<Predicate> UnsupportedFeatures = !listconcat(SVEUnsupported.F,
SMEUnsupported.F,
MTEUnsupported.F,
PAUnsupported.F,
[HasPAuth, HasCSSC]);
}
let SchedModel = OryonModel in {
// Issue ports.
// IXU has 6 ports p0 ~ p5
// LSU has 4 ports p6 ~ p9(ls0 ~ ls3), p10/p11(std0, std1) has to work with ls0~ls3
// VXU has 4 ports p12 ~ p15
// cross IXU/LSU/VXU resource group for FMOV P41 of VXU
// I2V
def ORYONI4FP0 : ProcResource<1>;
def ORYONI5FP1 : ProcResource<1>;
// V2I
def ORYONFP0I4 : ProcResource<1>;
def ORYONFP1I5 : ProcResource<1>;
// store 1 for normal store instructions
def ORYONST0 : ProcResource<1>;
// store 2 for normal store instructions
def ORYONST1 : ProcResource<1>;
// Port 0: ALU/Indirect/Direct Branch.
def ORYONP0 : ProcResource<1>;
// Port 1: ALU/Direct Branch.
def ORYONP1 : ProcResource<1>;
// Port 2: ALU.
def ORYONP2 : ProcResource<1>;
// Port 3: ALU.
def ORYONP3 : ProcResource<1>;
// Port 4: ALU.
def ORYONP4 : ProcResource<1> {
let Super = ORYONI4FP0;
let Super = ORYONFP0I4; }
// Port 5: ALU.
def ORYONP5 : ProcResource<1> {
let Super = ORYONI5FP1;
let Super = ORYONFP1I5; }
// Port 6: Load/Store. LS0
def ORYONP6 : ProcResource<1> {
let Super = ORYONST0; }
// Port 7: Load/store. LS1
def ORYONP7 : ProcResource<1> {
let Super = ORYONST0; }
// Port 8: Load/Store. LS2
def ORYONP8 : ProcResource<1> {
let Super = ORYONST1; }
// Port 9: Load/store. LS3
def ORYONP9 : ProcResource<1> {
let Super = ORYONST1; }
// Port 10: Load/Store. STD0
def ORYONP10SD0 : ProcResource<1> {
let Super = ORYONST0; }
// Port 11: Load/store. STD1
def ORYONP11SD1 : ProcResource<1> {
let Super = ORYONST1; }
// Port 12: FP/Neon/SIMD/Crypto.
def ORYONP12FP0 : ProcResource<1> {
let Super = ORYONI4FP0;
let Super = ORYONFP0I4; }
// Port 13: FP/Neon/SIMD/Crypto.
def ORYONP13FP1 : ProcResource<1> {
let Super = ORYONI5FP1;
let Super = ORYONFP1I5; }
// Port 14: FP/Neon/SIMD/Crypto.
def ORYONP14FP2 : ProcResource<1>;
// Port 15: FP/Neon/SIMD/Crypto.
def ORYONP15FP3 : ProcResource<1>;
// Define groups for the functional units on each issue port. Each group
// created will be used by a WriteRes.
// Integer add/shift/logical/misc. instructions on port I0/I1/I2/I3/I4/I5.
def ORYONI012345 : ProcResGroup<[ORYONP0, ORYONP1, ORYONP2,
ORYONP3, ORYONP4, ORYONP5]> {
let BufferSize = 120;
}
// Direct Conditional Branch instructions on ports I0/I1.
def ORYONI01 : ProcResGroup<[ORYONP0, ORYONP1]> {
let BufferSize = 40;
}
// Indirect/crypto Conditional Branch instructions on ports I0.
def ORYONI0 : ProcResGroup<[ORYONP0]> {
let BufferSize = 20;
}
// Crypto/CRC/PAU instructions on ports I2.
def ORYONI2 : ProcResGroup<[ORYONP2]> {
let BufferSize = 20;
}
// Multiply/Multiply-ADD instructions on ports I4/I5.
def ORYONI45 : ProcResGroup<[ORYONP4, ORYONP5]> {
let BufferSize = 40;
}
// Divide instructions on ports I5.
def ORYONI5 : ProcResGroup<[ORYONP5]> {
let BufferSize = 20;
}
// Comparison instructions on ports I0/I1/I2/I3.
def ORYONI0123 : ProcResGroup<[ORYONP0, ORYONP1,
ORYONP2, ORYONP3]> {
let BufferSize = 80;
}
// Load instructions on ports P6/P7/P8/P9.
def ORYONLD : ProcResGroup<[ORYONP6, ORYONP7, ORYONP8, ORYONP9]> {
let BufferSize = 64;
}
// Store instructions on combo of STA/STD pipes
def ORYONST : ProcResGroup<[ORYONST0, ORYONST1]> {
let BufferSize = 64;
}
// Arithmetic and CRYP-AED ASIMD/FP instructions on ports FP0/FP1/FP2/FP3.
def ORYONFP0123 : ProcResGroup<[ORYONP12FP0, ORYONP13FP1,
ORYONP14FP2, ORYONP15FP3]> {
let BufferSize = 192;
}
// FP Comparison and F/I move instructions on ports FP0/FP1.
def ORYONFP01 : ProcResGroup<[ORYONP12FP0, ORYONP13FP1]> {
let BufferSize = 96;
}
// FDIV instructions on ports FP3.
def ORYONFP3 : ProcResGroup<[ORYONP15FP3]> {
let BufferSize = 48;
}
// CRYP-SHA instructions on ports FP1.
def ORYONFP1 : ProcResGroup<[ORYONP14FP2]> {
let BufferSize = 48;
}
def ORYONFP2 : ProcResGroup<[ORYONP14FP2]> {
let BufferSize = 48;
}
// Reciprocal, Squre root on FP0.
def ORYONFP0 : ProcResGroup<[ORYONP12FP0]> {
let BufferSize = 48;
}
// cross IXU/LSU/VXU resource group for FMOV P41 of VXU
// I2V
def ORYONI2V : ProcResGroup<[ORYONI4FP0, ORYONI5FP1]> {
let BufferSize = 40;
}
// V2I
def ORYONV2I : ProcResGroup<[ORYONFP0I4, ORYONFP1I5]> {
let BufferSize = 96;
}
// Define commonly used write types for InstRW specializations.
// All definitions follow the format: ORYONWrite_<NumCycles>Cyc_<Resources>.
// Because of the complexity of Oryon CPU, we skip the following
// generic definitions and define each instruction specifically
// These WriteRes entries are not used in the Falkor sched model.
def : WriteRes<WriteImm, []> { let Unsupported = 1; }
def : WriteRes<WriteI, []> { let Unsupported = 1; }
def : WriteRes<WriteISReg, []> { let Unsupported = 1; }
def : WriteRes<WriteIEReg, []> { let Unsupported = 1; }
def : WriteRes<WriteExtr, []> { let Unsupported = 1; }
def : WriteRes<WriteIS, []> { let Unsupported = 1; }
def : WriteRes<WriteID32, []> { let Unsupported = 1; }
def : WriteRes<WriteID64, []> { let Unsupported = 1; }
def : WriteRes<WriteIM32, []> { let Unsupported = 1; }
def : WriteRes<WriteIM64, []> { let Unsupported = 1; }
def : WriteRes<WriteBr, []> { let Unsupported = 1; }
def : WriteRes<WriteBrReg, []> { let Unsupported = 1; }
def : WriteRes<WriteLD, []> { let Unsupported = 1; }
def : WriteRes<WriteST, []> { let Unsupported = 1; }
def : WriteRes<WriteSTP, []> { let Unsupported = 1; }
def : WriteRes<WriteAdr, []> { let Unsupported = 1; }
def : WriteRes<WriteLDIdx, []> { let Unsupported = 1; }
def : WriteRes<WriteSTIdx, []> { let Unsupported = 1; }
def : WriteRes<WriteF, []> { let Unsupported = 1; }
def : WriteRes<WriteFCmp, []> { let Unsupported = 1; }
def : WriteRes<WriteFCvt, []> { let Unsupported = 1; }
def : WriteRes<WriteFCopy, []> { let Unsupported = 1; }
def : WriteRes<WriteFImm, []> { let Unsupported = 1; }
def : WriteRes<WriteFMul, []> { let Unsupported = 1; }
def : WriteRes<WriteFDiv, []> { let Unsupported = 1; }
def : WriteRes<WriteVd, []> { let Unsupported = 1; }
def : WriteRes<WriteVq, []> { let Unsupported = 1; }
def : WriteRes<WriteVLD, []> { let Unsupported = 1; }
def : WriteRes<WriteVST, []> { let Unsupported = 1; }
def : WriteRes<WriteSys, []> { let Unsupported = 1; }
def : WriteRes<WriteBarrier, []> { let Unsupported = 1; }
def : WriteRes<WriteHint, []> { let Unsupported = 1; }
def : WriteRes<WriteLDHi, []> { let Unsupported = 1; }
def : WriteRes<WriteAtomic, []> { let Unsupported = 1; }
// These ReadAdvance entries will be defined in later implementation
def : ReadAdvance<ReadI, 0>;
def : ReadAdvance<ReadISReg, 0>;
def : ReadAdvance<ReadIEReg, 0>;
def : ReadAdvance<ReadIM, 0>;
def : ReadAdvance<ReadIMA, 0>;
def : ReadAdvance<ReadID, 0>;
def : ReadAdvance<ReadExtrHi, 0>;
def : ReadAdvance<ReadAdrBase, 0>;
def : ReadAdvance<ReadVLD, 0>;
def : ReadAdvance<ReadST, 0>;
//IXU resource definition
// 1 cycles NO pipe
def ORYONWrite_1Cyc_NONE : SchedWriteRes<[]>;
// 1 cycles on I01.
def ORYONWrite_1Cyc_I01 : SchedWriteRes<[ORYONI01]>;
def ORYONWrite_1Cyc_2Uops_I01 : SchedWriteRes<[ORYONI01]> {
let NumMicroOps = 2;
}
def ORYONWrite_1Cyc_I0 : SchedWriteRes<[ORYONI0]>;
// 7 cycles on I2. PAC*/AUT* instructions
def ORYONWrite_7Cyc_I2 : SchedWriteRes<[ORYONI2]> {
let Latency = 7;
}
// 7 cycles on I2. PAC*/AUT* instructions
def ORYONWrite_7Cyc_3Uops_I2 : SchedWriteRes<[ORYONI2]> {
let Latency = 7;
let NumMicroOps = 3;
}
// 9 (7+1+1) cycles on I2 and I0/I1, I0. Authentication branch instructions
// these instructions are broken down to three uops
// a. PtrAuth on pipe 2 taking 7 cycles
// b. Link Register Update on pipes 0 and 1 taking 1 cycle
// c. Indirect branch on pipe 0 taking 1 cycle
def ORYONWrite_9Cyc_I012 : SchedWriteRes<[ORYONI2, ORYONI01]> {
let Latency = 9;
let NumMicroOps = 3;
}
// 3 cycles on I2. CRC32 and CRC32C instructions
def ORYONWrite_3Cyc_I2 : SchedWriteRes<[ORYONI2]> {
let Latency = 3;
}
// 1 cycle on I012345
def ORYONWrite_1Cyc_I012345 : SchedWriteRes<[ORYONI012345]>;
// 1 cycle on I0123
def ORYONWrite_1Cyc_I0123 : SchedWriteRes<[ORYONI0123]>;
// 1 cycle on 2 of I012345
def ORYONWrite_1Cyc_I012345_I012345 :
SchedWriteRes<[ORYONI012345, ORYONI012345]> ;
// 2 cycle on 2 of I0123 with ReleaseAtCycles
def ORYONWrite_2Cyc_I0123_I0123_RC :
SchedWriteRes<[ORYONI0123, ORYONI0123]> {
let Latency = 2;
let ReleaseAtCycles = [2,2];
}
// 2 cycle on 2 of I012345
def ORYONWrite_2Cyc_I012345_I012345_RC :
SchedWriteRes<[ORYONI012345, ORYONI012345]> {
let Latency = 2;
let ReleaseAtCycles = [2,2];
}
// 3 cycle on 2 of I45
def ORYONWrite_3Cyc_I45_I45_RC :
SchedWriteRes<[ORYONI45, ORYONI45]> {
let Latency = 3;
let ReleaseAtCycles = [2,2];
}
// 3 cycle on I45
def ORYONWrite_3Cyc_I45 : SchedWriteRes<[ORYONI45]> {
let Latency = 3;
}
// 7 cycle on I2 32-bit integer division
def ORYONWrite_7Cyc_I2_RC : SchedWriteRes<[ORYONI2]> {
let Latency = 7;
let ReleaseAtCycles = [2];
}
// 9 cycle on I2 64-bit integer division
def ORYONWrite_9Cyc_I2_RC : SchedWriteRes<[ORYONI2]> {
let Latency = 9;
let ReleaseAtCycles = [2];
}
// LSU resource definition
// need to define WriteLDAdr, WriteAdrAdr, WriteLDHi, WriteSTX
// 4 cycle on LS(P6789)
def ORYONWrite_4Cyc_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 4;
}
// 4 cycle for Post/Pre inc/dec access, also covers all pair loads Post/Pre
def ORYONWrite_4Cyc_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 4;
}
// 5 (4+1) for VXU SIMD access/could also include FP
// resource might not be correct, as VXU resource not included
def ORYONWrite_5Cyc_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
}
def ORYONWrite_5Cyc_2Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 2;
}
def ORYONWrite_5Cyc_3Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 3;
}
def ORYONWrite_5Cyc_4Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 4;
}
def ORYONWrite_5Cyc_5Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 5;
}
def ORYONWrite_5Cyc_6Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 6;
}
def ORYONWrite_5Cyc_8Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 8;
}
def ORYONWrite_5Cyc_10Uops_LD : SchedWriteRes<[ORYONLD]> {
let Latency = 5;
let NumMicroOps = 10;
}
// 6 cycle for Post/Pre inc/dec access
def ORYONWrite_5Cyc_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
}
def ORYONWrite_5Cyc_2Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 2;
}
def ORYONWrite_5Cyc_3Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 3;
}
def ORYONWrite_5Cyc_4Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 4;
}
def ORYONWrite_5Cyc_5Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 5;
}
def ORYONWrite_5Cyc_6Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 6;
}
def ORYONWrite_5Cyc_8Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 8;
}
def ORYONWrite_5Cyc_10Uops_LD_I012345 : SchedWriteRes<[ORYONLD, ORYONI012345]> {
let Latency = 5;
let NumMicroOps = 10;
}
// 1 cycle for all generic stores
def ORYONWrite_1Cyc_ST : SchedWriteRes<[ORYONST]>;
def ORYONWrite_1Cyc_2Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 2;
}
def ORYONWrite_1Cyc_3Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 3;
}
def ORYONWrite_1Cyc_4Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 4;
}
def ORYONWrite_1Cyc_5Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 5;
}
def ORYONWrite_1Cyc_6Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 6;
}
def ORYONWrite_1Cyc_8Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 8;
}
def ORYONWrite_1Cyc_10Uops_ST : SchedWriteRes<[ORYONST]> {
let NumMicroOps = 10;
}
// 1 cycle for neon write: float + ASIMD with Post/Pre Inc/Dec access
// also includes Pair store until further informed
def ORYONWrite_1Cyc_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 3;
}
def ORYONWrite_1Cyc_2Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 2;
}
def ORYONWrite_1Cyc_3Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 3;
}
def ORYONWrite_1Cyc_4Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 4;
}
def ORYONWrite_1Cyc_5Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 5;
}
def ORYONWrite_1Cyc_6Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 6;
}
def ORYONWrite_1Cyc_8Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 8;
}
def ORYONWrite_1Cyc_10Uops_ST_I012345 : SchedWriteRes<[ORYONST, ORYONI012345]> {
let NumMicroOps = 10;
}
// VXU resource definition
// I2V instruction has 1 uOp
// I2v with convert has 2 uOps
// all I2V, V2I's throughputs are 2
// On VXU doc, p37 -- latencies and throughput
// P41, resource taken, P42, uOps
def ORYONWrite_I2V_4Cyc_I45 : SchedWriteRes<[ORYONI2V]> {
let Latency = 4;
}
// inline a FCVT, so add one more uOp
def ORYONWrite_I2V_7Cyc_I45 : SchedWriteRes<[ORYONI2V]> {
let Latency = 7;
let NumMicroOps = 2;
}
// V2I move instruction has 1/2 uOps, P42 in VXU doc
// Latency is 3, FCVT is also 3 cycle
// move + convert is 6 (3+3) cycles
// throughput is 2
def ORYONWrite_V2I_3Cyc_FP01 : SchedWriteRes<[ORYONV2I]> {
let Latency = 3;
}
// inline a FCVT, so add one more uOp
def ORYONWrite_V2I_6Cyc_FP01 : SchedWriteRes<[ORYONV2I]> {
let Latency = 6;
let NumMicroOps = 2;
}
def ORYONWrite_V2V_2Cyc_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 2;
}
def ORYONWrite_V2V_3Cyc_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 3;
}
def ORYONWrite_V2V_6Cyc_FP01 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 6;
let NumMicroOps = 3;
}
def ORYONWrite_4Cyc_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 4;
}
def ORYONWrite_3Cyc_FP0 : SchedWriteRes<[ORYONFP0]> {
let Latency = 3;
}
def ORYONWrite_3Cyc_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 3;
}
def ORYONWrite_3Cyc_2Uops_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 3;
let NumMicroOps = 2;
}
def ORYONWrite_2Cyc_FP0123 : SchedWriteRes<[ORYONFP0123]> {
let Latency = 2;
}
def ORYONWrite_2Cyc_FP01 : SchedWriteRes<[ORYONFP01]> {
let Latency = 2;
}
// 2 cycle on FP1
def ORYONWrite_2Cyc_FP1 : SchedWriteRes<[ORYONFP1]> {
let Latency = 2;
}
// 3 cycle on FP1
def ORYONWrite_3Cyc_FP1 : SchedWriteRes<[ORYONFP1]> {
let Latency = 3;
}
// 4 cycle , 0.5 throughput on FP1
def ORYONWrite_4Cyc_FP1_RC4 : SchedWriteRes<[ORYONFP1]> {
let Latency = 4;
let ReleaseAtCycles = [4];
}
// 5 cycle , 1 throughput on FP1
def ORYONWrite_5Cyc_FP1 : SchedWriteRes<[ORYONFP1]> {
let Latency = 5;
}
// 8 cycle , 2 throughput on FP0123
def ORYONWrite_8Cyc_FP0123_RC : SchedWriteRes<[ORYONFP0123]> {
let Latency = 8;
let ReleaseAtCycles = [2];
}
def ORYONWrite_6Cyc_FP3 : SchedWriteRes<[ORYONFP3]> {
let Latency = 6;
}
def ORYONWrite_7Cyc_FP3 : SchedWriteRes<[ORYONFP3]> {
let Latency = 7;
}
def ORYONWrite_8Cyc_FP3 : SchedWriteRes<[ORYONFP3]> {
let Latency = 8;
}
def ORYONWrite_9Cyc_FP3 : SchedWriteRes<[ORYONFP3]> {
let Latency = 9;
}
def ORYONWrite_10Cyc_FP3 : SchedWriteRes<[ORYONFP3]> {
let Latency = 10;
}
def ORYONWrite_8Cyc_FP3_RC : SchedWriteRes<[ORYONFP3]> {
let Latency = 8;
let ReleaseAtCycles = [2];
}
def ORYONWrite_10Cyc_FP3_RC : SchedWriteRes<[ORYONFP3]> {
let Latency = 10;
let ReleaseAtCycles = [2];
}
def ORYONWrite_13Cyc_FP3_RC : SchedWriteRes<[ORYONFP3]> {
let Latency = 13;
let ReleaseAtCycles = [2];
}
def ORYONWrite_4Cyc_FP0123_RC :
SchedWriteRes<[ORYONFP0123]> {
let Latency = 4;
let ReleaseAtCycles = [2];
}
def ORYONWrite_4Cyc_FP0123_FP0123_RC :
SchedWriteRes<[ORYONFP0123, ORYONFP0123]> {
let Latency = 4;
let NumMicroOps = 2;
let ReleaseAtCycles = [2,2];
}
def ORYONWrite_4Cyc_FP0123_FP0123_FP0123_RC :
SchedWriteRes<[ORYONFP0123, ORYONFP0123, ORYONFP0123]> {
let Latency = 4;
let NumMicroOps = 3;
let ReleaseAtCycles = [3,3,3];
}
def ORYONWrite_6Cyc_FP0123_FP0123_FP0123_FP0123_RC :
SchedWriteRes<[ORYONFP0123, ORYONFP0123, ORYONFP0123, ORYONFP0123]> {
let Latency = 6;
let NumMicroOps = 4;
let ReleaseAtCycles = [6,6,6,6];
}
//===----------------------------------------------------------------------===//
// Instruction Tables in IXU
//===----------------------------------------------------------------------===//
//---
// Arithmetic Instructions
//---
//1, 1, 6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^ADD(W|X)r(i|r|x)", "^SUB(W|X)r(i|r|x)")>;
//2,2,3
def : InstRW<[ORYONWrite_2Cyc_I012345_I012345_RC],
(instregex "^ADD(W|X)rs", "^SUB(W|X)rs")>;
//1,1,4 alias CMP, CMN on page 75
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^ADDS(W|X)r(i|r|x)(64)?", "^SUBS(W|X)r(i|r|x)")>;
//2,2,2 alias CMP, CMN on page 75
def : InstRW<[ORYONWrite_2Cyc_I0123_I0123_RC],
(instregex "^ADDS(W|X)rs", "^SUBS(W|X)rs")>;
//1,1,4
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^ADC(W|X)r","^SBC(W|X)r",
"^ADCS(W|X)r","^SBCS(W|X)r")>;
//1,1,2
def : InstRW<[ORYONWrite_1Cyc_2Uops_I01],
(instrs ADR,ADRP)>;
//1,1,4
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^CSEL(W|X)r", "^CSINV(W|X)r",
"^CSNEG(W|X)r", "^CSINC(W|X)r")>;
//---
//Compare Instruciton
//---
// We have CCMP, CCMN as LLVM DAG node
// CMP is an alias of SUBS as above
// CMN is an alias of ADDS as above
// We also have no way to get shift compare node in LLVM
//2,2,1.5 CMP, CMN
//1,1,4
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^CCMP(W|X)(i|r)", "^CCMN(W|X)(i|r)")>;
//---
// Branch
//---
def : InstRW<[ORYONWrite_1Cyc_NONE], (instrs B)>;
def : InstRW<[ORYONWrite_1Cyc_I01], (instrs BL)>;
def : InstRW<[ORYONWrite_1Cyc_I01],
(instrs Bcc, CBZW, CBZX, CBNZW, CBNZX, TBZW, TBZX, TBNZW, TBNZX)>;
def : InstRW<[ORYONWrite_1Cyc_I0], (instrs BR, BLR)>;
def : InstRW<[ORYONWrite_1Cyc_I0], (instrs RET)>;
// 3 uOp, 1 cycle for branch, 7 cycle for Authentication,
// 1 cycle for updating link register
// V8.3a PAC
def : InstRW<[ORYONWrite_9Cyc_I012],
(instrs BLRAA, BLRAAZ, BLRAB, BLRABZ,
BRAA, BRAAZ, BRAB, BRABZ)>;
def : InstRW<[ORYONWrite_9Cyc_I012], (instrs RETAA, RETAB, ERETAA, ERETAB)>;
def : InstRW<[ORYONWrite_7Cyc_3Uops_I2], (instregex "^LDRAA", "^LDRAB")>;
// Logical Instructions
//---
//1,1,4 TST is an alias of ANDS
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^ANDS(W|X)r(i|r|x)", "^BICS(W|X)r(i|r|x)")>;
//2,2,2 TST shift is an alias
def : InstRW<[ORYONWrite_2Cyc_I0123_I0123_RC],
(instregex "^ANDS(W|X)rs", "^BICS(W|X)rs")>;
//1,1,6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^AND(W|X)r(i|r|x)", "^EOR(W|X)r(i|r|x)",
"^ORR(W|X)r(i|r|x)", "^BIC(W|X)r(i|r|x)",
"^EON(W|X)r(i|r|x)", "^ORN(W|X)r(i|r|x)")>;
//2,2,3
def : InstRW<[ORYONWrite_2Cyc_I012345_I012345_RC],
(instregex "^AND(W|X)rs", "^EOR(W|X)rs", "^ORR(W|X)rs",
"^BIC(W|X)rs", "^EON(W|X)rs", "^ORN(W|X)rs")>;
//---
// Shift Instructions
//---
//1,1,6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^ASRV(W|X)r", "^LSLV(W|X)r",
"^LSRV(W|X)r", "^RORV(W|X)r",
"RMIF")>;
//---
// Move-Data Bit-field and Sign_Extension Instructions
//---
//1,1,6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^MOVK(W|X)i", "^MOVN(W|X)i",
"^MOVZ(W|X)i", "^SBFM(W|X)ri",
"^UBFM(W|X)ri", "^BFM(W|X)ri",
"^SXT(W|B|H|X)", "^UXT(H|B)")>;
// COPY instruction is an LLVM internal DAG node, needs further study
def : InstRW<[ORYONWrite_1Cyc_I012345], (instrs COPY)>;
//---
// Reverse Instructions
//---
//1,1,6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^RBIT(W|X)r", "^REV(16|32|64)?(W|X)r")>;
//---
// Flag Manipulate Instructions
//---
//1,1,4
def : InstRW<[ORYONWrite_1Cyc_I0123],
(instregex "^SETF8", "^SETF16", "^CFINV")>;
//---
// Miscellaneous Instructions
//---
//1,1,6
def : InstRW<[ORYONWrite_1Cyc_I012345],
(instregex "^CLS(W|X)r$", "^CLZ(W|X)r$", "^EXTR(W|X)rri")>;
//---
// Multiply Instructions
//---
//1,3,2
def : InstRW<[ORYONWrite_3Cyc_I45],
(instregex "^MADD(W|X)rrr", "^MSUB(W|X)rrr",
"^(S|U)MADDLrrr", "^(S|U)MSUBLrrr",
"^(S|U)MULHrr")>;
//---
// Divide Instructions
//---
def : InstRW<[ORYONWrite_7Cyc_I2_RC],
(instregex "^(S|U)DIVWr")>;
def : InstRW<[ORYONWrite_9Cyc_I2_RC],
(instregex "^(S|U)DIVXr")>;
//---
// Cryptgraphy Instructions
//
//1,3,1 on I2
def : InstRW<[ORYONWrite_3Cyc_I2],
(instregex "^CRC32(B|H|W|X)rr", "^CRC32C(B|H|W|X)rr")>;
//---
// PAU instructions
//---
// on p47 of IXU document, we have 7 cycles for all PAU instructions
// here we just assume all signing and pauth instructions are 7 cycles
// assume all are 7 cycles here
// signing instrucitons
def : InstRW<[ORYONWrite_7Cyc_I2], (instrs PACIA, PACIB,
PACDA, PACDB,
PACIZA, PACIZB,
PACDZA, PACDZB,
PACGA)>;
// authentication instrucitons
def : InstRW<[ORYONWrite_7Cyc_I2], (instrs AUTIA, AUTIB,
AUTDA, AUTDB,
AUTIZA, AUTIZB,
AUTDZA, AUTDZB)>;
def : InstRW<[ORYONWrite_7Cyc_I2], (instrs XPACI, XPACD)>;
//===----------------------------------------------------------------------===//
// Instruction Tables in LSU
//===----------------------------------------------------------------------===//
// 4 cycle Load-to-use from L1D$
// Neon load with 5 cycle
// 6 cycle to STA ?
// STD cycle ?
// NEON STD + 2
// Load Instructions
// FP Load Instructions
// Load pair, immed pre-index, normal
// Load pair, immed pre-index, signed words
// Load pair, immed post-index, normal
// Load pair, immed post-index, signed words
// NOTE: Handled by WriteLD, WriteLDHi, WriteAdr.
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDNPDi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDNPQi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDNPSi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDNPWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDNPXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPDi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPQi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPSi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPSWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDPXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRBui)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRDui)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRHui)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRQui)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSui)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRDl)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRQl)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRWl)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRXl)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRBi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRHi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRSBWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRSBXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRSHWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRSHXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDTRSWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPDpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPQpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPSpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPWpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRBpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRDpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRHpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRQpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRWpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRXpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSBWpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSBXpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSBWpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSBXpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSHWpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSHXpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSHWpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSHXpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRBBpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRBBpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRHHpre)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRHHpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPDpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPQpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPSpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPWpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345],
(instrs LDPXpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRBpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRDpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRHpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRQpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRSpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRWpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD_I012345], (instrs LDRXpost)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRBroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRDroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRHroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRHHroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRQroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSHWroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSHXroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRWroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRXroW)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRBroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRDroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRHHroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRHroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRQroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSHWroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRSHXroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRWroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDRXroX)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURBi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURBBi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURDi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURHi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURHHi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURQi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSBWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSBXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSHWi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSHXi)>;
def : InstRW<[ORYONWrite_4Cyc_LD], (instrs LDURSWi)>;
// Store register, immed post-index
// NOTE: Handled by WriteST, ReadAdrBase
// Store register, immed pre-index
// NOTE: Handled by WriteST
// Store pair, immed post-index, W-form
// Store pair, immed post-indx, X-form
// Store pair, immed pre-index, W-form
// Store pair, immed pre-index, X-form
// NOTE: Handled by WriteSTP.
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURBi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURBBi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURDi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURHi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURHHi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURQi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURSi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURWi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STURXi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STTRBi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STTRHi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STTRWi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STTRXi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STNPDi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STNPQi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STNPXi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STNPWi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STPDi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STPQi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STPXi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STPWi)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRBui)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRDui)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRHui)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRQui)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRXui)>;
def : InstRW<[ORYONWrite_1Cyc_ST], (instrs STRWui)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STPDpre, STPDpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STPSpre, STPSpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STPWpre, STPWpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STPXpre, STPXpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRBpre, STRBpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRBBpre, STRBBpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRDpre, STRDpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRHpre, STRHpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRHHpre, STRHHpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRQpre, STRQpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRSpre, STRSpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRWpre, STRWpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instrs STRXpre, STRXpost)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRBroW, STRBroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRDroW, STRDroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRHroW, STRHroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRHHroW, STRHHroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRQroW, STRQroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRSroW, STRSroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRWroW, STRWroX)>;
def : InstRW<[ORYONWrite_1Cyc_ST],
(instrs STRXroW, STRXroX)>;
// ASIMD Load instructions, 4 cycle access + 2 cycle NEON access
// ASIMD load, 1 element, multiple, 1 reg, D-form 1uOps
// ASIMD load, 1 element, multiple, 1 reg, Q-form 1uOps
def : InstRW<[ORYONWrite_5Cyc_LD],
(instregex "^LD1Onev(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_LD_I012345],
(instregex "^LD1Onev(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD load, 1 element, multiple, 2 reg, D-form 3 uOps
// ASIMD load, 1 element, multiple, 2 reg, Q-form 2 uOps
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD],
(instregex "^LD1Twov(8b|4h|2s|1d)$")>;
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD],
(instregex "^LD1Twov(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD_I012345],
(instregex "^LD1Twov(8b|4h|2s|1d)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD_I012345],
(instregex "^LD1Twov(16b|8h|4s|2d)_POST$")>;
// ASIMD load, 1 element, multiple, 3 reg, D-form 4 uOps
// ASIMD load, 1 element, multiple, 3 reg, Q-form 3 uOps
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD],
(instregex "^LD1Threev(8b|4h|2s|1d)$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD],
(instregex "^LD1Threev(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD_I012345],
(instregex "^LD1Threev(8b|4h|2s|1d)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD_I012345],
(instregex "^LD1Threev(16b|8h|4s|2d)_POST$")>;
// ASIMD load, 1 element, multiple, 4 reg, D-form 6 uOps
// ASIMD load, 1 element, multiple, 4 reg, Q-form 4 uOps
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD],
(instregex "^LD1Fourv(8b|4h|2s|1d)$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD],
(instregex "^LD1Fourv(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD_I012345],
(instregex "^LD1Fourv(8b|4h|2s|1d)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD_I012345],
(instregex "^LD1Fourv(16b|8h|4s|2d)_POST$")>;
// ASIMD load, 1 element, one lane, B/H/S 2uOps
// ASIMD load, 1 element, one lane, D 2UOps
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD], (instregex "^LD1i(8|16|32|64)$")>;
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD_I012345],
(instregex "^LD1i(8|16|32|64)_POST$")>;
// ASIMD load, 1 element, all lanes, D-form, B/H/S 2uOps
// ASIMD load, 1 element, all lanes, D-form, D 2uOps
// ASIMD load, 1 element, all lanes, Q-form 2uOps
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD],
(instregex "^LD1Rv(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_2Uops_LD_I012345],
(instregex "^LD1Rv(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD load, 2 element, multiple, D-form, B/H/S 3 uOps
// ASIMD load, 2 element, multiple, Q-form, D 4 uOps
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD],
(instregex "^LD2Twov(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD],
(instregex "^LD2Twov(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD_I012345],
(instregex "^LD2Twov(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD_I012345],
(instregex "^LD2Twov(16b|8h|4s|2d)_POST$")>;
// ASIMD load, 2 element, one lane, B/H 3 uOps
// ASIMD load, 2 element, one lane, S 3 uOps
// ASIMD load, 2 element, one lane, D 3 uOps
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD], (instregex "^LD2i(8|16|32|64)$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD_I012345],
(instregex "^LD2i(8|16|32|64)_POST$")>;
// ASIMD load, 2 element, all lanes, D-form, B/H/S 3 uOps
// ASIMD load, 2 element, all lanes, D-form, D 3 uOps
// ASIMD load, 2 element, all lanes, Q-form 3 uOps
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD],
(instregex "^LD2Rv(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_3Uops_LD_I012345],
(instregex "^LD2Rv(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD load, 3 element, multiple, D-form, B/H/S 5 uOps
// ASIMD load, 3 element, multiple, Q-form, B/H/S 6 uOps
// ASIMD load, 3 element, multiple, Q-form, D 6 uOps
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD],
(instregex "^LD3Threev(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD],
(instregex "^LD3Threev(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD_I012345],
(instregex "^LD3Threev(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD_I012345],
(instregex "^LD3Threev(16b|8h|4s|2d)_POST$")>;
// ASIMD load, 3 element, one lone, B/H 4 uOps
// ASIMD load, 3 element, one lane, S 4 uOps
// ASIMD load, 3 element, one lane, D 5 uOps
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD], (instregex "^LD3i(8|16|32)$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD], (instregex "^LD3i(64)$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD_I012345],
(instregex "^LD3i(8|16|32)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD_I012345],
(instregex "^LD3i(64)_POST$")>;
// ASIMD load, 3 element, all lanes, D-form, B/H/S 4 uOps
// ASIMD load, 3 element, all lanes, D-form, D 5 uOps
// ASIMD load, 3 element, all lanes, Q-form, B/H/S 4 uOps
// ASIMD load, 3 element, all lanes, Q-form, D 5 uOps
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD],
(instregex "^LD3Rv(8b|4h|2s|16b|8h|4s)$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD],
(instregex "^LD3Rv(1d|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_4Uops_LD_I012345],
(instregex "^LD3Rv(8b|4h|2s|16b|8h|4s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD_I012345],
(instregex "^LD3Rv(1d|2d)_POST$")>;
// ASIMD load, 4 element, multiple, D-form, B/H/S 6 uOps
// ASIMD load, 4 element, multiple, Q-form, B/H/S 10 uOps
// ASIMD load, 4 element, multiple, Q-form, D 8 uOps
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD],
(instregex "^LD4Fourv(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_5Cyc_10Uops_LD],
(instregex "^LD4Fourv(16b|8h|4s)$")>;
def : InstRW<[ORYONWrite_5Cyc_8Uops_LD],
(instregex "^LD4Fourv(2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD_I012345],
(instregex "^LD4Fourv(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_10Uops_LD_I012345],
(instregex "^LD4Fourv(16b|8h|4s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_8Uops_LD_I012345],
(instregex "^LD4Fourv(2d)_POST$")>;
// ASIMD load, 4 element, one lane, B/H 5 uOps
// ASIMD load, 4 element, one lane, S 5 uOps
// ASIMD load, 4 element, one lane, D 6 uOps
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD], (instregex "^LD4i(8|16|32)$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD], (instregex "^LD4i(64)$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD_I012345],
(instregex "^LD4i(8|16|32)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD_I012345],
(instregex "^LD4i(64)_POST$")>;
// ASIMD load, 4 element, all lanes, D-form, B/H/S 5 uOps
// ASIMD load, 4 element, all lanes, D-form, D 6 uOps
// ASIMD load, 4 element, all lanes, Q-form, B/H/S 5 uOps
// ASIMD load, 4 element, all lanes, Q-form, D 6 uOps
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD],
(instregex "^LD4Rv(8b|4h|2s|16b|8h|4s)$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD],
(instregex "^LD4Rv(1d|2d)$")>;
def : InstRW<[ORYONWrite_5Cyc_5Uops_LD_I012345],
(instregex "^LD4Rv(8b|4h|2s|16b|8h|4s)_POST$")>;
def : InstRW<[ORYONWrite_5Cyc_6Uops_LD_I012345],
(instregex "^LD4Rv(1d|2d)_POST$")>;
// ASIMD Store Instructions
// ASIMD store, 1 element, multiple, 1 reg, D-form 1 uOps
// ASIMD store, 1 element, multiple, 1 reg, Q-form 1 uops
def : InstRW<[ORYONWrite_1Cyc_ST],
(instregex "^ST1Onev(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_ST_I012345],
(instregex "^ST1Onev(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD store, 1 element, multiple, 2 reg, D-form 2 uOps
// ASIMD store, 1 element, multiple, 2 reg, Q-form 2 uOps
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST],
(instregex "^ST1Twov(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST_I012345],
(instregex "^ST1Twov(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD store, 1 element, multiple, 3 reg, D-form 3 uOps
// ASIMD store, 1 element, multiple, 3 reg, Q-form 3 uOps
def : InstRW<[ORYONWrite_1Cyc_3Uops_ST],
(instregex "^ST1Threev(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_3Uops_ST_I012345],
(instregex "^ST1Threev(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD store, 1 element, multiple, 4 reg, D-form 4 uOps
// ASIMD store, 1 element, multiple, 4 reg, Q-form 4 uOps
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST],
(instregex "^ST1Fourv(8b|4h|2s|1d|16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST_I012345],
(instregex "^ST1Fourv(8b|4h|2s|1d|16b|8h|4s|2d)_POST$")>;
// ASIMD store, 1 element, one lane, B/H/S 2 uOps
// ASIMD store, 1 element, one lane, D 2 uOps
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST],
(instregex "^ST1i(8|16|32|64)$")>;
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST_I012345],
(instregex "^ST1i(8|16|32|64)_POST$")>;
// ASIMD store, 2 element, multiple, D-form, B/H/S 2 uOps
// ASIMD store, 2 element, multiple, Q-form, B/H/S 4 uOps
// ASIMD store, 2 element, multiple, Q-form, D 4 uOps
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST],
(instregex "^ST2Twov(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST],
(instregex "^ST2Twov(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST_I012345],
(instregex "^ST2Twov(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST_I012345],
(instregex "^ST2Twov(16b|8h|4s|2d)_POST$")>;
// ASIMD store, 2 element, one lane, B/H/S 2 uOps
// ASIMD store, 2 element, one lane, D 2 uOps
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST],
(instregex "^ST2i(8|16|32|64)$")>;
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST_I012345],
(instregex "^ST2i(8|16|32|64)_POST$")>;
// ASIMD store, 3 element, multiple, D-form, B/H/S 4 uOps
// ASIMD store, 3 element, multiple, Q-form, B/H/S 6 uOps
// ASIMD store, 3 element, multiple, Q-form, D 6 uOps
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST],
(instregex "^ST3Threev(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_1Cyc_6Uops_ST],
(instregex "^ST3Threev(16b|8h|4s|2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST_I012345],
(instregex "^ST3Threev(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_6Uops_ST_I012345],
(instregex "^ST3Threev(16b|8h|4s|2d)_POST$")>;
// ASIMD store, 3 element, one lane, B/H 2 uOps
// ASIMD store, 3 element, one lane, S 2 uOps
// ASIMD store, 3 element, one lane, D 4 uOps
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST], (instregex "^ST3i(8|16|32)$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST], (instregex "^ST3i(64)$")>;
def : InstRW<[ORYONWrite_1Cyc_2Uops_ST_I012345],
(instregex "^ST3i(8|16|32)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST_I012345],
(instregex "^ST3i(64)_POST$")>;
// ASIMD store, 4 element, multiple, D-form, B/H/S 5 uOps
// ASIMD store, 4 element, multiple, Q-form, B/H/S 10 uOps
// ASIMD store, 4 element, multiple, Q-form, D 8 uOps
def : InstRW<[ORYONWrite_1Cyc_5Uops_ST],
(instregex "^ST4Fourv(8b|4h|2s)$")>;
def : InstRW<[ORYONWrite_1Cyc_10Uops_ST],
(instregex "^ST4Fourv(16b|8h|4s)$")>;
def : InstRW<[ORYONWrite_1Cyc_8Uops_ST],
(instregex "^ST4Fourv(2d)$")>;
def : InstRW<[ORYONWrite_1Cyc_5Uops_ST_I012345],
(instregex "^ST4Fourv(8b|4h|2s)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_10Uops_ST_I012345],
(instregex "^ST4Fourv(16b|8h|4s)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_8Uops_ST_I012345],
(instregex "^ST4Fourv(2d)_POST$")>;
// ASIMD store, 4 element, one lane, B/H 3 uOps
// ASIMD store, 4 element, one lane, S 3 uOps
// ASIMD store, 4 element, one lane, D 4 uOps
def : InstRW<[ORYONWrite_1Cyc_3Uops_ST], (instregex "^ST4i(8|16|32)$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST], (instregex "^ST4i(64)$")>;
def : InstRW<[ORYONWrite_1Cyc_3Uops_ST_I012345],
(instregex "^ST4i(8|16|32)_POST$")>;
def : InstRW<[ORYONWrite_1Cyc_4Uops_ST_I012345],
(instregex "^ST4i(64)_POST$")>;
//===----------------------------------------------------------------------===//
// Instruction Tables in VXU
//===----------------------------------------------------------------------===//
// all uOps are not clearly written in the VXU document
// I2V
def : InstRW<[ORYONWrite_I2V_4Cyc_I45], (instregex "^FMOV[HSD][WX]r", "^FMOVDXHighr")>;
// I2V with convert
def : InstRW<[ORYONWrite_I2V_7Cyc_I45], (instregex "^[SU]CVTF[SU][XW][HSD]ri")>;
// V2I
def : InstRW<[ORYONWrite_V2I_3Cyc_FP01], (instregex "^FMOV[WX][HSD]r", "FMOVXDHighr")>;
// V2I with convert 2nd [SU] necessary?
def : InstRW<[ORYONWrite_V2I_6Cyc_FP01], (instregex "^FCVT[AMNPZ][SU][SU][XW][HSD]r")>;
// float to float move immediate, row 7 in big chart
def : InstRW<[ORYONWrite_V2V_2Cyc_FP0123], (instregex "^FMOV[HSD]r")>;
def : InstRW<[ORYONWrite_V2V_2Cyc_FP0123], (instregex "^FMOV[HSD]i")>;
// float to float conversion within VXU, precision conversion
def : InstRW<[ORYONWrite_V2V_6Cyc_FP01], (instregex "^FJCVTZS")>;
def : InstRW<[ORYONWrite_V2V_3Cyc_FP0123], (instregex "^FCVT[HSD][HSD]r",
"^FRINT(A|I|M|N|P|X|Z)(Sr|Dr)")>;
// floating comparison write to NZCV
def : InstRW<[ORYONWrite_2Cyc_FP01], (instregex "^FCMP(E)?[HSD]r[ir]")>;
def : InstRW<[ORYONWrite_2Cyc_FP01], (instregex "^FCCMP(E)?[HSD]rr")>;
// floating point conditional select
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^FCSEL")>;
// floating multiply-add
def : InstRW<[ORYONWrite_4Cyc_FP0123], (instregex "^(F|FN)MADD", "^(F|FN)MSUB")>;
// floating unary, cycle/throughput? xls row14
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^F(ABS|NEG)[SD]r")>;
//floating division/square root
def : InstRW<[ORYONWrite_7Cyc_FP3], (instregex "^FDIVHrr")>;
def : InstRW<[ORYONWrite_8Cyc_FP3], (instregex "^FDIVSrr")>;
def : InstRW<[ORYONWrite_10Cyc_FP3], (instregex "^FDIVDrr")>;
def : InstRW<[ORYONWrite_8Cyc_FP3_RC], (instregex "^FSQRTHr")>;
def : InstRW<[ORYONWrite_10Cyc_FP3_RC], (instregex "^FSQRTSr")>;
def : InstRW<[ORYONWrite_13Cyc_FP3_RC], (instregex "^FSQRTDr")>;
//==========
// SIMD move instructions
//==========
// ASIMD DUP element
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^DUPv.+lane")>;
// ASIMD DUP general thoughput undecided, 3? FP0123
// VXU doc, p42, 2 uOps
def : InstRW<[ORYONWrite_3Cyc_2Uops_FP0123], (instregex "^DUPv.+gpr")>;
// ASIMD insert, element to element
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^INSv.+lane")>;
// ASIMD insert, gen reg 3? FP0123?
def : InstRW<[ORYONWrite_3Cyc_2Uops_FP0123], (instregex "^INSv.+gpr")>;
// ASIMD move, FP immed
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^FMOVv")>;
// ASIMD transfer, element to gen reg
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^[SU]MOVv")>;
//==========
// SIMD arithmetic instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^ADDv", "^SUBv",
"^BIFv", "^BITv", "^BSLv",
"^ANDv", "^BICv", "^EORv",
"^ORRv", "^ORNv")>;
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^FABDv", "^FADDv", "^FSUBv")>;
// floating division
def : InstRW<[ORYONWrite_6Cyc_FP3], (instregex "^FDIVv.*16$")>;
def : InstRW<[ORYONWrite_7Cyc_FP3], (instregex "^FDIVv.*32$")>;
def : InstRW<[ORYONWrite_9Cyc_FP3], (instregex "^FDIVv.*64$")>;
def : InstRW<[ORYONWrite_4Cyc_FP0123], (instregex "^FMUL(X)?v",
"^FRECPSv", "^FRSQRTSv")>;
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^MLAv","^MLSv", "^MULv",
"^PMULv", "UABAv")>;
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "SABAv", "SABDv",
"^(SH|UH)(ADD|SUB)v",
"^S(MAX|MIN)v",
"^(SQ|UQ)(ADD|SUB)v",
"^(SQ|SQR|UQ|UQR)SHLv",
"^(SR|UR)HADDv",
"^(SR|UR)SHLv",
"^UABDv",
"^U(MAX|MIN)v")>;
// IMAX or UMAX in the above line
//==========
// SIMD compare instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^CMEQv","^CMGEv","^CMGTv",
"^CMLEv","^CMLTv", "^CMHIv",
"^CMHSv",
"^FCMEQv", "^FCMGEv",
"^FCMGTv", "^FCMLEv",
"^FCMLTv",
"^FACGEv", "^FACGTv")>;
//==========
// SIMD widening and narrowing arithmetic instructions
//==========
// NO need to list ADDHN2, RADDHN2, RSUBHN2 as they are not distinguished
// from ADDHN, RADDHN, RSUBHN in td file(v16i8, v8i16, v4i32).
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^ADDHNv",
"^SUBHNv",
"^RADDHNv",
"^RSUBHNv",
"^SABD(L|L2)v", "^UABD(L|L2)v",
"^(S|U)(ADD|SUB)(L|L2|W|W2)v")>;
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^PMUL(L|L2)v","^SABA(L|L2)v",
"^(S|U|SQ)(MLA|MSL|MUL)(L|L2)v")>;
//==========
// SIMD unary arithmetic instructions
//==========
//^MVNv is an alias of ^NOTv
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^ABSv", "^CLSv","^CLZv", "^CNTv",
"^NEGv", "^NOTv",
"^RBITv", "^REV(16|32|64)v",
"^SQ(ABS|NEG)v", "^SQ(XT|XTU)(N|N2)v",
"^(SU|US)QADDv",
"^UQXT(N|N2)v", "^XTN2?v")>;
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^FCVT(L|L2|N|N2|XN|XN2)v",
"^FRINT[AIMNPXZ]v",
"^FRSQRTEv",
"^(S|U)ADALPv",
"^(S|U)ADDLPv")>;
def : InstRW<[ORYONWrite_3Cyc_FP0], (instregex "^URECPEv", "^URSQRTEv",
"^FRECPEv", "^FRECPXv")>;
def : InstRW<[ORYONWrite_8Cyc_FP3_RC], (instregex "^FSQRTv.*16$")>;
def : InstRW<[ORYONWrite_10Cyc_FP3_RC], (instregex "^FSQRTv.*32$")>;
def : InstRW<[ORYONWrite_13Cyc_FP3_RC], (instregex "^FSQRTv.*64$")>;
//==========
// SIMD binary elememt arithmetic instructions
//==========
def : InstRW<[ORYONWrite_4Cyc_FP0123], (instregex "^FMLAv", "^FMLSv")>;
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^SQDMULHv",
"^SQRD(MLA|MLS|MUL)Hv")>;
//==========
// SIMD permute instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^EXTv", "^TRN(1|2)v",
"^UZP(1|2)v", "^ZIP(1|2)v")>;
//==========
// SIMD immediate instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^MOVIv", "^MVNIv")>;
//==========
// SIMD shift(immediate) instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^RSHR(N|N2)v", "^SHLv",
"^(SHL|SHR)(N|N2)v",
"^SLIv",
"^(SQ|SQR)SHR(U)?(N|N2)v",
"^(UQ|UQR)SHR(N|N2)v",
"^SQSHLUv",
"^SRIv",
"^(S|SR|U|UR)SHRv",
"^(S|SR|U|UR)SRAv",
"^(S|U)SHL(L|L2)v")>;
//==========
// SIMD floating-point and integer conversion instructions
//==========
// same as above conversion
//==========
// SIMD reduce (acoss vector lanes) instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^ADDVv",
"^(FMAX|FMIN)(V|NMV)v",
"^(S|U)ADDLVv",
"^(S|U)(MAX|MIN)Vv")>;
//==========
// SIMD pairwise arithmetic instructions
//==========
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^ADDPv", "^FADDPv",
"^(FMAX|FMIN)(NMP|P)v",
"^(S|U)(MIN|MAX)Pv")>;
//==========
// SIMD dot prodcut instructions
//==========
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^(U|S)DOTv")>;
//==========
// SIMD table lookup instructions
//==========
// TBL 1-reg/2-reg; TBX 1-reg, 1uOp, throughput=4 latency=2
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instrs TBLv8i8One, TBLv16i8One,
TBXv8i8One, TBXv16i8One,
TBLv8i8Two, TBLv16i8Two)>;
// TBL 3-reg/4-reg, 3uops, throughtput=4/3=1.33 latency=4
def : InstRW<[ORYONWrite_4Cyc_FP0123_FP0123_FP0123_RC],
(instrs TBLv8i8Three, TBLv16i8Three,
TBLv8i8Four, TBLv16i8Four)>;
// TBX 2-reg 2 uOps, throughput=2 latency=4
def : InstRW<[ORYONWrite_4Cyc_FP0123_FP0123_RC], (instrs TBXv8i8Two, TBXv16i8Two)>;
// TBX 3-reg/4-reg, 4uOps, throughput=1, latency=6
def : InstRW<[ORYONWrite_6Cyc_FP0123_FP0123_FP0123_FP0123_RC],
(instrs TBXv8i8Three, TBXv16i8Three,
TBXv8i8Four, TBXv16i8Four)>;
//==========
// SIMD complex number arithmetic instructions
//==========
def : InstRW<[ORYONWrite_4Cyc_FP0123], (instregex "^FCADDv", "^FCMLAv")>;
//==========
// SIMD cryptographic instructions
//==========
// 3,4 on IMLA, CRYP
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^AES[DE]",
"^SM3(TT1|TT2)(A|B)")>;
// 2,4 on CRYP
def : InstRW<[ORYONWrite_2Cyc_FP0123], (instregex "^AESI?MC",
"^EOR3",
"^RAX1",
"^XAR",
"^BCAX",
"^SM3SS1",
"^SM3PART(W1|W2)")>;
// 5,1 on CRYP
def : InstRW<[ORYONWrite_5Cyc_FP1], (instregex "^SM4E",
"^SM4EKEY")>;
// 2,1 on CRYP
def : InstRW<[ORYONWrite_2Cyc_FP1], (instregex "^SHA1(H|SU0|SU1)",
"^SHA256SU0",
"^SHA512(SU0|SU1)")>;
// 3,1 on CRYP
def : InstRW<[ORYONWrite_3Cyc_FP1], (instregex "^SHA256SU1",
"^SHA512(H|H2)")>;
// 4,0.25 on CRYP
def : InstRW<[ORYONWrite_4Cyc_FP1_RC4], (instregex "^SHA1(C|P|M)",
"^SHA256(H|H2)")>;
//==========
// SIMD v8.6 instructions
//==========
// 4,2 on IMLA
def : InstRW<[ORYONWrite_4Cyc_FP0123_RC], (instregex "^(S|U|US)MMLA$")>;
// 4,0.5 on IMLA
def : InstRW<[ORYONWrite_8Cyc_FP0123_RC], (instregex "^BFMMLA$")>;
// 4,0.5 on IMLA
def : InstRW<[ORYONWrite_8Cyc_FP0123_RC], (instregex "^BFMLAL(B|T)")>;
// 3,4
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^(US|SU)DOTv")>;
// 3,1
def : InstRW<[ORYONWrite_4Cyc_FP0123], (instregex "^BF(16)?DOTv")>;
// 3,4
def : InstRW<[ORYONWrite_3Cyc_FP0123], (instregex "^BFCVT(N|N2)?$")>;
} // SchedModel = OryonModel
Codebase Browser
llvm