| //=- X86ScheduleZnver2.td - X86 Znver2 Scheduling -------------*- 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 machine model for Znver2 to support instruction |
| // scheduling and other instruction cost heuristics. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| def Znver2Model : SchedMachineModel { |
| // Zen can decode 4 instructions per cycle. |
| let IssueWidth = 4; |
| // Based on the reorder buffer we define MicroOpBufferSize |
| let MicroOpBufferSize = 224; |
| let LoadLatency = 4; |
| let MispredictPenalty = 17; |
| let HighLatency = 25; |
| let PostRAScheduler = 1; |
| |
| // FIXME: This variable is required for incomplete model. |
| // We haven't catered all instructions. |
| // So, we reset the value of this variable so as to |
| // say that the model is incomplete. |
| let CompleteModel = 0; |
| } |
| |
| let SchedModel = Znver2Model in { |
| |
| // Zen can issue micro-ops to 10 different units in one cycle. |
| // These are |
| // * Four integer ALU units (ZALU0, ZALU1, ZALU2, ZALU3) |
| // * Three AGU units (ZAGU0, ZAGU1, ZAGU2) |
| // * Four FPU units (ZFPU0, ZFPU1, ZFPU2, ZFPU3) |
| // AGUs feed load store queues @two loads and 1 store per cycle. |
| |
| // Four ALU units are defined below |
| def Zn2ALU0 : ProcResource<1>; |
| def Zn2ALU1 : ProcResource<1>; |
| def Zn2ALU2 : ProcResource<1>; |
| def Zn2ALU3 : ProcResource<1>; |
| |
| // Three AGU units are defined below |
| def Zn2AGU0 : ProcResource<1>; |
| def Zn2AGU1 : ProcResource<1>; |
| def Zn2AGU2 : ProcResource<1>; |
| |
| // Four FPU units are defined below |
| def Zn2FPU0 : ProcResource<1>; |
| def Zn2FPU1 : ProcResource<1>; |
| def Zn2FPU2 : ProcResource<1>; |
| def Zn2FPU3 : ProcResource<1>; |
| |
| // FPU grouping |
| def Zn2FPU013 : ProcResGroup<[Zn2FPU0, Zn2FPU1, Zn2FPU3]>; |
| def Zn2FPU01 : ProcResGroup<[Zn2FPU0, Zn2FPU1]>; |
| def Zn2FPU12 : ProcResGroup<[Zn2FPU1, Zn2FPU2]>; |
| def Zn2FPU13 : ProcResGroup<[Zn2FPU1, Zn2FPU3]>; |
| def Zn2FPU23 : ProcResGroup<[Zn2FPU2, Zn2FPU3]>; |
| def Zn2FPU02 : ProcResGroup<[Zn2FPU0, Zn2FPU2]>; |
| def Zn2FPU03 : ProcResGroup<[Zn2FPU0, Zn2FPU3]>; |
| |
| // Below are the grouping of the units. |
| // Micro-ops to be issued to multiple units are tackled this way. |
| |
| // ALU grouping |
| // Zn2ALU03 - 0,3 grouping |
| def Zn2ALU03: ProcResGroup<[Zn2ALU0, Zn2ALU3]>; |
| |
| // 64 Entry (16x4 entries) Int Scheduler |
| def Zn2ALU : ProcResGroup<[Zn2ALU0, Zn2ALU1, Zn2ALU2, Zn2ALU3]> { |
| let BufferSize=64; |
| } |
| |
| // 28 Entry (14x2) AGU group. AGUs can't be used for all ALU operations |
| // but are relevant for some instructions |
| def Zn2AGU : ProcResGroup<[Zn2AGU0, Zn2AGU1, Zn2AGU2]> { |
| let BufferSize=28; |
| } |
| |
| // Integer Multiplication issued on ALU1. |
| def Zn2Multiplier : ProcResource<1>; |
| |
| // Integer division issued on ALU2. |
| def Zn2Divider : ProcResource<1>; |
| |
| // 4 Cycles load-to use Latency is captured |
| def : ReadAdvance<ReadAfterLd, 4>; |
| |
| // 7 Cycles vector load-to use Latency is captured |
| def : ReadAdvance<ReadAfterVecLd, 7>; |
| def : ReadAdvance<ReadAfterVecXLd, 7>; |
| def : ReadAdvance<ReadAfterVecYLd, 7>; |
| |
| def : ReadAdvance<ReadInt2Fpu, 0>; |
| |
| // The Integer PRF for Zen is 168 entries, and it holds the architectural and |
| // speculative version of the 64-bit integer registers. |
| // Reference: "Software Optimization Guide for AMD Family 17h Processors" |
| def Zn2IntegerPRF : RegisterFile<168, [GR64, CCR]>; |
| |
| // 36 Entry (9x4 entries) floating-point Scheduler |
| def Zn2FPU : ProcResGroup<[Zn2FPU0, Zn2FPU1, Zn2FPU2, Zn2FPU3]> { |
| let BufferSize=36; |
| } |
| |
| // The Zen FP Retire Queue renames SIMD and FP uOps onto a pool of 160 128-bit |
| // registers. Operations on 256-bit data types are cracked into two COPs. |
| // Reference: "Software Optimization Guide for AMD Family 17h Processors" |
| def Zn2FpuPRF: RegisterFile<160, [VR64, VR128, VR256], [1, 1, 2]>; |
| |
| // The unit can track up to 192 macro ops in-flight. |
| // The retire unit handles in-order commit of up to 8 macro ops per cycle. |
| // Reference: "Software Optimization Guide for AMD Family 17h Processors" |
| // To be noted, the retire unit is shared between integer and FP ops. |
| // In SMT mode it is 96 entry per thread. But, we do not use the conservative |
| // value here because there is currently no way to fully mode the SMT mode, |
| // so there is no point in trying. |
| def Zn2RCU : RetireControlUnit<192, 8>; |
| |
| // (a folded load is an instruction that loads and does some operation) |
| // Ex: ADDPD xmm,[mem]-> This instruction has two micro-ops |
| // Instructions with folded loads are usually micro-fused, so they only appear |
| // as two micro-ops. |
| // a. load and |
| // b. addpd |
| // This multiclass is for folded loads for integer units. |
| multiclass Zn2WriteResPair<X86FoldableSchedWrite SchedRW, |
| list<ProcResourceKind> ExePorts, |
| int Lat, list<int> Res = [], int UOps = 1, |
| int LoadLat = 4, int LoadUOps = 1> { |
| // Register variant takes 1-cycle on Execution Port. |
| def : WriteRes<SchedRW, ExePorts> { |
| let Latency = Lat; |
| let ResourceCycles = Res; |
| let NumMicroOps = UOps; |
| } |
| |
| // Memory variant also uses a cycle on Zn2AGU |
| // adds LoadLat cycles to the latency (default = 4). |
| def : WriteRes<SchedRW.Folded, !listconcat([Zn2AGU], ExePorts)> { |
| let Latency = !add(Lat, LoadLat); |
| let ResourceCycles = !if(!empty(Res), [], !listconcat([1], Res)); |
| let NumMicroOps = !add(UOps, LoadUOps); |
| } |
| } |
| |
| // This multiclass is for folded loads for floating point units. |
| multiclass Zn2WriteResFpuPair<X86FoldableSchedWrite SchedRW, |
| list<ProcResourceKind> ExePorts, |
| int Lat, list<int> Res = [], int UOps = 1, |
| int LoadLat = 7, int LoadUOps = 0> { |
| // Register variant takes 1-cycle on Execution Port. |
| def : WriteRes<SchedRW, ExePorts> { |
| let Latency = Lat; |
| let ResourceCycles = Res; |
| let NumMicroOps = UOps; |
| } |
| |
| // Memory variant also uses a cycle on Zn2AGU |
| // adds LoadLat cycles to the latency (default = 7). |
| def : WriteRes<SchedRW.Folded, !listconcat([Zn2AGU], ExePorts)> { |
| let Latency = !add(Lat, LoadLat); |
| let ResourceCycles = !if(!empty(Res), [], !listconcat([1], Res)); |
| let NumMicroOps = !add(UOps, LoadUOps); |
| } |
| } |
| |
| // WriteRMW is set for instructions with Memory write |
| // operation in codegen |
| def : WriteRes<WriteRMW, [Zn2AGU]>; |
| |
| def : WriteRes<WriteStore, [Zn2AGU]>; |
| def : WriteRes<WriteStoreNT, [Zn2AGU]>; |
| def : WriteRes<WriteMove, [Zn2ALU]>; |
| def : WriteRes<WriteLoad, [Zn2AGU]> { let Latency = 8; } |
| |
| def : WriteRes<WriteZero, []>; |
| def : WriteRes<WriteLEA, [Zn2ALU]>; |
| defm : Zn2WriteResPair<WriteALU, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteADC, [Zn2ALU], 1>; |
| |
| defm : Zn2WriteResPair<WriteIMul8, [Zn2ALU1, Zn2Multiplier], 4>; |
| |
| defm : X86WriteRes<WriteBSWAP32, [Zn2ALU], 1, [4], 1>; |
| defm : X86WriteRes<WriteBSWAP64, [Zn2ALU], 1, [4], 1>; |
| defm : X86WriteRes<WriteCMPXCHG, [Zn2ALU], 1, [1], 1>; |
| defm : X86WriteRes<WriteCMPXCHGRMW,[Zn2ALU,Zn2AGU], 8, [1,1], 5>; |
| defm : X86WriteRes<WriteXCHG, [Zn2ALU], 1, [2], 2>; |
| |
| defm : Zn2WriteResPair<WriteShift, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteShiftCL, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteRotate, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteRotateCL, [Zn2ALU], 1>; |
| |
| defm : X86WriteRes<WriteSHDrri, [Zn2ALU], 1, [1], 1>; |
| defm : X86WriteResUnsupported<WriteSHDrrcl>; |
| defm : X86WriteResUnsupported<WriteSHDmri>; |
| defm : X86WriteResUnsupported<WriteSHDmrcl>; |
| |
| defm : Zn2WriteResPair<WriteJump, [Zn2ALU], 1>; |
| defm : Zn2WriteResFpuPair<WriteCRC32, [Zn2FPU0], 3>; |
| |
| defm : Zn2WriteResPair<WriteCMOV, [Zn2ALU], 1>; |
| def : WriteRes<WriteSETCC, [Zn2ALU]>; |
| def : WriteRes<WriteSETCCStore, [Zn2ALU, Zn2AGU]>; |
| defm : X86WriteRes<WriteLAHFSAHF, [Zn2ALU], 2, [1], 2>; |
| |
| defm : X86WriteRes<WriteBitTest, [Zn2ALU], 1, [1], 1>; |
| defm : X86WriteRes<WriteBitTestImmLd, [Zn2ALU,Zn2AGU], 5, [1,1], 2>; |
| defm : X86WriteRes<WriteBitTestRegLd, [Zn2ALU,Zn2AGU], 5, [1,1], 2>; |
| defm : X86WriteRes<WriteBitTestSet, [Zn2ALU], 2, [1], 2>; |
| |
| // Bit counts. |
| defm : Zn2WriteResPair<WriteBSF, [Zn2ALU], 3>; |
| defm : Zn2WriteResPair<WriteBSR, [Zn2ALU], 3>; |
| defm : Zn2WriteResPair<WriteLZCNT, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteTZCNT, [Zn2ALU], 2>; |
| defm : Zn2WriteResPair<WritePOPCNT, [Zn2ALU], 1>; |
| |
| // Treat misc copies as a move. |
| def : InstRW<[WriteMove], (instrs COPY)>; |
| |
| // BMI1 BEXTR, BMI2 BZHI |
| defm : Zn2WriteResPair<WriteBEXTR, [Zn2ALU], 1>; |
| defm : Zn2WriteResPair<WriteBZHI, [Zn2ALU], 1>; |
| |
| // IDIV |
| defm : Zn2WriteResPair<WriteDiv8, [Zn2ALU2, Zn2Divider], 15, [1,15], 1>; |
| defm : Zn2WriteResPair<WriteDiv16, [Zn2ALU2, Zn2Divider], 17, [1,17], 2>; |
| defm : Zn2WriteResPair<WriteDiv32, [Zn2ALU2, Zn2Divider], 25, [1,25], 2>; |
| defm : Zn2WriteResPair<WriteDiv64, [Zn2ALU2, Zn2Divider], 41, [1,41], 2>; |
| defm : Zn2WriteResPair<WriteIDiv8, [Zn2ALU2, Zn2Divider], 15, [1,15], 1>; |
| defm : Zn2WriteResPair<WriteIDiv16, [Zn2ALU2, Zn2Divider], 17, [1,17], 2>; |
| defm : Zn2WriteResPair<WriteIDiv32, [Zn2ALU2, Zn2Divider], 25, [1,25], 2>; |
| defm : Zn2WriteResPair<WriteIDiv64, [Zn2ALU2, Zn2Divider], 41, [1,41], 2>; |
| |
| // IMULH |
| def : WriteRes<WriteIMulH, [Zn2ALU1, Zn2Multiplier]>{ |
| let Latency = 4; |
| } |
| |
| // Floating point operations |
| defm : X86WriteRes<WriteFLoad, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteFLoadX, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteFLoadY, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteFMaskedLoad, [Zn2AGU,Zn2FPU01], 8, [1,1], 1>; |
| defm : X86WriteRes<WriteFMaskedLoadY, [Zn2AGU,Zn2FPU01], 8, [1,1], 2>; |
| defm : X86WriteRes<WriteFMaskedStore32, [Zn2AGU,Zn2FPU01], 4, [1,1], 1>; |
| defm : X86WriteRes<WriteFMaskedStore32Y, [Zn2AGU,Zn2FPU01], 5, [1,2], 2>; |
| defm : X86WriteRes<WriteFMaskedStore64, [Zn2AGU,Zn2FPU01], 4, [1,1], 1>; |
| defm : X86WriteRes<WriteFMaskedStore64Y, [Zn2AGU,Zn2FPU01], 5, [1,2], 2>; |
| |
| defm : X86WriteRes<WriteFStore, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFStoreX, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFStoreY, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFStoreNT, [Zn2AGU,Zn2FPU2], 8, [1,1], 1>; |
| defm : X86WriteRes<WriteFStoreNTX, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFStoreNTY, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFMove, [Zn2FPU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFMoveX, [Zn2FPU], 1, [1], 1>; |
| defm : X86WriteRes<WriteFMoveY, [Zn2FPU], 1, [1], 1>; |
| |
| defm : Zn2WriteResFpuPair<WriteFAdd, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFAddX, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFAddY, [Zn2FPU0], 3>; |
| defm : X86WriteResPairUnsupported<WriteFAddZ>; |
| defm : Zn2WriteResFpuPair<WriteFAdd64, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFAdd64X, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFAdd64Y, [Zn2FPU0], 3>; |
| defm : X86WriteResPairUnsupported<WriteFAdd64Z>; |
| defm : Zn2WriteResFpuPair<WriteFCmp, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFCmpX, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFCmpY, [Zn2FPU0], 3>; |
| defm : X86WriteResPairUnsupported<WriteFCmpZ>; |
| defm : Zn2WriteResFpuPair<WriteFCmp64, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFCmp64X, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFCmp64Y, [Zn2FPU0], 3>; |
| defm : X86WriteResPairUnsupported<WriteFCmp64Z>; |
| defm : Zn2WriteResFpuPair<WriteFCom, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WriteFBlend, [Zn2FPU01], 1>; |
| defm : Zn2WriteResFpuPair<WriteFBlendY, [Zn2FPU01], 1>; |
| defm : X86WriteResPairUnsupported<WriteFBlendZ>; |
| defm : Zn2WriteResFpuPair<WriteFVarBlend, [Zn2FPU01], 1>; |
| defm : Zn2WriteResFpuPair<WriteFVarBlendY,[Zn2FPU01], 1>; |
| defm : X86WriteResPairUnsupported<WriteFVarBlendZ>; |
| defm : Zn2WriteResFpuPair<WriteVarBlend, [Zn2FPU0], 1>; |
| defm : Zn2WriteResFpuPair<WriteVarBlendY, [Zn2FPU0], 1>; |
| defm : X86WriteResPairUnsupported<WriteVarBlendZ>; |
| defm : Zn2WriteResFpuPair<WriteCvtSS2I, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtPS2I, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtPS2IY, [Zn2FPU3], 5>; |
| defm : X86WriteResPairUnsupported<WriteCvtPS2IZ>; |
| defm : Zn2WriteResFpuPair<WriteCvtSD2I, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtPD2I, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtPD2IY, [Zn2FPU3], 5>; |
| defm : X86WriteResPairUnsupported<WriteCvtPD2IZ>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2SS, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2PS, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2PSY, [Zn2FPU3], 5>; |
| defm : X86WriteResPairUnsupported<WriteCvtI2PSZ>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2SD, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2PD, [Zn2FPU3], 5>; |
| defm : Zn2WriteResFpuPair<WriteCvtI2PDY, [Zn2FPU3], 5>; |
| defm : X86WriteResPairUnsupported<WriteCvtI2PDZ>; |
| defm : Zn2WriteResFpuPair<WriteFDiv, [Zn2FPU3], 15>; |
| defm : Zn2WriteResFpuPair<WriteFDivX, [Zn2FPU3], 15>; |
| defm : X86WriteResPairUnsupported<WriteFDivZ>; |
| defm : Zn2WriteResFpuPair<WriteFDiv64, [Zn2FPU3], 15>; |
| defm : Zn2WriteResFpuPair<WriteFDiv64X, [Zn2FPU3], 15>; |
| defm : X86WriteResPairUnsupported<WriteFDiv64Z>; |
| defm : Zn2WriteResFpuPair<WriteFSign, [Zn2FPU3], 2>; |
| defm : Zn2WriteResFpuPair<WriteFRnd, [Zn2FPU3], 4, [1], 1, 7, 0>; |
| defm : Zn2WriteResFpuPair<WriteFRndY, [Zn2FPU3], 4, [1], 1, 7, 0>; |
| defm : X86WriteResPairUnsupported<WriteFRndZ>; |
| defm : Zn2WriteResFpuPair<WriteFLogic, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteFLogicY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteFLogicZ>; |
| defm : Zn2WriteResFpuPair<WriteFTest, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteFTestY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteFTestZ>; |
| defm : Zn2WriteResFpuPair<WriteFShuffle, [Zn2FPU12], 1>; |
| defm : Zn2WriteResFpuPair<WriteFShuffleY, [Zn2FPU12], 1>; |
| defm : X86WriteResPairUnsupported<WriteFShuffleZ>; |
| defm : Zn2WriteResFpuPair<WriteFVarShuffle, [Zn2FPU12], 1>; |
| defm : Zn2WriteResFpuPair<WriteFVarShuffleY,[Zn2FPU12], 1>; |
| defm : X86WriteResPairUnsupported<WriteFVarShuffleZ>; |
| defm : Zn2WriteResFpuPair<WriteFMul, [Zn2FPU01], 3, [1], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WriteFMulX, [Zn2FPU01], 3, [1], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WriteFMulY, [Zn2FPU01], 4, [1], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteFMulZ>; |
| defm : Zn2WriteResFpuPair<WriteFMul64, [Zn2FPU01], 3, [1], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WriteFMul64X, [Zn2FPU01], 3, [1], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WriteFMul64Y, [Zn2FPU01], 4, [1], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteFMul64Z>; |
| defm : Zn2WriteResFpuPair<WriteFMA, [Zn2FPU03], 5>; |
| defm : Zn2WriteResFpuPair<WriteFMAX, [Zn2FPU03], 5>; |
| defm : Zn2WriteResFpuPair<WriteFMAY, [Zn2FPU03], 5>; |
| defm : X86WriteResPairUnsupported<WriteFMAZ>; |
| defm : Zn2WriteResFpuPair<WriteFRcp, [Zn2FPU01], 5>; |
| defm : Zn2WriteResFpuPair<WriteFRcpX, [Zn2FPU01], 5>; |
| defm : Zn2WriteResFpuPair<WriteFRcpY, [Zn2FPU01], 5, [1], 1, 7, 2>; |
| defm : X86WriteResPairUnsupported<WriteFRcpZ>; |
| defm : Zn2WriteResFpuPair<WriteFRsqrtX, [Zn2FPU01], 5, [1], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteFRsqrtZ>; |
| defm : Zn2WriteResFpuPair<WriteFSqrt, [Zn2FPU3], 20, [20]>; |
| defm : Zn2WriteResFpuPair<WriteFSqrtX, [Zn2FPU3], 20, [20]>; |
| defm : Zn2WriteResFpuPair<WriteFSqrtY, [Zn2FPU3], 28, [28], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteFSqrtZ>; |
| defm : Zn2WriteResFpuPair<WriteFSqrt64, [Zn2FPU3], 20, [20]>; |
| defm : Zn2WriteResFpuPair<WriteFSqrt64X, [Zn2FPU3], 20, [20]>; |
| defm : Zn2WriteResFpuPair<WriteFSqrt64Y, [Zn2FPU3], 20, [20], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteFSqrt64Z>; |
| defm : Zn2WriteResFpuPair<WriteFSqrt80, [Zn2FPU3], 20, [20]>; |
| |
| // Vector integer operations which uses FPU units |
| defm : X86WriteRes<WriteVecLoad, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteVecLoadX, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteVecLoadY, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteVecLoadNT, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteVecLoadNTY, [Zn2AGU], 8, [1], 1>; |
| defm : X86WriteRes<WriteVecMaskedLoad, [Zn2AGU,Zn2FPU01], 8, [1,2], 2>; |
| defm : X86WriteRes<WriteVecMaskedLoadY, [Zn2AGU,Zn2FPU01], 8, [1,2], 2>; |
| defm : X86WriteRes<WriteVecStore, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecStoreX, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecStoreY, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecStoreNT, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecStoreNTY, [Zn2AGU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecMaskedStore, [Zn2AGU,Zn2FPU01], 4, [1,1], 1>; |
| defm : X86WriteRes<WriteVecMaskedStoreY, [Zn2AGU,Zn2FPU01], 5, [1,1], 2>; |
| defm : X86WriteRes<WriteVecMove, [Zn2FPU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecMoveX, [Zn2FPU], 1, [1], 1>; |
| defm : X86WriteRes<WriteVecMoveY, [Zn2FPU], 2, [1], 2>; |
| defm : X86WriteRes<WriteVecMoveToGpr, [Zn2FPU2], 2, [1], 1>; |
| defm : X86WriteRes<WriteVecMoveFromGpr, [Zn2FPU2], 3, [1], 1>; |
| defm : X86WriteRes<WriteEMMS, [Zn2FPU], 2, [1], 1>; |
| |
| defm : Zn2WriteResFpuPair<WriteVecShift, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecShiftX, [Zn2FPU2], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecShiftY, [Zn2FPU2], 2>; |
| defm : X86WriteResPairUnsupported<WriteVecShiftZ>; |
| defm : Zn2WriteResFpuPair<WriteVecShiftImm, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecShiftImmX, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecShiftImmY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteVecShiftImmZ>; |
| defm : Zn2WriteResFpuPair<WriteVecLogic, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecLogicX, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecLogicY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteVecLogicZ>; |
| defm : Zn2WriteResFpuPair<WriteVecTest, [Zn2FPU12], 1, [2], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WriteVecTestY, [Zn2FPU12], 1, [2], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WriteVecTestZ>; |
| defm : Zn2WriteResFpuPair<WriteVecALU, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecALUX, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVecALUY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteVecALUZ>; |
| defm : Zn2WriteResFpuPair<WriteVecIMul, [Zn2FPU0], 4>; |
| defm : Zn2WriteResFpuPair<WriteVecIMulX, [Zn2FPU0], 4>; |
| defm : Zn2WriteResFpuPair<WriteVecIMulY, [Zn2FPU0], 4>; |
| defm : X86WriteResPairUnsupported<WriteVecIMulZ>; |
| defm : Zn2WriteResFpuPair<WritePMULLD, [Zn2FPU0], 4, [1], 1, 7, 1>; |
| defm : Zn2WriteResFpuPair<WritePMULLDY, [Zn2FPU0], 3, [1], 1, 7, 1>; |
| defm : X86WriteResPairUnsupported<WritePMULLDZ>; |
| defm : Zn2WriteResFpuPair<WriteShuffle, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteShuffleX, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteShuffleY, [Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteShuffleZ>; |
| defm : Zn2WriteResFpuPair<WriteVarShuffle, [Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVarShuffleX,[Zn2FPU], 1>; |
| defm : Zn2WriteResFpuPair<WriteVarShuffleY,[Zn2FPU], 1>; |
| defm : X86WriteResPairUnsupported<WriteVarShuffleZ>; |
| defm : Zn2WriteResFpuPair<WriteBlend, [Zn2FPU01], 1>; |
| defm : Zn2WriteResFpuPair<WriteBlendY, [Zn2FPU01], 1>; |
| defm : X86WriteResPairUnsupported<WriteBlendZ>; |
| defm : Zn2WriteResFpuPair<WriteShuffle256, [Zn2FPU], 2>; |
| defm : Zn2WriteResFpuPair<WriteVarShuffle256, [Zn2FPU], 2>; |
| defm : Zn2WriteResFpuPair<WritePSADBW, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WritePSADBWX, [Zn2FPU0], 3>; |
| defm : Zn2WriteResFpuPair<WritePSADBWY, [Zn2FPU0], 3>; |
| defm : X86WriteResPairUnsupported<WritePSADBWZ>; |
| defm : Zn2WriteResFpuPair<WritePHMINPOS, [Zn2FPU0], 4>; |
| |
| // Vector Shift Operations |
| defm : Zn2WriteResFpuPair<WriteVarVecShift, [Zn2FPU12], 1>; |
| defm : Zn2WriteResFpuPair<WriteVarVecShiftY, [Zn2FPU12], 1>; |
| defm : X86WriteResPairUnsupported<WriteVarVecShiftZ>; |
| |
| // Vector insert/extract operations. |
| defm : Zn2WriteResFpuPair<WriteVecInsert, [Zn2FPU], 1>; |
| |
| def : WriteRes<WriteVecExtract, [Zn2FPU12, Zn2FPU2]> { |
| let Latency = 2; |
| let ResourceCycles = [1, 2]; |
| } |
| def : WriteRes<WriteVecExtractSt, [Zn2AGU, Zn2FPU12, Zn2FPU2]> { |
| let Latency = 5; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1, 2, 3]; |
| } |
| |
| // MOVMSK Instructions. |
| def : WriteRes<WriteFMOVMSK, [Zn2FPU2]>; |
| def : WriteRes<WriteMMXMOVMSK, [Zn2FPU2]>; |
| def : WriteRes<WriteVecMOVMSK, [Zn2FPU2]>; |
| |
| def : WriteRes<WriteVecMOVMSKY, [Zn2FPU2]> { |
| let NumMicroOps = 2; |
| let Latency = 2; |
| let ResourceCycles = [2]; |
| } |
| |
| // AES Instructions. |
| defm : Zn2WriteResFpuPair<WriteAESDecEnc, [Zn2FPU01], 4>; |
| defm : Zn2WriteResFpuPair<WriteAESIMC, [Zn2FPU01], 4>; |
| defm : Zn2WriteResFpuPair<WriteAESKeyGen, [Zn2FPU01], 4>; |
| |
| def : WriteRes<WriteFence, [Zn2AGU]>; |
| def : WriteRes<WriteNop, []>; |
| |
| // Following instructions with latency=100 are microcoded. |
| // We set long latency so as to block the entire pipeline. |
| defm : Zn2WriteResFpuPair<WriteFShuffle256, [Zn2FPU], 100>; |
| defm : Zn2WriteResFpuPair<WriteFVarShuffle256, [Zn2FPU], 100>; |
| |
| // Microcoded Instructions |
| def Zn2WriteMicrocoded : SchedWriteRes<[]> { |
| let Latency = 100; |
| } |
| |
| def : SchedAlias<WriteMicrocoded, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteFCMOV, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteSystem, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteMPSAD, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteMPSADY, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteMPSADLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteMPSADYLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCLMul, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCLMulLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpIStrM, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpIStrMLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpEStrI, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpEStrILd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpEStrM, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpEStrMLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpIStrI, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePCmpIStrILd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteLDMXCSR, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteSTMXCSR, Zn2WriteMicrocoded>; |
| |
| //=== Regex based InstRW ===// |
| // Notation: |
| // - r: register. |
| // - m = memory. |
| // - i = immediate |
| // - mm: 64 bit mmx register. |
| // - x = 128 bit xmm register. |
| // - (x)mm = mmx or xmm register. |
| // - y = 256 bit ymm register. |
| // - v = any vector register. |
| |
| //=== Integer Instructions ===// |
| //-- Move instructions --// |
| // MOV. |
| // r16,m. |
| def : InstRW<[WriteALULd, ReadAfterLd], (instregex "MOV16rm")>; |
| |
| // MOVSX, MOVZX. |
| // r,m. |
| def : InstRW<[WriteLoad], (instregex "MOV(S|Z)X32rm(8|16)")>; |
| |
| // XCHG. |
| // r,r. |
| def Zn2WriteXCHG : SchedWriteRes<[Zn2ALU]> { |
| let NumMicroOps = 2; |
| } |
| |
| def : InstRW<[Zn2WriteXCHG], (instregex "XCHG(8|16|32|64)rr", "XCHG(16|32|64)ar")>; |
| |
| // r,m. |
| def Zn2WriteXCHGrm : SchedWriteRes<[Zn2AGU, Zn2ALU]> { |
| let Latency = 5; |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteXCHGrm, ReadAfterLd], (instregex "XCHG(8|16|32|64)rm")>; |
| |
| def : InstRW<[WriteMicrocoded], (instrs XLAT)>; |
| |
| // POP16. |
| // r. |
| def Zn2WritePop16r : SchedWriteRes<[Zn2AGU]>{ |
| let Latency = 5; |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WritePop16r], (instregex "POP16rmm")>; |
| def : InstRW<[WriteMicrocoded], (instregex "POPF(16|32)")>; |
| def : InstRW<[WriteMicrocoded], (instregex "POPA(16|32)")>; |
| |
| |
| // PUSH. |
| // r. Has default values. |
| // m. |
| def Zn2WritePUSH : SchedWriteRes<[Zn2AGU]>{ |
| let Latency = 4; |
| } |
| def : InstRW<[Zn2WritePUSH], (instregex "PUSH(16|32)rmm")>; |
| |
| //PUSHF |
| def : InstRW<[WriteMicrocoded], (instregex "PUSHF(16|32)")>; |
| |
| // PUSHA. |
| def Zn2WritePushA : SchedWriteRes<[Zn2AGU]> { |
| let Latency = 8; |
| } |
| def : InstRW<[Zn2WritePushA], (instregex "PUSHA(16|32)")>; |
| |
| //LAHF |
| def : InstRW<[WriteMicrocoded], (instrs LAHF)>; |
| |
| // MOVBE. |
| // r,m. |
| def Zn2WriteMOVBE : SchedWriteRes<[Zn2AGU, Zn2ALU]> { |
| let Latency = 5; |
| } |
| def : InstRW<[Zn2WriteMOVBE, ReadAfterLd], (instregex "MOVBE(16|32|64)rm")>; |
| |
| // m16,r16. |
| def : InstRW<[Zn2WriteMOVBE], (instregex "MOVBE(16|32|64)mr")>; |
| |
| //-- Arithmetic instructions --// |
| |
| // ADD SUB. |
| // m,r/i. |
| def : InstRW<[WriteALULd], (instregex "(ADD|SUB)(8|16|32|64)m(r|i)", |
| "(ADD|SUB)(8|16|32|64)mi8", |
| "(ADD|SUB)64mi32")>; |
| |
| // ADC SBB. |
| // m,r/i. |
| def : InstRW<[WriteALULd], |
| (instregex "(ADC|SBB)(8|16|32|64)m(r|i)", |
| "(ADC|SBB)(16|32|64)mi8", |
| "(ADC|SBB)64mi32")>; |
| |
| // INC DEC NOT NEG. |
| // m. |
| def : InstRW<[WriteALULd], |
| (instregex "(INC|DEC|NOT|NEG)(8|16|32|64)m")>; |
| |
| // MUL IMUL. |
| // r16. |
| def Zn2WriteMul16 : SchedWriteRes<[Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 3; |
| } |
| def : SchedAlias<WriteIMul16, Zn2WriteMul16>; |
| def : SchedAlias<WriteIMul16Imm, Zn2WriteMul16>; |
| def : SchedAlias<WriteIMul16Reg, Zn2WriteMul16>; |
| |
| // m16. |
| def Zn2WriteMul16Ld : SchedWriteRes<[Zn2AGU, Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 7; |
| } |
| def : SchedAlias<WriteIMul16Ld, Zn2WriteMul16Ld>; |
| def : SchedAlias<WriteIMul16ImmLd, Zn2WriteMul16Ld>; |
| def : SchedAlias<WriteIMul16RegLd, Zn2WriteMul16Ld>; |
| |
| // r32. |
| def Zn2WriteMul32 : SchedWriteRes<[Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 3; |
| } |
| def : SchedAlias<WriteIMul32, Zn2WriteMul32>; |
| def : SchedAlias<WriteIMul32Imm, Zn2WriteMul32>; |
| def : SchedAlias<WriteIMul32Reg, Zn2WriteMul32>; |
| |
| // m32. |
| def Zn2WriteMul32Ld : SchedWriteRes<[Zn2AGU, Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 7; |
| } |
| def : SchedAlias<WriteIMul32Ld, Zn2WriteMul32Ld>; |
| def : SchedAlias<WriteIMul32ImmLd, Zn2WriteMul32Ld>; |
| def : SchedAlias<WriteIMul32RegLd, Zn2WriteMul32Ld>; |
| |
| // r64. |
| def Zn2WriteMul64 : SchedWriteRes<[Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 4; |
| let NumMicroOps = 2; |
| } |
| def : SchedAlias<WriteIMul64, Zn2WriteMul64>; |
| def : SchedAlias<WriteIMul64Imm, Zn2WriteMul64>; |
| def : SchedAlias<WriteIMul64Reg, Zn2WriteMul64>; |
| |
| // m64. |
| def Zn2WriteMul64Ld : SchedWriteRes<[Zn2AGU, Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| def : SchedAlias<WriteIMul64Ld, Zn2WriteMul64Ld>; |
| def : SchedAlias<WriteIMul64ImmLd, Zn2WriteMul64Ld>; |
| def : SchedAlias<WriteIMul64RegLd, Zn2WriteMul64Ld>; |
| |
| // MULX. |
| // r32,r32,r32. |
| def Zn2WriteMulX32 : SchedWriteRes<[Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 3; |
| let ResourceCycles = [1, 2]; |
| } |
| def : InstRW<[Zn2WriteMulX32], (instrs MULX32rr)>; |
| |
| // r32,r32,m32. |
| def Zn2WriteMulX32Ld : SchedWriteRes<[Zn2AGU, Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 7; |
| let ResourceCycles = [1, 2, 2]; |
| } |
| def : InstRW<[Zn2WriteMulX32Ld, ReadAfterLd], (instrs MULX32rm)>; |
| |
| // r64,r64,r64. |
| def Zn2WriteMulX64 : SchedWriteRes<[Zn2ALU1]> { |
| let Latency = 3; |
| } |
| def : InstRW<[Zn2WriteMulX64], (instrs MULX64rr)>; |
| |
| // r64,r64,m64. |
| def Zn2WriteMulX64Ld : SchedWriteRes<[Zn2AGU, Zn2ALU1, Zn2Multiplier]> { |
| let Latency = 7; |
| } |
| def : InstRW<[Zn2WriteMulX64Ld, ReadAfterLd], (instrs MULX64rm)>; |
| |
| //-- Control transfer instructions --// |
| |
| // J(E|R)CXZ. |
| def Zn2WriteJCXZ : SchedWriteRes<[Zn2ALU03]>; |
| def : InstRW<[Zn2WriteJCXZ], (instrs JCXZ, JECXZ, JRCXZ)>; |
| |
| // INTO |
| def : InstRW<[WriteMicrocoded], (instrs INTO)>; |
| |
| // LOOP. |
| def Zn2WriteLOOP : SchedWriteRes<[Zn2ALU03]>; |
| def : InstRW<[Zn2WriteLOOP], (instrs LOOP)>; |
| |
| // LOOP(N)E, LOOP(N)Z |
| def Zn2WriteLOOPE : SchedWriteRes<[Zn2ALU03]>; |
| def : InstRW<[Zn2WriteLOOPE], (instrs LOOPE, LOOPNE)>; |
| |
| // CALL. |
| // r. |
| def Zn2WriteCALLr : SchedWriteRes<[Zn2AGU, Zn2ALU03]>; |
| def : InstRW<[Zn2WriteCALLr], (instregex "CALL(16|32)r")>; |
| |
| def : InstRW<[WriteMicrocoded], (instregex "CALL(16|32)m")>; |
| |
| // RET. |
| def Zn2WriteRET : SchedWriteRes<[Zn2ALU03]> { |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)", |
| "IRET(16|32|64)")>; |
| |
| //-- Logic instructions --// |
| |
| // AND OR XOR. |
| // m,r/i. |
| def : InstRW<[WriteALULd], |
| (instregex "(AND|OR|XOR)(8|16|32|64)m(r|i)", |
| "(AND|OR|XOR)(8|16|32|64)mi8", "(AND|OR|XOR)64mi32")>; |
| |
| // Define ALU latency variants |
| def Zn2WriteALULat2 : SchedWriteRes<[Zn2ALU]> { |
| let Latency = 2; |
| } |
| def Zn2WriteALULat2Ld : SchedWriteRes<[Zn2AGU, Zn2ALU]> { |
| let Latency = 6; |
| } |
| |
| // BT. |
| // m,i. |
| def : InstRW<[WriteShiftLd], (instregex "BT(16|32|64)mi8")>; |
| |
| // BTR BTS BTC. |
| // r,r,i. |
| def Zn2WriteBTRSC : SchedWriteRes<[Zn2ALU]> { |
| let Latency = 2; |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteBTRSC], (instregex "BT(R|S|C)(16|32|64)r(r|i8)")>; |
| |
| // m,r,i. |
| def Zn2WriteBTRSCm : SchedWriteRes<[Zn2AGU, Zn2ALU]> { |
| let Latency = 6; |
| let NumMicroOps = 2; |
| } |
| // m,r,i. |
| def : SchedAlias<WriteBitTestSetImmRMW, Zn2WriteBTRSCm>; |
| def : SchedAlias<WriteBitTestSetRegRMW, Zn2WriteBTRSCm>; |
| |
| // BLSI BLSMSK BLSR. |
| // r,r. |
| def : SchedAlias<WriteBLS, Zn2WriteALULat2>; |
| // r,m. |
| def : SchedAlias<WriteBLSLd, Zn2WriteALULat2Ld>; |
| |
| // CLD STD. |
| def : InstRW<[WriteALU], (instrs STD, CLD)>; |
| |
| // PDEP PEXT. |
| // r,r,r. |
| def : InstRW<[WriteMicrocoded], (instregex "PDEP(32|64)rr", "PEXT(32|64)rr")>; |
| // r,r,m. |
| def : InstRW<[WriteMicrocoded], (instregex "PDEP(32|64)rm", "PEXT(32|64)rm")>; |
| |
| // RCR RCL. |
| // m,i. |
| def : InstRW<[WriteMicrocoded], (instregex "RC(R|L)(8|16|32|64)m(1|i|CL)")>; |
| |
| // SHR SHL SAR. |
| // m,i. |
| def : InstRW<[WriteShiftLd], (instregex "S(A|H)(R|L)(8|16|32|64)m(i|1)")>; |
| |
| // SHRD SHLD. |
| // m,r |
| def : InstRW<[WriteShiftLd], (instregex "SH(R|L)D(16|32|64)mri8")>; |
| |
| // r,r,cl. |
| def : InstRW<[WriteMicrocoded], (instregex "SH(R|L)D(16|32|64)rrCL")>; |
| |
| // m,r,cl. |
| def : InstRW<[WriteMicrocoded], (instregex "SH(R|L)D(16|32|64)mrCL")>; |
| |
| //-- Misc instructions --// |
| // CMPXCHG8B. |
| def Zn2WriteCMPXCHG8B : SchedWriteRes<[Zn2AGU, Zn2ALU]> { |
| let NumMicroOps = 18; |
| } |
| def : InstRW<[Zn2WriteCMPXCHG8B], (instrs CMPXCHG8B)>; |
| |
| def : InstRW<[WriteMicrocoded], (instrs CMPXCHG16B)>; |
| |
| // LEAVE |
| def Zn2WriteLEAVE : SchedWriteRes<[Zn2ALU, Zn2AGU]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteLEAVE], (instregex "LEAVE")>; |
| |
| // PAUSE. |
| def : InstRW<[WriteMicrocoded], (instrs PAUSE)>; |
| |
| // RDTSC. |
| def : InstRW<[WriteMicrocoded], (instregex "RDTSC")>; |
| |
| // RDPMC. |
| def : InstRW<[WriteMicrocoded], (instrs RDPMC)>; |
| |
| // RDRAND. |
| def : InstRW<[WriteMicrocoded], (instregex "RDRAND(16|32|64)r")>; |
| |
| // XGETBV. |
| def : InstRW<[WriteMicrocoded], (instregex "XGETBV")>; |
| |
| //-- String instructions --// |
| // CMPS. |
| def : InstRW<[WriteMicrocoded], (instregex "CMPS(B|L|Q|W)")>; |
| |
| // LODSB/W. |
| def : InstRW<[WriteMicrocoded], (instregex "LODS(B|W)")>; |
| |
| // LODSD/Q. |
| def : InstRW<[WriteMicrocoded], (instregex "LODS(L|Q)")>; |
| |
| // MOVS. |
| def : InstRW<[WriteMicrocoded], (instregex "MOVS(B|L|Q|W)")>; |
| |
| // SCAS. |
| def : InstRW<[WriteMicrocoded], (instregex "SCAS(B|W|L|Q)")>; |
| |
| // STOS |
| def : InstRW<[WriteMicrocoded], (instregex "STOS(B|L|Q|W)")>; |
| |
| // XADD. |
| def Zn2XADD : SchedWriteRes<[Zn2ALU]>; |
| def : InstRW<[Zn2XADD], (instregex "XADD(8|16|32|64)rr")>; |
| def : InstRW<[WriteMicrocoded], (instregex "XADD(8|16|32|64)rm")>; |
| |
| //=== Floating Point x87 Instructions ===// |
| //-- Move instructions --// |
| |
| def Zn2WriteFLDr : SchedWriteRes<[Zn2FPU13]> ; |
| |
| def Zn2WriteSTr: SchedWriteRes<[Zn2FPU23]> { |
| let Latency = 5; |
| let NumMicroOps = 2; |
| } |
| |
| // LD_F. |
| // r. |
| def : InstRW<[Zn2WriteFLDr], (instregex "LD_Frr")>; |
| |
| // m. |
| def Zn2WriteLD_F80m : SchedWriteRes<[Zn2AGU, Zn2FPU13]> { |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteLD_F80m], (instregex "LD_F80m")>; |
| |
| // FBLD. |
| def : InstRW<[WriteMicrocoded], (instregex "FBLDm")>; |
| |
| // FST(P). |
| // r. |
| def : InstRW<[Zn2WriteSTr], (instregex "ST_(F|FP)rr")>; |
| |
| // m80. |
| def Zn2WriteST_FP80m : SchedWriteRes<[Zn2AGU, Zn2FPU23]> { |
| let Latency = 5; |
| } |
| def : InstRW<[Zn2WriteST_FP80m], (instregex "ST_FP80m")>; |
| |
| // FBSTP. |
| // m80. |
| def : InstRW<[WriteMicrocoded], (instregex "FBSTPm")>; |
| |
| def Zn2WriteFXCH : SchedWriteRes<[Zn2FPU]>; |
| |
| // FXCHG. |
| def : InstRW<[Zn2WriteFXCH], (instrs XCH_F)>; |
| |
| // FILD. |
| def Zn2WriteFILD : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 11; |
| let NumMicroOps = 2; |
| } |
| def : InstRW<[Zn2WriteFILD], (instregex "ILD_F(16|32|64)m")>; |
| |
| // FIST(P) FISTTP. |
| def Zn2WriteFIST : SchedWriteRes<[Zn2AGU, Zn2FPU23]> { |
| let Latency = 12; |
| } |
| def : InstRW<[Zn2WriteFIST], (instregex "IS(T|TT)_(F|FP)(16|32|64)m")>; |
| |
| def Zn2WriteFPU13 : SchedWriteRes<[Zn2AGU, Zn2FPU13]> { |
| let Latency = 8; |
| } |
| |
| def Zn2WriteFPU3 : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 11; |
| } |
| |
| // FLDZ. |
| def : SchedAlias<WriteFLD0, Zn2WriteFPU13>; |
| |
| // FLD1. |
| def : SchedAlias<WriteFLD1, Zn2WriteFPU3>; |
| |
| // FLDPI FLDL2E etc. |
| def : SchedAlias<WriteFLDC, Zn2WriteFPU3>; |
| |
| // FNSTSW. |
| // AX. |
| def : InstRW<[WriteMicrocoded], (instrs FNSTSW16r)>; |
| |
| // m16. |
| def : InstRW<[WriteMicrocoded], (instrs FNSTSWm)>; |
| |
| // FLDCW. |
| def : InstRW<[WriteMicrocoded], (instrs FLDCW16m)>; |
| |
| // FNSTCW. |
| def : InstRW<[WriteMicrocoded], (instrs FNSTCW16m)>; |
| |
| // FINCSTP FDECSTP. |
| def : InstRW<[Zn2WriteFPU3], (instrs FINCSTP, FDECSTP)>; |
| |
| // FFREE. |
| def : InstRW<[Zn2WriteFPU3], (instregex "FFREE")>; |
| |
| // FNSAVE. |
| def : InstRW<[WriteMicrocoded], (instregex "FSAVEm")>; |
| |
| // FRSTOR. |
| def : InstRW<[WriteMicrocoded], (instregex "FRSTORm")>; |
| |
| //-- Arithmetic instructions --// |
| |
| def Zn2WriteFPU3Lat1 : SchedWriteRes<[Zn2FPU3]> ; |
| |
| def Zn2WriteFPU0Lat1 : SchedWriteRes<[Zn2FPU0]> ; |
| |
| def Zn2WriteFPU0Lat1Ld : SchedWriteRes<[Zn2AGU, Zn2FPU0]> { |
| let Latency = 8; |
| } |
| |
| // FCHS. |
| def : InstRW<[Zn2WriteFPU3Lat1], (instregex "CHS_F")>; |
| |
| // FCOM(P) FUCOM(P). |
| // r. |
| def : InstRW<[Zn2WriteFPU0Lat1], (instregex "COM(P?)_FST0r", "UCOM_F(P?)r")>; |
| // m. |
| def : InstRW<[Zn2WriteFPU0Lat1Ld], (instregex "FCOM(P?)(32|64)m")>; |
| |
| // FCOMPP FUCOMPP. |
| // r. |
| def : InstRW<[Zn2WriteFPU0Lat1], (instrs FCOMPP, UCOM_FPPr)>; |
| |
| def Zn2WriteFPU02 : SchedWriteRes<[Zn2AGU, Zn2FPU02]> |
| { |
| let Latency = 9; |
| } |
| |
| // FCOMI(P) FUCOMI(P). |
| // m. |
| def : InstRW<[Zn2WriteFPU02], (instrs COM_FIPr, COM_FIr, UCOM_FIPr, UCOM_FIr)>; |
| |
| def Zn2WriteFPU03 : SchedWriteRes<[Zn2AGU, Zn2FPU03]> |
| { |
| let Latency = 12; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1,3]; |
| } |
| |
| // FICOM(P). |
| def : InstRW<[Zn2WriteFPU03], (instregex "FICOM(P?)(16|32)m")>; |
| |
| // FTST. |
| def : InstRW<[Zn2WriteFPU0Lat1], (instregex "TST_F")>; |
| |
| // FXAM. |
| def : InstRW<[Zn2WriteFPU3Lat1], (instrs FXAM)>; |
| |
| // FPREM. |
| def : InstRW<[WriteMicrocoded], (instrs FPREM)>; |
| |
| // FPREM1. |
| def : InstRW<[WriteMicrocoded], (instrs FPREM1)>; |
| |
| // FRNDINT. |
| def : InstRW<[WriteMicrocoded], (instrs FRNDINT)>; |
| |
| // FSCALE. |
| def : InstRW<[WriteMicrocoded], (instrs FSCALE)>; |
| |
| // FXTRACT. |
| def : InstRW<[WriteMicrocoded], (instrs FXTRACT)>; |
| |
| // FNOP. |
| def : InstRW<[Zn2WriteFPU0Lat1], (instrs FNOP)>; |
| |
| // WAIT. |
| def : InstRW<[Zn2WriteFPU0Lat1], (instrs WAIT)>; |
| |
| // FNCLEX. |
| def : InstRW<[WriteMicrocoded], (instrs FNCLEX)>; |
| |
| // FNINIT. |
| def : InstRW<[WriteMicrocoded], (instrs FNINIT)>; |
| |
| //=== Integer MMX and XMM Instructions ===// |
| |
| // PACKSSWB/DW. |
| // mm <- mm. |
| def Zn2WriteFPU12 : SchedWriteRes<[Zn2FPU12]> ; |
| def Zn2WriteFPU12Y : SchedWriteRes<[Zn2FPU12]> { |
| let NumMicroOps = 2; |
| } |
| def Zn2WriteFPU12m : SchedWriteRes<[Zn2AGU, Zn2FPU12]> ; |
| def Zn2WriteFPU12Ym : SchedWriteRes<[Zn2AGU, Zn2FPU12]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| |
| def : InstRW<[Zn2WriteFPU12], (instrs MMX_PACKSSDWirr, |
| MMX_PACKSSWBirr, |
| MMX_PACKUSWBirr)>; |
| def : InstRW<[Zn2WriteFPU12m], (instrs MMX_PACKSSDWirm, |
| MMX_PACKSSWBirm, |
| MMX_PACKUSWBirm)>; |
| |
| // VPMOVSX/ZX BW BD BQ WD WQ DQ. |
| // y <- x. |
| def : InstRW<[Zn2WriteFPU12Y], (instregex "VPMOV(SX|ZX)(BW|BD|BQ|WD|WQ|DQ)Yrr")>; |
| def : InstRW<[Zn2WriteFPU12Ym], (instregex "VPMOV(SX|ZX)(BW|BD|BQ|WD|WQ|DQ)Yrm")>; |
| |
| def Zn2WriteFPU013 : SchedWriteRes<[Zn2FPU013]> ; |
| def Zn2WriteFPU013Y : SchedWriteRes<[Zn2FPU013]> ; |
| def Zn2WriteFPU013m : SchedWriteRes<[Zn2AGU, Zn2FPU013]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| def Zn2WriteFPU013Ld : SchedWriteRes<[Zn2AGU, Zn2FPU013]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| def Zn2WriteFPU013LdY : SchedWriteRes<[Zn2AGU, Zn2FPU013]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| } |
| |
| // PBLENDW. |
| // x,x,i / v,v,v,i |
| def : InstRW<[Zn2WriteFPU013], (instregex "(V?)PBLENDWrri")>; |
| // ymm |
| def : InstRW<[Zn2WriteFPU013Y], (instrs VPBLENDWYrri)>; |
| |
| // x,m,i / v,v,m,i |
| def : InstRW<[Zn2WriteFPU013Ld], (instregex "(V?)PBLENDWrmi")>; |
| // y,m,i |
| def : InstRW<[Zn2WriteFPU013LdY], (instrs VPBLENDWYrmi)>; |
| |
| def Zn2WriteFPU01 : SchedWriteRes<[Zn2FPU01]> ; |
| def Zn2WriteFPU01Y : SchedWriteRes<[Zn2FPU01]> { |
| let NumMicroOps = 2; |
| } |
| |
| // VPBLENDD. |
| // v,v,v,i. |
| def : InstRW<[Zn2WriteFPU01], (instrs VPBLENDDrri)>; |
| // ymm |
| def : InstRW<[Zn2WriteFPU01Y], (instrs VPBLENDDYrri)>; |
| |
| // v,v,m,i |
| def Zn2WriteFPU01Op2 : SchedWriteRes<[Zn2AGU, Zn2FPU01]> { |
| let NumMicroOps = 2; |
| let Latency = 8; |
| let ResourceCycles = [1, 2]; |
| } |
| def Zn2WriteFPU01Op2Y : SchedWriteRes<[Zn2AGU, Zn2FPU01]> { |
| let NumMicroOps = 2; |
| let Latency = 9; |
| let ResourceCycles = [1, 3]; |
| } |
| def : InstRW<[Zn2WriteFPU01Op2], (instrs VPBLENDDrmi)>; |
| def : InstRW<[Zn2WriteFPU01Op2Y], (instrs VPBLENDDYrmi)>; |
| |
| // MASKMOVQ. |
| def : InstRW<[WriteMicrocoded], (instregex "MMX_MASKMOVQ(64)?")>; |
| |
| // MASKMOVDQU. |
| def : InstRW<[WriteMicrocoded], (instregex "(V?)MASKMOVDQU(64)?")>; |
| |
| // VPMASKMOVD. |
| // ymm |
| def : InstRW<[WriteMicrocoded], |
| (instregex "VPMASKMOVD(Y?)rm")>; |
| // m, v,v. |
| def : InstRW<[WriteMicrocoded], (instregex "VPMASKMOV(D|Q)(Y?)mr")>; |
| |
| // VPBROADCAST B/W. |
| // x, m8/16. |
| def Zn2WriteVPBROADCAST128Ld : SchedWriteRes<[Zn2AGU, Zn2FPU12]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1, 2]; |
| } |
| def : InstRW<[Zn2WriteVPBROADCAST128Ld], |
| (instregex "VPBROADCAST(B|W)rm")>; |
| |
| // y, m8/16 |
| def Zn2WriteVPBROADCAST256Ld : SchedWriteRes<[Zn2AGU, Zn2FPU1]> { |
| let Latency = 8; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1, 2]; |
| } |
| def : InstRW<[Zn2WriteVPBROADCAST256Ld], |
| (instregex "VPBROADCAST(B|W)Yrm")>; |
| |
| // VPGATHER. |
| def : InstRW<[WriteMicrocoded], (instregex "VPGATHER(Q|D)(Q|D)(Y?)rm")>; |
| |
| //-- Arithmetic instructions --// |
| |
| // HADD, HSUB PS/PD |
| // PHADD|PHSUB (S) W/D. |
| def : SchedAlias<WritePHAdd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePHAddLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePHAddX, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePHAddXLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePHAddY, Zn2WriteMicrocoded>; |
| def : SchedAlias<WritePHAddYLd, Zn2WriteMicrocoded>; |
| |
| // PCMPGTQ. |
| def Zn2WritePCMPGTQr : SchedWriteRes<[Zn2FPU03]>; |
| def : InstRW<[Zn2WritePCMPGTQr], (instregex "(V?)PCMPGTQ(Y?)rr")>; |
| |
| // x <- x,m. |
| def Zn2WritePCMPGTQm : SchedWriteRes<[Zn2AGU, Zn2FPU03]> { |
| let Latency = 8; |
| } |
| // ymm. |
| def Zn2WritePCMPGTQYm : SchedWriteRes<[Zn2AGU, Zn2FPU03]> { |
| let Latency = 8; |
| } |
| def : InstRW<[Zn2WritePCMPGTQm], (instregex "(V?)PCMPGTQrm")>; |
| def : InstRW<[Zn2WritePCMPGTQYm], (instrs VPCMPGTQYrm)>; |
| |
| //-- Logic instructions --// |
| |
| // PSLL,PSRL,PSRA W/D/Q. |
| // x,x / v,v,x. |
| def Zn2WritePShift : SchedWriteRes<[Zn2FPU2]> ; |
| def Zn2WritePShiftY : SchedWriteRes<[Zn2FPU2]> ; |
| |
| // PSLL,PSRL DQ. |
| def : InstRW<[Zn2WritePShift], (instregex "(V?)PS(R|L)LDQri")>; |
| def : InstRW<[Zn2WritePShiftY], (instregex "(V?)PS(R|L)LDQYri")>; |
| |
| //=== Floating Point XMM and YMM Instructions ===// |
| //-- Move instructions --// |
| |
| // VPERM2F128. |
| def : InstRW<[WriteMicrocoded], (instrs VPERM2F128rr)>; |
| def : InstRW<[WriteMicrocoded], (instrs VPERM2F128rm)>; |
| |
| def Zn2WriteBROADCAST : SchedWriteRes<[Zn2AGU, Zn2FPU13]> { |
| let NumMicroOps = 2; |
| let Latency = 8; |
| } |
| // VBROADCASTF128. |
| def : InstRW<[Zn2WriteBROADCAST], (instrs VBROADCASTF128)>; |
| |
| // EXTRACTPS. |
| // r32,x,i. |
| def Zn2WriteEXTRACTPSr : SchedWriteRes<[Zn2FPU12, Zn2FPU2]> { |
| let Latency = 2; |
| let ResourceCycles = [1, 2]; |
| } |
| def : InstRW<[Zn2WriteEXTRACTPSr], (instregex "(V?)EXTRACTPSrr")>; |
| |
| def Zn2WriteEXTRACTPSm : SchedWriteRes<[Zn2AGU,Zn2FPU12, Zn2FPU2]> { |
| let Latency = 5; |
| let NumMicroOps = 2; |
| let ResourceCycles = [5, 1, 2]; |
| } |
| // m32,x,i. |
| def : InstRW<[Zn2WriteEXTRACTPSm], (instregex "(V?)EXTRACTPSmr")>; |
| |
| // VEXTRACTF128. |
| // x,y,i. |
| def : InstRW<[Zn2WriteFPU013], (instrs VEXTRACTF128rr)>; |
| |
| // m128,y,i. |
| def : InstRW<[Zn2WriteFPU013m], (instrs VEXTRACTF128mr)>; |
| |
| def Zn2WriteVINSERT128r: SchedWriteRes<[Zn2FPU013]> { |
| let Latency = 2; |
| // let ResourceCycles = [2]; |
| } |
| def Zn2WriteVINSERT128Ld: SchedWriteRes<[Zn2AGU,Zn2FPU013]> { |
| let Latency = 9; |
| let NumMicroOps = 2; |
| } |
| // VINSERTF128. |
| // y,y,x,i. |
| def : InstRW<[Zn2WriteVINSERT128r], (instrs VINSERTF128rr)>; |
| def : InstRW<[Zn2WriteVINSERT128Ld], (instrs VINSERTF128rm)>; |
| |
| // VGATHER. |
| def : InstRW<[WriteMicrocoded], (instregex "VGATHER(Q|D)(PD|PS)(Y?)rm")>; |
| |
| //-- Conversion instructions --// |
| def Zn2WriteCVTPD2PSr: SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 3; |
| } |
| def Zn2WriteCVTPD2PSYr: SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 3; |
| } |
| |
| // CVTPD2PS. |
| // x,x. |
| def : SchedAlias<WriteCvtPD2PS, Zn2WriteCVTPD2PSr>; |
| // y,y. |
| def : SchedAlias<WriteCvtPD2PSY, Zn2WriteCVTPD2PSYr>; |
| // z,z. |
| defm : X86WriteResUnsupported<WriteCvtPD2PSZ>; |
| |
| def Zn2WriteCVTPD2PSLd: SchedWriteRes<[Zn2AGU,Zn2FPU03]> { |
| let Latency = 10; |
| let NumMicroOps = 2; |
| } |
| // x,m128. |
| def : SchedAlias<WriteCvtPD2PSLd, Zn2WriteCVTPD2PSLd>; |
| |
| // x,m256. |
| def Zn2WriteCVTPD2PSYLd : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 10; |
| } |
| def : SchedAlias<WriteCvtPD2PSYLd, Zn2WriteCVTPD2PSYLd>; |
| // z,m512 |
| defm : X86WriteResUnsupported<WriteCvtPD2PSZLd>; |
| |
| // CVTSD2SS. |
| // x,x. |
| // Same as WriteCVTPD2PSr |
| def : SchedAlias<WriteCvtSD2SS, Zn2WriteCVTPD2PSr>; |
| |
| // x,m64. |
| def : SchedAlias<WriteCvtSD2SSLd, Zn2WriteCVTPD2PSLd>; |
| |
| // CVTPS2PD. |
| // x,x. |
| def Zn2WriteCVTPS2PDr : SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 3; |
| } |
| def : SchedAlias<WriteCvtPS2PD, Zn2WriteCVTPS2PDr>; |
| |
| // x,m64. |
| // y,m128. |
| def Zn2WriteCVTPS2PDLd : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 10; |
| let NumMicroOps = 2; |
| } |
| def : SchedAlias<WriteCvtPS2PDLd, Zn2WriteCVTPS2PDLd>; |
| def : SchedAlias<WriteCvtPS2PDYLd, Zn2WriteCVTPS2PDLd>; |
| defm : X86WriteResUnsupported<WriteCvtPS2PDZLd>; |
| |
| // y,x. |
| def Zn2WriteVCVTPS2PDY : SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 3; |
| } |
| def : SchedAlias<WriteCvtPS2PDY, Zn2WriteVCVTPS2PDY>; |
| defm : X86WriteResUnsupported<WriteCvtPS2PDZ>; |
| |
| // CVTSS2SD. |
| // x,x. |
| def Zn2WriteCVTSS2SDr : SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 3; |
| } |
| def : SchedAlias<WriteCvtSS2SD, Zn2WriteCVTSS2SDr>; |
| |
| // x,m32. |
| def Zn2WriteCVTSS2SDLd : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 10; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1, 2]; |
| } |
| def : SchedAlias<WriteCvtSS2SDLd, Zn2WriteCVTSS2SDLd>; |
| |
| def Zn2WriteCVTDQ2PDr: SchedWriteRes<[Zn2FPU12,Zn2FPU3]> { |
| let Latency = 3; |
| } |
| // CVTDQ2PD. |
| // x,x. |
| def : InstRW<[Zn2WriteCVTDQ2PDr], (instregex "(V)?CVTDQ2PDrr")>; |
| |
| // Same as xmm |
| // y,x. |
| def : InstRW<[Zn2WriteCVTDQ2PDr], (instrs VCVTDQ2PDYrr)>; |
| def : InstRW<[Zn2WriteCVTDQ2PDr], (instrs VCVTDQ2PSYrr)>; |
| |
| def Zn2WriteCVTPD2DQr: SchedWriteRes<[Zn2FPU12, Zn2FPU3]> { |
| let Latency = 3; |
| } |
| // CVT(T)PD2DQ. |
| // x,x. |
| def : InstRW<[Zn2WriteCVTPD2DQr], (instregex "(V?)CVT(T?)PD2DQrr")>; |
| |
| def Zn2WriteCVTPD2DQLd: SchedWriteRes<[Zn2AGU,Zn2FPU12,Zn2FPU3]> { |
| let Latency = 10; |
| let NumMicroOps = 2; |
| } |
| // x,m128. |
| def : InstRW<[Zn2WriteCVTPD2DQLd], (instregex "(V?)CVT(T?)PD2DQrm")>; |
| // same as xmm handling |
| // x,y. |
| def : InstRW<[Zn2WriteCVTPD2DQr], (instregex "VCVT(T?)PD2DQYrr")>; |
| // x,m256. |
| def : InstRW<[Zn2WriteCVTPD2DQLd], (instregex "VCVT(T?)PD2DQYrm")>; |
| |
| def Zn2WriteCVTPS2PIr: SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 4; |
| } |
| // CVT(T)PS2PI. |
| // mm,x. |
| def : InstRW<[Zn2WriteCVTPS2PIr], (instregex "MMX_CVT(T?)PS2PIirr")>; |
| |
| // CVTPI2PD. |
| // x,mm. |
| def : InstRW<[Zn2WriteCVTPS2PDr], (instrs MMX_CVTPI2PDirr)>; |
| |
| // CVT(T)PD2PI. |
| // mm,x. |
| def : InstRW<[Zn2WriteCVTPS2PIr], (instregex "MMX_CVT(T?)PD2PIirr")>; |
| |
| def Zn2WriteCVSTSI2SSr: SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 4; |
| } |
| |
| // same as CVTPD2DQr |
| // CVT(T)SS2SI. |
| // r32,x. |
| def : InstRW<[Zn2WriteCVTPD2DQr], (instregex "(V?)CVT(T?)SS2SI(64)?rr")>; |
| // same as CVTPD2DQm |
| // r32,m32. |
| def : InstRW<[Zn2WriteCVTPD2DQLd], (instregex "(V?)CVT(T?)SS2SI(64)?rm")>; |
| |
| def Zn2WriteCVSTSI2SDr: SchedWriteRes<[Zn2FPU013, Zn2FPU3]> { |
| let Latency = 4; |
| } |
| // CVTSI2SD. |
| // x,r32/64. |
| def : InstRW<[Zn2WriteCVSTSI2SDr], (instregex "(V?)CVTSI(64)?2SDrr")>; |
| |
| |
| def Zn2WriteCVSTSI2SIr: SchedWriteRes<[Zn2FPU3, Zn2FPU2]> { |
| let Latency = 4; |
| } |
| def Zn2WriteCVSTSI2SILd: SchedWriteRes<[Zn2AGU, Zn2FPU3, Zn2FPU2]> { |
| let Latency = 11; |
| } |
| // CVTSD2SI. |
| // r32/64 |
| def : InstRW<[Zn2WriteCVSTSI2SIr], (instregex "(V?)CVT(T?)SD2SI(64)?rr")>; |
| // r32,m32. |
| def : InstRW<[Zn2WriteCVSTSI2SILd], (instregex "(V?)CVT(T?)SD2SI(64)?rm")>; |
| |
| // VCVTPS2PH. |
| // x,v,i. |
| def : SchedAlias<WriteCvtPS2PH, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCvtPS2PHY, Zn2WriteMicrocoded>; |
| defm : X86WriteResUnsupported<WriteCvtPS2PHZ>; |
| // m,v,i. |
| def : SchedAlias<WriteCvtPS2PHSt, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCvtPS2PHYSt, Zn2WriteMicrocoded>; |
| defm : X86WriteResUnsupported<WriteCvtPS2PHZSt>; |
| |
| // VCVTPH2PS. |
| // v,x. |
| def : SchedAlias<WriteCvtPH2PS, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCvtPH2PSY, Zn2WriteMicrocoded>; |
| defm : X86WriteResUnsupported<WriteCvtPH2PSZ>; |
| // v,m. |
| def : SchedAlias<WriteCvtPH2PSLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteCvtPH2PSYLd, Zn2WriteMicrocoded>; |
| defm : X86WriteResUnsupported<WriteCvtPH2PSZLd>; |
| |
| //-- SSE4A instructions --// |
| // EXTRQ |
| def Zn2WriteEXTRQ: SchedWriteRes<[Zn2FPU12, Zn2FPU2]> { |
| let Latency = 2; |
| } |
| def : InstRW<[Zn2WriteEXTRQ], (instregex "EXTRQ")>; |
| |
| // INSERTQ |
| def Zn2WriteINSERTQ: SchedWriteRes<[Zn2FPU03,Zn2FPU1]> { |
| let Latency = 4; |
| } |
| def : InstRW<[Zn2WriteINSERTQ], (instregex "INSERTQ")>; |
| |
| //-- SHA instructions --// |
| // SHA256MSG2 |
| def : InstRW<[WriteMicrocoded], (instregex "SHA256MSG2(Y?)r(r|m)")>; |
| |
| // SHA1MSG1, SHA256MSG1 |
| // x,x. |
| def Zn2WriteSHA1MSG1r : SchedWriteRes<[Zn2FPU12]> { |
| let Latency = 2; |
| } |
| def : InstRW<[Zn2WriteSHA1MSG1r], (instregex "SHA(1|256)MSG1rr")>; |
| // x,m. |
| def Zn2WriteSHA1MSG1Ld : SchedWriteRes<[Zn2AGU, Zn2FPU12]> { |
| let Latency = 9; |
| } |
| def : InstRW<[Zn2WriteSHA1MSG1Ld], (instregex "SHA(1|256)MSG1rm")>; |
| |
| // SHA1MSG2 |
| // x,x. |
| def Zn2WriteSHA1MSG2r : SchedWriteRes<[Zn2FPU12]> ; |
| def : InstRW<[Zn2WriteSHA1MSG2r], (instregex "SHA1MSG2rr")>; |
| // x,m. |
| def Zn2WriteSHA1MSG2Ld : SchedWriteRes<[Zn2AGU, Zn2FPU12]> { |
| let Latency = 8; |
| } |
| def : InstRW<[Zn2WriteSHA1MSG2Ld], (instregex "SHA1MSG2rm")>; |
| |
| // SHA1NEXTE |
| // x,x. |
| def Zn2WriteSHA1NEXTEr : SchedWriteRes<[Zn2FPU1]> ; |
| def : InstRW<[Zn2WriteSHA1NEXTEr], (instregex "SHA1NEXTErr")>; |
| // x,m. |
| def Zn2WriteSHA1NEXTELd : SchedWriteRes<[Zn2AGU, Zn2FPU1]> { |
| let Latency = 8; |
| } |
| def : InstRW<[Zn2WriteSHA1NEXTELd], (instregex "SHA1NEXTErm")>; |
| |
| // SHA1RNDS4 |
| // x,x. |
| def Zn2WriteSHA1RNDS4r : SchedWriteRes<[Zn2FPU1]> { |
| let Latency = 6; |
| } |
| def : InstRW<[Zn2WriteSHA1RNDS4r], (instregex "SHA1RNDS4rr")>; |
| // x,m. |
| def Zn2WriteSHA1RNDS4Ld : SchedWriteRes<[Zn2AGU, Zn2FPU1]> { |
| let Latency = 13; |
| } |
| def : InstRW<[Zn2WriteSHA1RNDS4Ld], (instregex "SHA1RNDS4rm")>; |
| |
| // SHA256RNDS2 |
| // x,x. |
| def Zn2WriteSHA256RNDS2r : SchedWriteRes<[Zn2FPU1]> { |
| let Latency = 4; |
| } |
| def : InstRW<[Zn2WriteSHA256RNDS2r], (instregex "SHA256RNDS2rr")>; |
| // x,m. |
| def Zn2WriteSHA256RNDS2Ld : SchedWriteRes<[Zn2AGU, Zn2FPU1]> { |
| let Latency = 11; |
| } |
| def : InstRW<[Zn2WriteSHA256RNDS2Ld], (instregex "SHA256RNDS2rm")>; |
| |
| //-- Arithmetic instructions --// |
| |
| // HADD, HSUB PS/PD |
| def : SchedAlias<WriteFHAdd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteFHAddLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteFHAddY, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteFHAddYLd, Zn2WriteMicrocoded>; |
| |
| // VDIVPS. |
| // TODO - convert to Zn2WriteResFpuPair |
| // y,y,y. |
| def Zn2WriteVDIVPSYr : SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 10; |
| let ResourceCycles = [10]; |
| } |
| def : SchedAlias<WriteFDivY, Zn2WriteVDIVPSYr>; |
| |
| // y,y,m256. |
| def Zn2WriteVDIVPSYLd : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 17; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1, 17]; |
| } |
| def : SchedAlias<WriteFDivYLd, Zn2WriteVDIVPSYLd>; |
| |
| // VDIVPD. |
| // TODO - convert to Zn2WriteResFpuPair |
| // y,y,y. |
| def Zn2WriteVDIVPDY : SchedWriteRes<[Zn2FPU3]> { |
| let Latency = 13; |
| let ResourceCycles = [13]; |
| } |
| def : SchedAlias<WriteFDiv64Y, Zn2WriteVDIVPDY>; |
| |
| // y,y,m256. |
| def Zn2WriteVDIVPDYLd : SchedWriteRes<[Zn2AGU, Zn2FPU3]> { |
| let Latency = 20; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1,20]; |
| } |
| def : SchedAlias<WriteFDiv64YLd, Zn2WriteVDIVPDYLd>; |
| |
| // DPPS. |
| // x,x,i / v,v,v,i. |
| def : SchedAlias<WriteDPPS, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteDPPSY, Zn2WriteMicrocoded>; |
| |
| // x,m,i / v,v,m,i. |
| def : SchedAlias<WriteDPPSLd, Zn2WriteMicrocoded>; |
| def : SchedAlias<WriteDPPSYLd,Zn2WriteMicrocoded>; |
| |
| // DPPD. |
| // x,x,i. |
| def : SchedAlias<WriteDPPD, Zn2WriteMicrocoded>; |
| |
| // x,m,i. |
| def : SchedAlias<WriteDPPDLd, Zn2WriteMicrocoded>; |
| |
| // RSQRTSS |
| // TODO - convert to Zn2WriteResFpuPair |
| // x,x. |
| def Zn2WriteRSQRTSSr : SchedWriteRes<[Zn2FPU02]> { |
| let Latency = 5; |
| } |
| def : SchedAlias<WriteFRsqrt, Zn2WriteRSQRTSSr>; |
| |
| // x,m128. |
| def Zn2WriteRSQRTSSLd: SchedWriteRes<[Zn2AGU, Zn2FPU02]> { |
| let Latency = 12; |
| let NumMicroOps = 2; |
| let ResourceCycles = [1,2]; |
| } |
| def : SchedAlias<WriteFRsqrtLd, Zn2WriteRSQRTSSLd>; |
| |
| // RSQRTPS |
| // TODO - convert to Zn2WriteResFpuPair |
| // y,y. |
| def Zn2WriteRSQRTPSYr : SchedWriteRes<[Zn2FPU01]> { |
| let Latency = 5; |
| let NumMicroOps = 2; |
| let ResourceCycles = [2]; |
| } |
| def : SchedAlias<WriteFRsqrtY, Zn2WriteRSQRTPSYr>; |
| |
| // y,m256. |
| def Zn2WriteRSQRTPSYLd : SchedWriteRes<[Zn2AGU, Zn2FPU01]> { |
| let Latency = 12; |
| let NumMicroOps = 2; |
| } |
| def : SchedAlias<WriteFRsqrtYLd, Zn2WriteRSQRTPSYLd>; |
| |
| //-- Other instructions --// |
| |
| // VZEROUPPER. |
| def : InstRW<[WriteALU], (instrs VZEROUPPER)>; |
| |
| // VZEROALL. |
| def : InstRW<[WriteMicrocoded], (instrs VZEROALL)>; |
| |
| } // SchedModel |
