diff --git a/llvm/lib/Target/X86/X86.td b/llvm/lib/Target/X86/X86.td --- a/llvm/lib/Target/X86/X86.td +++ b/llvm/lib/Target/X86/X86.td @@ -734,6 +734,7 @@ include "X86SchedSkylakeServer.td" include "X86SchedIceLake.td" include "X86SchedAlderlakeP.td" +include "X86SchedSapphireRapids.td" //===----------------------------------------------------------------------===// // X86 Processor Feature Lists @@ -1653,7 +1654,7 @@ ProcessorFeatures.ICXFeatures, ProcessorFeatures.ICXTuning>; def : ProcModel<"tigerlake", IceLakeModel, ProcessorFeatures.TGLFeatures, ProcessorFeatures.TGLTuning>; -def : ProcModel<"sapphirerapids", SkylakeServerModel, +def : ProcModel<"sapphirerapids", SapphireRapidsModel, ProcessorFeatures.SPRFeatures, ProcessorFeatures.SPRTuning>; def : ProcModel<"alderlake", AlderlakePModel, ProcessorFeatures.ADLFeatures, ProcessorFeatures.ADLTuning>; @@ -1661,9 +1662,9 @@ ProcessorFeatures.ADLFeatures, ProcessorFeatures.ADLTuning>; def : ProcModel<"meteorlake", AlderlakePModel, ProcessorFeatures.ADLFeatures, ProcessorFeatures.ADLTuning>; -def : ProcModel<"graniterapids", SkylakeServerModel, +def : ProcModel<"graniterapids", SapphireRapidsModel, ProcessorFeatures.GNRFeatures, ProcessorFeatures.SPRTuning>; -def : ProcModel<"emeraldrapids", SkylakeServerModel, +def : ProcModel<"emeraldrapids", SapphireRapidsModel, ProcessorFeatures.SPRFeatures, ProcessorFeatures.SPRTuning>; // AMD CPUs. diff --git a/llvm/lib/Target/X86/X86SchedSapphireRapids.td b/llvm/lib/Target/X86/X86SchedSapphireRapids.td new file mode 100644 --- /dev/null +++ b/llvm/lib/Target/X86/X86SchedSapphireRapids.td @@ -0,0 +1,5202 @@ +//=- X86SchedSapphireRapids.td - X86 SapphireRapids 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 SapphireRapids to support instruction +// scheduling and other instruction cost heuristics. +// +//===----------------------------------------------------------------------===// + +def SapphireRapidsModel : SchedMachineModel { + // SapphireRapids can allocate 6 uops per cycle. + let IssueWidth = 6; // Based on allocator width. + let MicroOpBufferSize = 512; // Based on the reorder buffer. + let LoadLatency = 5; + let MispredictPenalty = 14; + + // Latency for microcoded instructions or instructions without latency info. + int MaxLatency = 100; + + // Based on the LSD (loop-stream detector) queue size (ST). + let LoopMicroOpBufferSize = 72; + + // This flag is set to allow the scheduler to assign a default model to + // unrecognized opcodes. + let CompleteModel = 0; +} + +let SchedModel = SapphireRapidsModel in { + +// SapphireRapids can issue micro-ops to 12 different ports in one cycle. +def SPRPort00 : ProcResource<1>; +def SPRPort01 : ProcResource<1>; +def SPRPort02 : ProcResource<1>; +def SPRPort03 : ProcResource<1>; +def SPRPort04 : ProcResource<1>; +def SPRPort05 : ProcResource<1>; +def SPRPort06 : ProcResource<1>; +def SPRPort07 : ProcResource<1>; +def SPRPort08 : ProcResource<1>; +def SPRPort09 : ProcResource<1>; +def SPRPort10 : ProcResource<1>; +def SPRPort11 : ProcResource<1>; + +// Workaround to represent invalid ports. WriteRes shouldn't use this resource. +def SPRPortInvalid :ProcResource<1>; + +// Many micro-ops are capable of issuing on multiple ports. +def SPRPort00_01 : ProcResGroup<[SPRPort00, SPRPort01]>; +def SPRPort00_01_05 : ProcResGroup<[SPRPort00, SPRPort01, SPRPort05]>; +def SPRPort00_01_05_06 : ProcResGroup<[SPRPort00, SPRPort01, SPRPort05, SPRPort06]>; +def SPRPort00_05 : ProcResGroup<[SPRPort00, SPRPort05]>; +def SPRPort00_05_06 : ProcResGroup<[SPRPort00, SPRPort05, SPRPort06]>; +def SPRPort00_06 : ProcResGroup<[SPRPort00, SPRPort06]>; +def SPRPort01_05 : ProcResGroup<[SPRPort01, SPRPort05]>; +def SPRPort01_05_10 : ProcResGroup<[SPRPort01, SPRPort05, SPRPort10]>; +def SPRPort02_03 : ProcResGroup<[SPRPort02, SPRPort03]>; +def SPRPort02_03_11 : ProcResGroup<[SPRPort02, SPRPort03, SPRPort11]>; +def SPRPort07_08 : ProcResGroup<[SPRPort07, SPRPort08]>; + +// EU has 112 reservation stations. +def SPRPort00_01_05_06_10 : ProcResGroup<[SPRPort00, SPRPort01, SPRPort05, + SPRPort06, SPRPort10]> { + let BufferSize = 112; +} + +// STD has 48 reservation stations. +def SPRPort04_09 : ProcResGroup<[SPRPort04, SPRPort09]> { + let BufferSize = 48; +} + +// MEM has 72 reservation stations. +def SPRPort02_03_07_08_11 : ProcResGroup<[SPRPort02, SPRPort03, SPRPort07, + SPRPort08, SPRPort11]> { + let BufferSize = 72; +} + +// Integer loads are 5 cycles, so ReadAfterLd registers needn't be available +// until 5 cycles after the memory operand. +def : ReadAdvance; + +// Vector loads are 6 cycles, so ReadAfterVec*Ld registers needn't be available +// until 6 cycles after the memory operand. +def : ReadAdvance; +def : ReadAdvance; +def : ReadAdvance; + +def : ReadAdvance; + +// Many SchedWrites are defined in pairs with and without a folded load. +// Instructions with folded loads are usually micro-fused, so they only appear +// as two micro-ops when queued in the reservation station. +// This multiclass defines the resource usage for variants with and without +// folded loads. +multiclass SPRWriteResPair ExePorts, + int Lat, list Res = [1], int UOps = 1, + int LoadLat = 5, int LoadUOps = 1> { + // Register variant is using a single cycle on ExePort. + def : WriteRes { + let Latency = Lat; + let ResourceCycles = Res; + let NumMicroOps = UOps; + } + + // Memory variant also uses a cycle on port 2/3/11 and adds LoadLat cycles to + // the latency (default = 5). + def : WriteRes { + let Latency = !add(Lat, LoadLat); + let ResourceCycles = !listconcat([1], Res); + let NumMicroOps = !add(UOps, LoadUOps); + } +} + +//===----------------------------------------------------------------------===// +// The following definitons are infered by smg. +//===----------------------------------------------------------------------===// + +// Infered SchedWrite definition. +def : WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes; +def : WriteRes { + let Latency = 11; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +def : WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes; +def : WriteRes { + let Latency = 11; +} +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes { + let Latency = 7; +} +def : WriteRes { + let Latency = 7; +} +def : WriteRes { + let Latency = 8; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +// Warning: negtive load latency. +defm : SPRWriteResPair; +def : WriteRes { + let ResourceCycles = [7, 1]; + let Latency = 21; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteResUnsupported; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 2; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +def : WriteRes { + let Latency = 3; +} +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +def : WriteRes; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 5; +} +def : WriteRes { + let Latency = 3; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = SapphireRapidsModel.MaxLatency; +} +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +def : WriteRes; +def : WriteRes { + let Latency = 12; +} +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes { + let Latency = SapphireRapidsModel.MaxLatency; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes { + let Latency = 7; +} +def : WriteRes { + let Latency = 7; +} +def : WriteRes { + let Latency = 8; +} +def : WriteRes { + let Latency = 7; +} +def : WriteRes { + let Latency = 8; +} +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +def : WriteRes { + let Latency = 3; +} +def : WriteRes { + let Latency = 4; +} +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +def : WriteRes; +def : WriteRes { + let Latency = 3; +} +def : WriteRes { + let Latency = 3; +} +defm : X86WriteRes; +def : WriteRes; +def : WriteRes; +defm : SPRWriteResPair; +def : WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : X86WriteRes; +defm : SPRWriteResPair; +defm : SPRWriteResPair; +defm : X86WriteRes; +def : WriteRes; + +// Infered SchedWriteRes and InstRW definition. + +def SPRWriteResGroup0 : SchedWriteRes<[SPRPort02_03, SPRPort02_03_11, SPRPort04, SPRPort04_09]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup0], (instregex "^AA(D|N)D64mr$", + "^A(X?)OR64mr$")>; + +def SPRWriteResGroup1 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 1, 1, 1]; + let Latency = 12; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup1, ReadAfterLd, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^(ADC|SBB)(16|32|64)mr$")>; + +def SPRWriteResGroup2 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup2], (instregex "^RORX(32|64)mi$")>; +def : InstRW<[SPRWriteResGroup2, ReadAfterLd, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^(ADC|SBB)(8|16|32|64)rm$", + "^AD(C|O)X(32|64)rm$")>; + +def SPRWriteResGroup3 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 13; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup3], (instregex "^(ADC|SBB)8mi(8?)$")>; + +def SPRWriteResGroup4 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 1, 1, 1]; + let Latency = 13; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup4, ReadAfterLd, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^(ADC|SBB)8mr$")>; + +def SPRWriteResGroup5 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup5], (instregex "^CMP(8|16|32)mi$", + "^CMP(8|16|32|64)mi8$", + "^MOV(8|16)rm$", + "^POP(16|32)r((mr)?)$")>; +def : InstRW<[SPRWriteResGroup5], (instrs CMP64mi32, + MOV8rm_NOREX, + MOVZX16rm8)>; +def : InstRW<[SPRWriteResGroup5, ReadAfterLd], (instregex "^(ADD|CMP|SUB)(8|16|32|64)rm$", + "^AND(8|16|32)rm$", + "^(X?)OR(8|16|32)rm$")>; +def : InstRW<[SPRWriteResGroup5, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^CMP(8|16|32|64)mr$")>; + +def SPRWriteResGroup6 : SchedWriteRes<[]> { + let NumMicroOps = 0; +} +def : InstRW<[SPRWriteResGroup6], (instregex "^(ADD|SUB)64ri8$", + "^(DE|IN)C64r$", + "^MOV64rr((_REV)?)$", + "^VMOV(A|U)P(D|S)Zrr((_REV)?)$", + "^VMOVDQA(32|64)Z((256)?)rr((_REV)?)$", + "^VMOVDQ(A|U)Yrr((_REV)?)$", + "^VMOVDQU(8|16|32|64)Z((256)?)rr((_REV)?)$")>; +def : InstRW<[SPRWriteResGroup6], (instrs CLC, + JMP_2)>; + +def SPRWriteResGroup7 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 13; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup7], (instregex "^A(D|N)D8mi(8?)$", + "^(DE|IN)C8m$", + "^N(EG|OT)8m$", + "^(X?)OR8mi(8?)$", + "^SUB8mi(8?)$")>; +def : InstRW<[SPRWriteResGroup7, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^A(D|N)D8mr$", + "^(X?)OR8mr$")>; +def : InstRW<[SPRWriteResGroup7, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instrs SUB8mr)>; + +def SPRWriteResGroup8 : SchedWriteRes<[SPRPort01_05, SPRPort02_03_11]> { + let Latency = 10; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup8, ReadAfterVecXLd], (instregex "^(V?)(ADD|SUB)PSrm$", + "^(V?)ADDSUBPSrm$", + "^V(ADD|SUB)PSZ128rm((b|k|bk|kz)?)$", + "^V(ADD|SUB)PSZ128rmbkz$")>; + +def SPRWriteResGroup9 : SchedWriteRes<[SPRPort01_05]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup9], (instregex "^(V?)(ADD|SUB)PSrr$", + "^(V?)ADDSUBPSrr$", + "^V(ADD|SUB)PSYrr$", + "^V(ADD|SUB)PSZ(128|256)rr(k?)$", + "^VPMOV(S|Z)XBWZ128rrk(z?)$", + "^VPSHUFBZ(128|256)rrk(z?)$", + "^VPSHUF(H|L)WZ(128|256)rik(z?)$", + "^VPUNPCK(H|L)(BW|WD)Z(128|256)rrk(z?)$")>; +def : InstRW<[SPRWriteResGroup9], (instrs VADDSUBPSYrr)>; + +def SPRWriteResGroup10 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 10; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup10], (instregex "^ADD_F(32|64)m$", + "^ILD_F(16|32|64)m$", + "^SUB(R?)_F(32|64)m$", + "^VPOPCNT(B|D|Q|W)Z128rm$", + "^VPOPCNT(D|Q)Z128rm(b|k|kz)$", + "^VPOPCNT(D|Q)Z128rmbk(z?)$")>; +def : InstRW<[SPRWriteResGroup10, ReadAfterVecXLd], (instregex "^(V?)PACK(S|U)S(DW|WB)rm$", + "^(V?)PCMPGTQrm$", + "^VFPCLASSP(D|H|S)Z128rmb$", + "^VPACK(S|U)S(DW|WB)Z128rm$", + "^VPACK(S|U)SDWZ128rmb$", + "^VPM(AX|IN)(S|U)QZ128rm((b|k|bk|kz)?)$", + "^VPM(AX|IN)(S|U)QZ128rmbkz$", + "^VPMULTISHIFTQBZ128rm(b?)$")>; +def : InstRW<[SPRWriteResGroup10, ReadAfterVecXLd], (instrs VFPCLASSPHZ128rm)>; +def : InstRW<[SPRWriteResGroup10, ReadAfterVecYLd], (instregex "^VFPCLASSP(D|H|S)Z((256)?)rm$", + "^VPERM(I|T)2(D|Q|PS)128rm((b|k|bk|kz)?)$", + "^VPERM(I|T)2(D|Q|PS)128rmbkz$", + "^VPERM(I|T)2PD128rm((b|k|bk|kz)?)$", + "^VPERM(I|T)2PD128rmbkz$")>; +def : InstRW<[SPRWriteResGroup10, ReadAfterVecYLd], (instrs VPERMBZ128rm)>; + +def SPRWriteResGroup11 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup11], (instregex "^ADD_FI(16|32)m$", + "^SUB(R?)_FI(16|32)m$")>; +def : InstRW<[SPRWriteResGroup11, ReadAfterVecXLd], (instrs SHA256MSG2rm)>; +def : InstRW<[SPRWriteResGroup11, ReadAfterVecYLd], (instregex "^VPEXPAND(B|W)Z(128|256)rmk(z?)$", + "^VPEXPAND(B|W)Zrmk(z?)$")>; + +def SPRWriteResGroup12 : SchedWriteRes<[SPRPort05]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup12], (instregex "^ADD_F(P?)rST0$", + "^KMOV(B|D|W)kr$", + "^(V?)PACK(S|U)S(DW|WB)rr$", + "^(V?)PCMPGTQrr$", + "^SUB(R?)_F(P?)rST0$", + "^SUB(R?)_FST0r$", + "^VALIGN(D|Q)Z256rri((k|kz)?)$", + "^VCMPP(D|H|S)Z(128|256)rri(k?)$", + "^VCMPS(D|H|S)Zrr$", + "^VCMPS(D|H|S)Zrr(b?)_Int(k?)$", + "^VFPCLASSP(D|H|S)Z(128|256)rr(k?)$", + "^VFPCLASSS(D|H|S)Zrr(k?)$", + "^VPACK(S|U)S(DW|WB)Yrr$", + "^VPACK(S|U)S(DW|WB)Z(128|256)rr$", + "^VPALIGNRZ(128|256)rrik(z?)$", + "^VPBROADCAST(B|W)Z128rrk(z?)$", + "^VPCMP(B|D|Q|W|UD|UQ|UW)Z(128|256)rri(k?)$", + "^VPCMP(EQ|GT)(B|D|Q|W)Z(128|256)rr(k?)$", + "^VPCMPUBZ(128|256)rri(k?)$", + "^VPERMBZ(128|256)rr$", + "^VPERM(B|D|Q)Zrr$", + "^VPERM(D|Q)Z256rr((k|kz)?)$", + "^VPERM(D|Q)Zrrk(z?)$", + "^VPERM(I|T)2(D|Q)(128|256)rr((k|kz)?)$", + "^VPERM(I|T)2(D|Q)rr((k|kz)?)$", + "^VPM(AX|IN)(S|U)QZ(128|256)rr((k|kz)?)$", + "^VPMULTISHIFTQBZ(128|256)rr$", + "^VPOPCNT(B|D|Q|W)Z(128|256)rr$", + "^VPOPCNT(D|Q)Z(128|256)rrk(z?)$", + "^VPTEST(N?)M(B|D|Q|W)Z(128|256)rr(k?)$", + "^VPTEST(N?)M(B|D|Q|W)Zrr(k?)$")>; +def : InstRW<[SPRWriteResGroup12], (instrs ADD_FST0r, + VPCMPGTQYrr, + VPERMDYrr)>; + +def SPRWriteResGroup13 : SchedWriteRes<[SPRPort00_01_05_06_10]> { + let Latency = 2; +} +def : InstRW<[SPRWriteResGroup13], (instregex "^AND(8|16|32|64)r(r|i8)$", + "^AND(8|16|32|64)rr_REV$", + "^(AND|TEST)(32|64)i32$", + "^(AND|TEST)(8|32)ri$", + "^(AND|TEST)64ri32$", + "^(AND|TEST)8i8$", + "^(X?)OR(8|16|32|64)r(r|i8)$", + "^(X?)OR(8|16|32|64)rr_REV$", + "^(X?)OR(32|64)i32$", + "^(X?)OR(8|32)ri$", + "^(X?)OR64ri32$", + "^(X?)OR8i8$", + "^TEST(8|16|32|64)rr$")>; +def : InstRW<[SPRWriteResGroup13], (instrs XOR8rr_NOREX)>; + +def SPRWriteResGroup14 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup14], (instregex "^TEST(8|16|32)mi$")>; +def : InstRW<[SPRWriteResGroup14], (instrs TEST64mi32)>; +def : InstRW<[SPRWriteResGroup14, ReadAfterLd], (instregex "^(X?)OR64rm$")>; +def : InstRW<[SPRWriteResGroup14, ReadAfterLd], (instrs AND64rm)>; +def : InstRW<[SPRWriteResGroup14, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^TEST(8|16|32|64)mr$")>; + +def SPRWriteResGroup15 : SchedWriteRes<[SPRPort01_05_10, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup15, ReadAfterLd], (instregex "^ANDN(32|64)rm$")>; + +def SPRWriteResGroup16 : SchedWriteRes<[SPRPort01_05_10]> { + let Latency = 2; +} +def : InstRW<[SPRWriteResGroup16], (instregex "^ANDN(32|64)rr$")>; + +def SPRWriteResGroup17 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [5, 2, 1, 1]; + let Latency = 10; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup17], (instrs BT64mr)>; + +def SPRWriteResGroup18 : SchedWriteRes<[SPRPort01]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup18], (instregex "^BT((C|R|S)?)64rr$", + "^P(DEP|EXT)(32|64)rr$")>; + +def SPRWriteResGroup19 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [4, 2, 1, 1, 1, 1]; + let Latency = 17; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup19], (instregex "^BT(C|R|S)64mr$")>; + +def SPRWriteResGroup20 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 7; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup20], (instregex "^CALL(16|32|64)m((_NT)?)$")>; + +def SPRWriteResGroup21 : SchedWriteRes<[SPRPort00_06, SPRPort04_09, SPRPort07_08]> { + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup21], (instregex "^CALL(16|32|64)r((_NT)?)$")>; + +def SPRWriteResGroup22 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup22], (instrs CALL64pcrel32, + MFENCE)>; + +def SPRWriteResGroup23 : SchedWriteRes<[SPRPort01_05]>; +def : InstRW<[SPRWriteResGroup23], (instregex "^C(DQ|WD)E$", + "^(V?)MOVS(H|L)DUPrr$", + "^(V?)SHUFP(D|S)rri$", + "^VMOVS(H|L)DUPYrr$", + "^VMOVS(H|L)DUPZ(128|256)rr((k|kz)?)$", + "^VPMOVQDZ128rr((k|kz)?)$", + "^VSHUFP(D|S)Yrri$", + "^VSHUFP(D|S)Z(128|256)rri((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup23], (instrs CBW, + VPBLENDWYrri)>; + +def SPRWriteResGroup24 : SchedWriteRes<[SPRPort00_06]>; +def : InstRW<[SPRWriteResGroup24], (instregex "^C(DQ|QO)$", + "^(CL|ST)AC$")>; + +def SPRWriteResGroup25 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup25], (instrs CLD)>; + +def SPRWriteResGroup26 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup26], (instrs CLDEMOTE)>; + +def SPRWriteResGroup27 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort04_09, SPRPort07_08]> { + let Latency = 2; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup27], (instrs CLFLUSH)>; + +def SPRWriteResGroup28 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let Latency = 2; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup28], (instrs CLFLUSHOPT)>; + +def SPRWriteResGroup29 : SchedWriteRes<[SPRPort00_06, SPRPort01]> { + let ResourceCycles = [2, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup29], (instrs CLI)>; + +def SPRWriteResGroup30 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort05]> { + let ResourceCycles = [6, 1, 3]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup30], (instrs CLTS)>; + +def SPRWriteResGroup31 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let Latency = 5; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup31], (instregex "^MOV16o(16|32|64)a$")>; +def : InstRW<[SPRWriteResGroup31], (instrs CLWB)>; + +def SPRWriteResGroup32 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let ResourceCycles = [5, 2]; + let Latency = 6; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup32], (instregex "^CMPS(B|L|Q|W)$")>; + +def SPRWriteResGroup33 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01_05, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [2, 7, 6, 2, 1, 1, 2, 1]; + let Latency = 32; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup33], (instrs CMPXCHG16B)>; + +def SPRWriteResGroup34 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [4, 7, 2, 1, 1, 1]; + let Latency = 25; + let NumMicroOps = 16; +} +def : InstRW<[SPRWriteResGroup34], (instrs CMPXCHG8B)>; + +def SPRWriteResGroup35 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 2, 1, 1, 1]; + let Latency = 13; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup35], (instrs CMPXCHG8rm)>; + +def SPRWriteResGroup36 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_06, SPRPort01, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [2, 1, 10, 6, 1, 5, 1]; + let Latency = 18; + let NumMicroOps = 26; +} +def : InstRW<[SPRWriteResGroup36], (instrs CPUID)>; + +def SPRWriteResGroup37 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup37], (instregex "^(V?)CVT(T?)PD2DQrm$", + "^VCVT(T?)PD2(U?)DQZ128rm((b|k|bk|kz)?)$", + "^VCVT(T?)PD2(U?)DQZ128rmbkz$", + "^VCVTPH2PSXZ128rm(b?)$", + "^VCVT(U?)QQ2PSZ128rm((b|k|bk|kz)?)$", + "^VCVT(U?)QQ2PSZ128rmbkz$")>; +def : InstRW<[SPRWriteResGroup37], (instrs CVTSI642SSrm)>; +def : InstRW<[SPRWriteResGroup37, ReadAfterVecLd], (instregex "^(V?)CVTSI642SSrm_Int$", + "^VCVT(U?)SI642SSZrm((_Int)?)$")>; +def : InstRW<[SPRWriteResGroup37, ReadAfterVecLd], (instrs VCVTSI642SSrm)>; + +def SPRWriteResGroup38 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort02_03_11]> { + let Latency = 26; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup38], (instregex "^(V?)CVT(T?)SD2SIrm((_Int)?)$")>; +def : InstRW<[SPRWriteResGroup38, ReadAfterVecLd], (instregex "^VCVT(T?)SD2SIZrm$", + "^VCVT(T?)SD2(U?)SIZrm_Int$")>; +def : InstRW<[SPRWriteResGroup38, ReadAfterVecLd], (instrs VCVTTSD2USIZrm)>; + +def SPRWriteResGroup39 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup39], (instregex "^VCVT(T?)PS2(U?)QQZ256rr((k|kz)?)$", + "^VCVT(U?)QQ2PSZ256rr((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup39, ReadInt2Fpu], (instrs CVTSI2SSrr)>; +def : InstRW<[SPRWriteResGroup39, ReadDefault, ReadInt2Fpu], (instregex "^(V?)CVTSI2SSrr_Int$", + "^VCVT(U?)SI2SSZrr$", + "^VCVT(U?)SI2SSZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup39, ReadDefault, ReadInt2Fpu], (instrs VCVTSI2SSrr)>; + +def SPRWriteResGroup40 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup40, ReadInt2Fpu], (instrs CVTSI642SSrr)>; +def : InstRW<[SPRWriteResGroup40, ReadDefault, ReadInt2Fpu], (instregex "^(V?)CVTSI642SSrr_Int$", + "^VCVT(U?)SI642SSZrr$", + "^VCVT(U?)SI642SSZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup40, ReadDefault, ReadInt2Fpu], (instrs VCVTSI642SSrr)>; + +def SPRWriteResGroup41 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup41], (instregex "^(V?)CVT(T?)SS2SI64rr_Int$", + "^VCVT(T?)SS2SI64Zrr$", + "^VCVT(T?)SS2(U?)SI64Zrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup41], (instrs VCVTTSS2USI64Zrr)>; +def : InstRW<[SPRWriteResGroup41, ReadDefault], (instregex "^(V?)CVT(T?)SS2SI64rr$")>; + +def SPRWriteResGroup42 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup42], (instregex "^J(E|R)CXZ$")>; +def : InstRW<[SPRWriteResGroup42], (instrs CWD)>; + +def SPRWriteResGroup43 : SchedWriteRes<[SPRPort00_01_05_06]>; +def : InstRW<[SPRWriteResGroup43], (instregex "^(LD|ST)_Frr$", + "^MOV16s(m|r)$", + "^MOV(32|64)sr$")>; +def : InstRW<[SPRWriteResGroup43], (instrs DEC16r_alt, + SALC, + ST_FPrr, + SYSCALL)>; + +def SPRWriteResGroup44 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 7; +} +def : InstRW<[SPRWriteResGroup44], (instrs DEC32r_alt)>; + +def SPRWriteResGroup45 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 27; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup45], (instregex "^DIVR_F(32|64)m$")>; + +def SPRWriteResGroup46 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 30; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup46], (instregex "^DIVR_FI(16|32)m$")>; + +def SPRWriteResGroup47 : SchedWriteRes<[SPRPort00]> { + let Latency = 15; +} +def : InstRW<[SPRWriteResGroup47], (instregex "^DIVR_F(P?)rST0$")>; +def : InstRW<[SPRWriteResGroup47], (instrs DIVR_FST0r)>; + +def SPRWriteResGroup48 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 19; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup48, ReadAfterVecLd], (instregex "^(V?)DIVSDrm$")>; +def : InstRW<[SPRWriteResGroup48, ReadAfterVecLd], (instrs VDIVSDZrm)>; + +def SPRWriteResGroup49 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 22; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup49], (instregex "^DIV_F(32|64)m$")>; +def : InstRW<[SPRWriteResGroup49, ReadAfterVecLd], (instregex "^VSQRTSHZm_Int((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup49, ReadAfterVecLd], (instrs VSQRTSHZm)>; + +def SPRWriteResGroup50 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 25; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup50], (instregex "^DIV_FI(16|32)m$")>; + +def SPRWriteResGroup51 : SchedWriteRes<[SPRPort00]> { + let Latency = 20; +} +def : InstRW<[SPRWriteResGroup51], (instregex "^DIV_F(P?)rST0$")>; +def : InstRW<[SPRWriteResGroup51], (instrs DIV_FST0r)>; + +def SPRWriteResGroup52 : SchedWriteRes<[SPRPort04, SPRPort04_09]>; +def : InstRW<[SPRWriteResGroup52], (instregex "^ENQCMD(S?)(16|32|64)$", + "^PUSHA(16|32)$", + "^ST_F(32|64)m$")>; +def : InstRW<[SPRWriteResGroup52], (instrs PUSHF32)>; + +def SPRWriteResGroup53 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [2, 21, 2, 14, 4, 9, 5]; + let Latency = 126; + let NumMicroOps = 57; +} +def : InstRW<[SPRWriteResGroup53], (instrs ENTER)>; + +def SPRWriteResGroup54 : SchedWriteRes<[SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup54], (instregex "^(V?)EXTRACTPSmr$", + "^VPMOVQDZ((256)?)mr$")>; +def : InstRW<[SPRWriteResGroup54], (instrs SMSW16m, + VEXTRACTPSZmr)>; + +def SPRWriteResGroup55 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup55], (instregex "^(V?)EXTRACTPSrr$")>; +def : InstRW<[SPRWriteResGroup55], (instrs MMX_PEXTRWrr, + VEXTRACTPSZrr, + VPERMWZrr)>; + +def SPRWriteResGroup56 : SchedWriteRes<[SPRPort02_03, SPRPort02_03_11, SPRPort04, SPRPort04_09, SPRPort06]> { + let Latency = 7; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup56], (instrs FARCALL64m)>; + +def SPRWriteResGroup57 : SchedWriteRes<[SPRPort02_03_11, SPRPort06]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup57], (instrs FARJMP64m, + JMP64m_REX)>; + +def SPRWriteResGroup58 : SchedWriteRes<[SPRPort04, SPRPort04_09]> { + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup58], (instregex "^(V?)MASKMOVDQU((64)?)$", + "^ST_FP(32|64|80)m$")>; +def : InstRW<[SPRWriteResGroup58], (instrs FBSTPm, + VMPTRSTm)>; + +def SPRWriteResGroup59 : SchedWriteRes<[SPRPort00_05]> { + let ResourceCycles = [2]; + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup59], (instrs FDECSTP)>; + +def SPRWriteResGroup60 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 11; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup60], (instregex "^FICOM(P?)(16|32)m$")>; +def : InstRW<[SPRWriteResGroup60, ReadAfterVecYLd], (instregex "^VEXPANDP(D|S)Z((256)?)rm((k|kz)?)$", + "^VPEXPAND(B|D|Q|W)Z((256)?)rm$", + "^VPEXPAND(D|Q)Z((256)?)rmk(z?)$")>; + +def SPRWriteResGroup61 : SchedWriteRes<[SPRPort00_05]>; +def : InstRW<[SPRWriteResGroup61], (instregex "^MMX_P(ADD|SUB)(B|D|Q|W)rr$", + "^VP(ADD|SUB)(B|D|Q|W)Zrr$", + "^VP(ADD|SUB)(D|Q)Zrrk(z?)$", + "^VPTERNLOG(D|Q)Zrri((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup61], (instrs FINCSTP, + FNOP)>; + +def SPRWriteResGroup62 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup62], (instrs FLDCW16m)>; + +def SPRWriteResGroup63 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort02_03, SPRPort02_03_11]> { + let ResourceCycles = [2, 5, 10, 39, 8]; + let Latency = 62; + let NumMicroOps = 64; +} +def : InstRW<[SPRWriteResGroup63], (instrs FLDENVm)>; + +def SPRWriteResGroup64 : SchedWriteRes<[SPRPort00_01_05_06]> { + let ResourceCycles = [4]; + let Latency = 4; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup64], (instrs FNCLEX)>; + +def SPRWriteResGroup65 : SchedWriteRes<[SPRPort00_01_05_06, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [6, 3, 6]; + let Latency = 75; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup65], (instrs FNINIT)>; + +def SPRWriteResGroup66 : SchedWriteRes<[SPRPort04, SPRPort04_09, SPRPort06]> { + let Latency = 2; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup66], (instrs FNSTCW16m)>; + +def SPRWriteResGroup67 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup67], (instrs FNSTSW16r)>; + +def SPRWriteResGroup68 : SchedWriteRes<[SPRPort00, SPRPort04, SPRPort04_09]> { + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup68], (instrs FNSTSWm)>; + +def SPRWriteResGroup69 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06, SPRPort00_06, SPRPort01, SPRPort04, SPRPort04_09, SPRPort05, SPRPort06]> { + let ResourceCycles = [9, 11, 21, 1, 30, 11, 16, 1]; + let Latency = 106; + let NumMicroOps = 100; +} +def : InstRW<[SPRWriteResGroup69], (instrs FSTENVm)>; + +def SPRWriteResGroup70 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort01_05, SPRPort02_03, SPRPort02_03_11, SPRPort06]> { + let ResourceCycles = [4, 1, 2, 1, 47, 33, 2]; + let Latency = 63; + let NumMicroOps = 90; +} +def : InstRW<[SPRWriteResGroup70], (instrs FXRSTOR)>; + +def SPRWriteResGroup71 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort01_05, SPRPort02_03, SPRPort02_03_11, SPRPort06]> { + let ResourceCycles = [4, 1, 2, 1, 45, 31, 4]; + let Latency = 63; + let NumMicroOps = 88; +} +def : InstRW<[SPRWriteResGroup71], (instrs FXRSTOR64)>; + +def SPRWriteResGroup72 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [2, 5, 10, 10, 2, 38, 5, 38]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 110; +} +def : InstRW<[SPRWriteResGroup72], (instregex "^FXSAVE((64)?)$")>; + +def SPRWriteResGroup73 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 12; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup73], (instregex "^VPLZCNT(D|Q)Z256rm((b|k|bk|kz)?)$", + "^VPLZCNT(D|Q)Z256rmbkz$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecXLd], (instregex "^(V?)GF2P8AFFINE((INV)?)QBrmi$", + "^(V?)GF2P8MULBrm$", + "^V(ADD|SUB)PHZ128rm((b|k|bk|kz)?)$", + "^V(ADD|SUB)PHZ128rmbkz$", + "^VGETEXPPHZ128m((b|k|bk|kz)?)$", + "^VGETEXPSHZm((k|kz)?)$", + "^VGETMANTPHZ128rm(bi|ik)$", + "^VGETMANTPHZ128rmbik(z?)$", + "^VGETMANTPHZ128rmi((kz)?)$", + "^VGETMANTSHZrmi((k|kz)?)$", + "^VGF2P8AFFINE((INV)?)QBZ128rm(b?)i$", + "^VM(AX|IN)CPHZ128rm((b|k|bk|kz)?)$", + "^VM(AX|IN)CPHZ128rmbkz$", + "^VM(AX|IN|UL)PHZ128rm((b|k|bk|kz)?)$", + "^VM(AX|IN|UL)PHZ128rmbkz$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecXLd], (instrs VGETEXPPHZ128mbkz, + VGF2P8MULBZ128rm)>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecLd], (instregex "^V(ADD|SUB)SHZrm$", + "^V(ADD|SUB)SHZrm_Int((k|kz)?)$", + "^VCVTSH2SSZrm((_Int)?)$", + "^VM(AX|IN)CSHZrm$", + "^VM(AX|IN|UL)SHZrm$", + "^VM(AX|IN|UL)SHZrm_Int((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecYLd], (instregex "^VGF2P8AFFINE((INV)?)QBYrmi$", + "^VGF2P8AFFINE((INV)?)QBZ256rm(b?)i$", + "^VGF2P8MULB(Y|Z256)rm$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecXLd, ReadAfterVecXLd], (instregex "^VF(N?)M(ADD|SUB)(132|213|231)PHZ128m((b|k|bk|kz)?)$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZ128mbkz$", + "^VFMADDSUB(132|213|231)PHZ128m((b|k|bk|kz)?)$", + "^VFMADDSUB(132|213|231)PHZ128mbkz$", + "^VFMSUBADD(132|213|231)PHZ128m((b|k|bk|kz)?)$", + "^VFMSUBADD(132|213|231)PHZ128mbkz$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecLd, ReadAfterVecLd], (instregex "^VF(N?)M(ADD|SUB)(132|213|231)SHZm$", + "^VF(N?)M(ADD|SUB)(132|213|231)SHZm_Int((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup73, ReadAfterVecYLd, ReadAfterVecYLd], (instregex "^VPMADD52(H|L)UQZ256m((b|k|bk|kz)?)$", + "^VPMADD52(H|L)UQZ256mbkz$")>; + +def SPRWriteResGroup74 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 5; +} +def : InstRW<[SPRWriteResGroup74], (instregex "^(V?)GF2P8MULBrr$", + "^V(ADD|SUB)PHZ(128|256)rr$", + "^V(ADD|SUB)SHZrr$", + "^V(ADD|SUB)SHZrr(b?)_Int$", + "^VCVT(T?)PH2(U?)WZ(128|256)rr$", + "^VCVTSH2SSZrr(b?)_Int$", + "^VCVT(U?)W2PHZ(128|256)rr$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZ(128|256)r$", + "^VF(N?)M(ADD|SUB)(132|213|231)SHZr(b?)((_Int)?)$", + "^VFMADDSUB(132|213|231)PHZ(128|256)r$", + "^VFMSUBADD(132|213|231)PHZ(128|256)r$", + "^VGETEXPPHZ(128|256)r$", + "^VGETEXPSHZr(b?)$", + "^VGETMANTPHZ(128|256)rri$", + "^VGETMANTSHZrri(b?)$", + "^VGF2P8MULBZ(128|256)rr$", + "^VM(AX|IN)CPHZ(128|256)rr$", + "^VM(AX|IN)CSHZrr$", + "^VM(AX|IN|UL)PHZ(128|256)rr$", + "^VM(AX|IN|UL)SHZrr$", + "^VM(AX|IN|UL)SHZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup74], (instrs VCVTSH2SSZrr, + VGF2P8MULBYrr)>; + +def SPRWriteResGroup75 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 5, 26, 19, 2, 7, 21]; + let Latency = 35; + let NumMicroOps = 87; +} +def : InstRW<[SPRWriteResGroup75], (instrs IN16ri)>; + +def SPRWriteResGroup76 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 1, 4, 26, 19, 3, 7, 20]; + let Latency = 35; + let NumMicroOps = 87; +} +def : InstRW<[SPRWriteResGroup76], (instrs IN16rr)>; + +def SPRWriteResGroup77 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 6, 28, 21, 2, 10, 20]; + let Latency = 35; + let NumMicroOps = 94; +} +def : InstRW<[SPRWriteResGroup77], (instrs IN32ri)>; + +def SPRWriteResGroup78 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 9, 28, 21, 2, 11, 21]; + let NumMicroOps = 99; +} +def : InstRW<[SPRWriteResGroup78], (instrs IN32rr)>; + +def SPRWriteResGroup79 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 6, 25, 19, 2, 8, 20]; + let Latency = 35; + let NumMicroOps = 87; +} +def : InstRW<[SPRWriteResGroup79], (instrs IN8ri)>; + +def SPRWriteResGroup80 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 6, 25, 19, 2, 7, 20]; + let Latency = 35; + let NumMicroOps = 86; +} +def : InstRW<[SPRWriteResGroup80], (instrs IN8rr)>; + +def SPRWriteResGroup81 : SchedWriteRes<[SPRPort00_06]> { + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup81], (instrs INC16r_alt)>; + +def SPRWriteResGroup82 : SchedWriteRes<[SPRPort02_03_11]> { + let Latency = 7; +} +def : InstRW<[SPRWriteResGroup82], (instregex "^LD_F(32|64|80)m$", + "^(V?)MOV(D|SH|SL)DUPrm$", + "^VBROADCASTSS((Z128)?)rm$", + "^VMOV(D|SH|SL)DUPZ128rm$", + "^VPBROADCAST(D|Q)((Z128)?)rm$")>; +def : InstRW<[SPRWriteResGroup82], (instrs INC32r_alt, + VBROADCASTI32X2Z128rm)>; + +def SPRWriteResGroup83 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [7, 6, 24, 17, 8, 1, 19, 1]; + let Latency = 20; + let NumMicroOps = 83; +} +def : InstRW<[SPRWriteResGroup83], (instrs INSB)>; + +def SPRWriteResGroup84 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [7, 1, 5, 1, 27, 17, 11, 1, 21, 1]; + let Latency = 20; + let NumMicroOps = 92; +} +def : InstRW<[SPRWriteResGroup84], (instrs INSL)>; + +def SPRWriteResGroup85 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [7, 1, 4, 1, 25, 17, 1, 9, 1, 19, 1]; + let Latency = 20; + let NumMicroOps = 86; +} +def : InstRW<[SPRWriteResGroup85], (instrs INSW)>; + +def SPRWriteResGroup86 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [5, 4, 8, 6, 2, 5, 7, 5]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 42; +} +def : InstRW<[SPRWriteResGroup86], (instrs INVLPG)>; + +def SPRWriteResGroup87 : SchedWriteRes<[SPRPort04, SPRPort04_09, SPRPort05]> { + let Latency = 4; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup87], (instregex "^IST(T?)_FP(16|32|64)m$", + "^IST_F(16|32)m$")>; + +def SPRWriteResGroup88 : SchedWriteRes<[SPRPort00_01_05_06, SPRPort00_06]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup88], (instrs JCXZ)>; + +def SPRWriteResGroup89 : SchedWriteRes<[SPRPort06]>; +def : InstRW<[SPRWriteResGroup89], (instrs JMP64r_REX)>; + +def SPRWriteResGroup90 : SchedWriteRes<[]> { + let Latency = 0; + let NumMicroOps = 0; +} +def : InstRW<[SPRWriteResGroup90], (instregex "^JMP_(1|4)$")>; +def : InstRW<[SPRWriteResGroup90], (instrs VZEROUPPER)>; + +def SPRWriteResGroup91 : SchedWriteRes<[SPRPort05]> { + let Latency = 4; +} +def : InstRW<[SPRWriteResGroup91], (instregex "^KADD(B|D|Q|W)rr$", + "^KSHIFT(LB|RD|RQ|RW)ri$", + "^KSHIFT(LD|RB)ri$", + "^KSHIFTL(Q|W)ri$", + "^KUNPCK(BW|DQ|WD)rr$")>; + +def SPRWriteResGroup92 : SchedWriteRes<[SPRPort00]>; +def : InstRW<[SPRWriteResGroup92], (instregex "^KAND(B|D|Q|W|ND|NQ|NW)rr$", + "^KMOV(B|D|Q|W)kk$", + "^KNOT(B|D|Q|W)rr$", + "^K((X|XN)?)OR(B|D|Q|W)rr$", + "^VP(A|SU)BSBZrr$", + "^VPABS(D|Q|W)Zrr$", + "^VPABS(D|Q)Zrrk(z?)$", + "^VPADD(U?)S(B|W)Zrr$", + "^VPAVG(B|W)Zrr$", + "^VPM(AX|IN)(SB|UD|UW)Zrr$", + "^VPM(AX|IN)(SD|UB)Zrr$", + "^VPM(AX|IN)(S|U)DZrrk(z?)$", + "^VPM(AX|IN)SWZrr$", + "^VPSH(L|R)D(D|Q|W)Zrri$", + "^VPSH(L|R)DV(D|Q|W)Zr$", + "^VPSH(L|R)DV(D|Q)Zrk(z?)$", + "^VPSUB(U?)SWZrr$")>; +def : InstRW<[SPRWriteResGroup92], (instrs KANDNBrr, + VPSUBUSBZrr)>; + +def SPRWriteResGroup93 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup93], (instregex "^KMOV(B|D|Q|W)km$")>; + +def SPRWriteResGroup94 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 13; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup94], (instregex "^MOV8m(i|r)$")>; +def : InstRW<[SPRWriteResGroup94], (instrs KMOVBmk, + MOV8mr_NOREX)>; + +def SPRWriteResGroup95 : SchedWriteRes<[SPRPort05]>; +def : InstRW<[SPRWriteResGroup95], (instregex "^(V?)PALIGNRrri$", + "^VALIGN(D|Q)Z128rri((k|kz)?)$", + "^VBROADCASTSSZ128rr((k|kz)?)$", + "^VPALIGNR(Y|Z)rri$", + "^VPALIGNRZ(128|256)rri$", + "^VPBROADCAST(B|D|Q|W)rr$", + "^VPSHUF(D|HW|LW)Zri$", + "^VPSHUFDZrik(z?)$", + "^VPS(L|R)LDQZri$", + "^VPUNPCK(H|L)(BW|WD)Zrr$", + "^VPUNPCK(H|L|LQ)DQZrr((k|kz)?)$", + "^VPUNPCKHQDQZrr((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup95], (instrs KMOVQkr, + VPSHUFBZrr)>; + +def SPRWriteResGroup96 : SchedWriteRes<[SPRPort00]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup96], (instregex "^K((OR)?)TEST(B|D|Q|W)rr$", + "^VP(A|SU)BS(B|W)Zrrk(z?)$", + "^VPADD(U?)S(B|W)Zrrk(z?)$", + "^VPAVG(B|W)Zrrk(z?)$", + "^VPM(AX|IN)(SB|UW)Zrrk(z?)$", + "^VPM(AX|IN)(SW|UB)Zrrk(z?)$", + "^VPSH(L|R)DVWZrk(z?)$", + "^VPS(L|R)LVWZrrk(z?)$", + "^VPS(L|R)LWZrik(z?)$", + "^VPSRAVWZrrk(z?)$", + "^VPSRAWZrik(z?)$", + "^VPSUBUS(B|W)Zrrk(z?)$")>; +def : InstRW<[SPRWriteResGroup96], (instrs VMOVSDto64Zrr)>; + +def SPRWriteResGroup97 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [8, 2, 14, 3, 1]; + let Latency = 198; + let NumMicroOps = 81; +} +def : InstRW<[SPRWriteResGroup97], (instrs LAR16rm)>; + +def SPRWriteResGroup98 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 3, 1, 8, 5, 1, 2, 1]; + let Latency = 66; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup98], (instrs LAR16rr)>; + +def SPRWriteResGroup99 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2, 2, 9, 5, 3, 1]; + let Latency = 71; + let NumMicroOps = 85; +} +def : InstRW<[SPRWriteResGroup99], (instrs LAR32rm)>; + +def SPRWriteResGroup100 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 3, 1, 8, 5, 1, 2, 1]; + let Latency = 65; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup100], (instregex "^LAR(32|64)rr$")>; + +def SPRWriteResGroup101 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2, 2, 9, 5, 3, 1]; + let Latency = 71; + let NumMicroOps = 87; +} +def : InstRW<[SPRWriteResGroup101], (instrs LAR64rm)>; + +def SPRWriteResGroup102 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup102], (instrs LEA16r)>; + +def SPRWriteResGroup103 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 6; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup103], (instregex "^LODS(B|W)$", + "^SCAS(B|L|Q|W)$")>; +def : InstRW<[SPRWriteResGroup103], (instrs LEAVE)>; + +def SPRWriteResGroup104 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 6; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup104], (instrs LEAVE64)>; + +def SPRWriteResGroup105 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 2, 4, 3, 2, 1, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 14; +} +def : InstRW<[SPRWriteResGroup105], (instrs LGDT64m)>; + +def SPRWriteResGroup106 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 1, 5, 3, 2, 1, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 14; +} +def : InstRW<[SPRWriteResGroup106], (instrs LIDT64m)>; + +def SPRWriteResGroup107 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [5, 3, 2, 1, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 12; +} +def : InstRW<[SPRWriteResGroup107], (instrs LLDT16m)>; + +def SPRWriteResGroup108 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 4, 3, 1, 1, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup108], (instrs LLDT16r)>; + +def SPRWriteResGroup109 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 1, 2, 8, 3, 1, 2, 7, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 27; +} +def : InstRW<[SPRWriteResGroup109], (instrs LMSW16m)>; + +def SPRWriteResGroup110 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [5, 7, 1, 2, 5, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup110], (instrs LMSW16r)>; + +def SPRWriteResGroup111 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 5; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup111], (instregex "^LODS(L|Q)$")>; + +def SPRWriteResGroup112 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [2, 4, 1]; + let Latency = 3; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup112], (instrs LOOP)>; + +def SPRWriteResGroup113 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [4, 6, 1]; + let Latency = 3; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup113], (instrs LOOPE)>; + +def SPRWriteResGroup114 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [4, 6, 1]; + let Latency = 2; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup114], (instrs LOOPNE)>; + +def SPRWriteResGroup115 : SchedWriteRes<[SPRPort02_03, SPRPort02_03_11, SPRPort06]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup115], (instrs LRET64)>; + +def SPRWriteResGroup116 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 5, 3, 3, 1]; + let Latency = 70; + let NumMicroOps = 13; +} +def : InstRW<[SPRWriteResGroup116], (instregex "^LSL(16|32|64)rm$")>; + +def SPRWriteResGroup117 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 4, 4, 3, 2, 1]; + let Latency = 63; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup117], (instregex "^LSL(16|32|64)rr$")>; + +def SPRWriteResGroup118 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 24; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup118], (instregex "^MMX_CVT(T?)PD2PIrm$")>; + +def SPRWriteResGroup119 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup119], (instregex "^MMX_CVT(T?)PD2PIrr$", + "^VCVT(T?)PH2(U?)DQZ(128|256)rr$", + "^VCVTP(H2PS|S2PH)XZ256rr$")>; + +def SPRWriteResGroup120 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup120], (instregex "^VCVTP(H2PS|S2PH)XZ128rr$", + "^VPERMWZ(128|256)rrk(z?)$", + "^VPS(L|R)LWZ256rrk(z?)$", + "^VPSRAWZ256rrk(z?)$")>; +def : InstRW<[SPRWriteResGroup120], (instrs MMX_CVTPI2PDrr)>; + +def SPRWriteResGroup121 : SchedWriteRes<[SPRPort00, SPRPort00_01]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup121], (instrs MMX_CVTPI2PSrr)>; + +def SPRWriteResGroup122 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 13; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup122], (instregex "^MMX_CVT(T?)PS2PIrm$")>; + +def SPRWriteResGroup123 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup123], (instregex "^MMX_CVT(T?)PS2PIrr$")>; + +def SPRWriteResGroup124 : SchedWriteRes<[SPRPort00, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup124], (instregex "^MMX_MASKMOVQ((64)?)$")>; + +def SPRWriteResGroup125 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 18; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup125], (instregex "^VMOV(W|SHZ)mr$")>; +def : InstRW<[SPRWriteResGroup125], (instrs MMX_MOVD64mr)>; + +def SPRWriteResGroup126 : SchedWriteRes<[SPRPort02_03_11]> { + let Latency = 8; +} +def : InstRW<[SPRWriteResGroup126], (instregex "^MMX_MOV(D|Q)64rm$", + "^VBROADCAST(F|I)128$", + "^VBROADCAST(F|I)32X(2|4)Z256rm$", + "^VBROADCAST(F|I)32X(8|2Z)rm$", + "^VBROADCAST(F|I)(32|64)X4rm$", + "^VBROADCAST(F|I)64X2((Z128)?)rm$", + "^VBROADCASTS(DY|SZ)rm$", + "^VBROADCASTS(D|S)Z256rm$", + "^VBROADCASTS(DZ|SY)rm$", + "^VMOV(D|SH|SL)DUP(Y|Z)rm$", + "^VMOV(D|SH|SL)DUPZ256rm$", + "^VPBROADCAST(DY|QZ)rm$", + "^VPBROADCAST(D|Q)Z256rm$", + "^VPBROADCAST(DZ|QY)rm$")>; +def : InstRW<[SPRWriteResGroup126], (instrs MMX_MOVD64to64rm)>; + +def SPRWriteResGroup127 : SchedWriteRes<[SPRPort00_01_05, SPRPort00_05]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup127], (instregex "^MMX_MOV(DQ|FR64)2Qrr$")>; + +def SPRWriteResGroup128 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup128], (instregex "^MMX_MOVQ2(DQ|FR64)rr$")>; + +def SPRWriteResGroup129 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup129, ReadAfterVecLd], (instregex "^MMX_PACKSS(DW|WB)rm$")>; +def : InstRW<[SPRWriteResGroup129, ReadAfterVecLd], (instrs MMX_PACKUSWBrm)>; + +def SPRWriteResGroup130 : SchedWriteRes<[SPRPort05]> { + let ResourceCycles = [2]; + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup130], (instregex "^MMX_PACKSS(DW|WB)rr$", + "^VPMOV(D|Q|W|SQ|SW)BZrr$", + "^VPMOV((S|US)?)(D|Q)WZrr$", + "^VPMOV(U?)S(DB|QD)Zrr$", + "^VPMOV(U?)SQDZrrk(z?)$", + "^VPMOVUS(Q|W)BZrr$")>; +def : InstRW<[SPRWriteResGroup130], (instrs MMX_PACKUSWBrr)>; +def : InstRW<[SPRWriteResGroup130, ReadDefault, ReadInt2Fpu], (instrs MMX_PINSRWrr)>; + +def SPRWriteResGroup131 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup131], (instregex "^VBROADCAST(F|I)32X(8|2Z)rmk(z?)$", + "^VBROADCAST(F|I)(32|64)X4rmk(z?)$", + "^VBROADCAST(F|I)64X2rmk(z?)$", + "^VBROADCASTS(D|S)Zrmk(z?)$", + "^VMOV(A|U)P(D|S)Zrmk(z?)$", + "^VMOV(D|SH|SL)DUPZrmk(z?)$", + "^VMOVDQ(A|U)(32|64)Zrmk(z?)$", + "^VPBROADCAST(D|Q)Zrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup131, ReadAfterVecLd], (instregex "^MMX_P(ADD|SUB)(B|D|Q|W)rm$")>; +def : InstRW<[SPRWriteResGroup131, ReadAfterVecYLd], (instregex "^VINSERT(F|I)(32|64)x4Zrm((k|kz)?)$", + "^VINSERT(F|I)(32x8|64x2)Zrm((k|kz)?)$", + "^VP(ADD|SUB)(B|D|Q|W)Zrm$", + "^VP(ADD|SUB)(D|Q)Zrm(b|k|kz)$", + "^VP(ADD|SUB)(D|Q)Zrmbk(z?)$", + "^VPTERNLOG(D|Q)Zrm(bi|ik)$", + "^VPTERNLOG(D|Q)Zrmbik(z?)$", + "^VPTERNLOG(D|Q)Zrmi((kz)?)$")>; + +def SPRWriteResGroup132 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 11; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup132, ReadAfterVecLd], (instregex "^MMX_PH(ADD|SUB)SWrm$")>; + +def SPRWriteResGroup133 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup133], (instregex "^MMX_PH(ADD|SUB)SWrr$")>; + +def SPRWriteResGroup134 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup134], (instregex "^VPBROADCAST(BY|WZ)rm$", + "^VPBROADCAST(B|W)Z256rm$", + "^VPBROADCAST(BZ|WY)rm$")>; +def : InstRW<[SPRWriteResGroup134, ReadAfterLd], (instrs MMX_PINSRWrm)>; +def : InstRW<[SPRWriteResGroup134, ReadAfterVecXLd], (instregex "^VFPCLASSP(D|S)Z128rm$")>; +def : InstRW<[SPRWriteResGroup134, ReadAfterVecLd], (instregex "^VFPCLASSS(D|H|S)Zrm$")>; +def : InstRW<[SPRWriteResGroup134, ReadAfterVecYLd], (instregex "^VPALIGNR(Y|Z256)rmi$")>; +def : InstRW<[SPRWriteResGroup134, ReadAfterVecYLd], (instrs VPSHUFBZrm)>; + +def SPRWriteResGroup135 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let Latency = 5; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup135], (instregex "^MOV16ao(16|32|64)$")>; + +def SPRWriteResGroup136 : SchedWriteRes<[SPRPort01, SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup136], (instregex "^PUSH(F|G)S(16|32)$")>; +def : InstRW<[SPRWriteResGroup136], (instrs MOV16ms, + MOVBE32mr)>; + +def SPRWriteResGroup137 : SchedWriteRes<[SPRPort00_01_05_06_10]>; +def : InstRW<[SPRWriteResGroup137], (instregex "^MOV(8|16|32|64)ri$", + "^MOV(8|16|32)ri_alt$", + "^MOV(8|16)rr((_REV)?)$")>; +def : InstRW<[SPRWriteResGroup137], (instrs MOV64ri32, + MOV8rr_NOREX)>; + +def SPRWriteResGroup138 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01]> { + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup138], (instregex "^MOV(16|32|64)rs$", + "^S(TR|LDT)16r$")>; + +def SPRWriteResGroup139 : SchedWriteRes<[SPRPort02_03_11]>; +def : InstRW<[SPRWriteResGroup139], (instregex "^MOV32ao(16|32|64)$")>; +def : InstRW<[SPRWriteResGroup139], (instrs MOV64ao64)>; + +def SPRWriteResGroup140 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup140], (instregex "^MOV(8|32)o(16|32)a$", + "^MOV(8|32|64)o64a$")>; + +def SPRWriteResGroup141 : SchedWriteRes<[SPRPort00_01_05_06_10]> { + let Latency = 0; +} +def : InstRW<[SPRWriteResGroup141], (instregex "^MOV32rr((_REV)?)$", + "^MOVZX(32|64)rr8$")>; +def : InstRW<[SPRWriteResGroup141], (instrs MOVZX32rr8_NOREX)>; + +def SPRWriteResGroup142 : SchedWriteRes<[SPRPort02_03_11]> { + let Latency = 5; +} +def : InstRW<[SPRWriteResGroup142], (instrs MOV64ao32)>; + +def SPRWriteResGroup143 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 2, 4, 16, 7, 2, 2, 12, 2]; + let Latency = 217; + let NumMicroOps = 48; +} +def : InstRW<[SPRWriteResGroup143], (instrs MOV64dr)>; + +def SPRWriteResGroup144 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup144], (instrs MOV64o32a)>; + +def SPRWriteResGroup145 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort05]> { + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup145], (instrs MOV64rc)>; + +def SPRWriteResGroup146 : SchedWriteRes<[SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort05]> { + let ResourceCycles = [3, 4, 8, 4, 2, 3]; + let Latency = 181; + let NumMicroOps = 24; +} +def : InstRW<[SPRWriteResGroup146], (instrs MOV64rd)>; + +def SPRWriteResGroup147 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup147], (instregex "^MOV8ao(16|32|64)$")>; + +def SPRWriteResGroup148 : SchedWriteRes<[SPRPort00_06, SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup148], (instrs MOVBE16mr)>; + +def SPRWriteResGroup149 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup149], (instrs MOVBE16rm)>; + +def SPRWriteResGroup150 : SchedWriteRes<[SPRPort01, SPRPort02_03_11]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup150], (instrs MOVBE32rm)>; + +def SPRWriteResGroup151 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup151], (instrs MOVBE64mr, + PUSHF16, + SLDT16m, + STRm)>; + +def SPRWriteResGroup152 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup152], (instrs MOVBE64rm)>; + +def SPRWriteResGroup153 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup153], (instregex "^MOVDIR64B(16|32|64)$")>; + +def SPRWriteResGroup154 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 511; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup154], (instrs MOVDIRI32)>; + +def SPRWriteResGroup155 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 514; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup155], (instrs MOVDIRI64)>; + +def SPRWriteResGroup156 : SchedWriteRes<[SPRPort01_05, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup156, ReadAfterVecXLd], (instregex "^(V?)MOVLP(D|S)rm$", + "^(V?)SHUFP(D|S)rmi$", + "^VMOVLP(D|S)Z128rm$", + "^VSHUFP(D|S)Z128rm(bi|ik)$", + "^VSHUFP(D|S)Z128rmbik(z?)$", + "^VSHUFP(D|S)Z128rmi((kz)?)$")>; + +def SPRWriteResGroup157 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 512; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup157], (instrs MOVNTDQmr)>; + +def SPRWriteResGroup158 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 518; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup158], (instrs MOVNTImr)>; + +def SPRWriteResGroup159 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [4, 1, 1, 1]; + let Latency = 8; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup159], (instrs MOVSB)>; + +def SPRWriteResGroup160 : SchedWriteRes<[SPRPort00_01_05]>; +def : InstRW<[SPRWriteResGroup160], (instregex "^(V?)MOVS(D|S)rr((_REV)?)$", + "^(V?)P(ADD|SUB)(B|D|Q|W)rr$", + "^VMOV(A|U)P(D|S)Z(128|256)rrk(z?)((_REV)?)$", + "^VMOVDQ(A|U)(32|64)Z128rrk(z?)((_REV)?)$", + "^VMOVS(D|H|S)Zrr((_REV)?)$", + "^VMOVS(D|S)Zrrk(z?)((_REV)?)$", + "^VP(ADD|SUB)(B|D|Q|W)Yrr$", + "^VP(ADD|SUB)(B|D|Q|W)Z(128|256)rr$", + "^VP(ADD|SUB)(D|Q)Z(128|256)rrk(z?)$", + "^VPMOVM2(D|Q)Z128rr$", + "^VPTERNLOG(D|Q)Z(128|256)rri((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup160], (instrs VPBLENDDrri)>; + +def SPRWriteResGroup161 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [4, 1, 1, 1]; + let Latency = 7; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup161], (instregex "^MOVS(L|Q|W)$")>; + +def SPRWriteResGroup162 : SchedWriteRes<[SPRPort02_03_11]> { + let Latency = 6; +} +def : InstRW<[SPRWriteResGroup162], (instregex "^MOVSX(16|32|64)rm(16|32)$", + "^MOVSX(32|64)rm8$")>; +def : InstRW<[SPRWriteResGroup162], (instrs MOVSX32rm8_NOREX)>; + +def SPRWriteResGroup163 : SchedWriteRes<[SPRPort01_05_10, SPRPort02_03_11]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup163], (instrs MOVSX16rm8)>; + +def SPRWriteResGroup164 : SchedWriteRes<[SPRPort01_05_10]>; +def : InstRW<[SPRWriteResGroup164], (instregex "^MOVSX(16|32|64)rr(8|16|32)$")>; +def : InstRW<[SPRWriteResGroup164], (instrs MOVSX32rr8_NOREX)>; + +def SPRWriteResGroup165 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup165], (instregex "^MUL_F(32|64)m$", + "^VPABS(B|W)Zrmk(z?)$", + "^VPS(L|R)LWZmik(z?)$", + "^VPSRAWZmik(z?)$")>; +def : InstRW<[SPRWriteResGroup165, ReadAfterVecYLd], (instregex "^VP(ADD|SUB)(U?)S(B|W)Zrmk(z?)$", + "^VPAVG(B|W)Zrmk(z?)$", + "^VPM(AX|IN)(SB|UW)Zrmk(z?)$", + "^VPM(AX|IN)(SW|UB)Zrmk(z?)$", + "^VPSH(L|R)DVWZmk(z?)$", + "^VPS(L|R)L(V?)WZrmk(z?)$", + "^VPSRA(V?)WZrmk(z?)$")>; + +def SPRWriteResGroup166 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup166], (instregex "^MUL_FI(16|32)m$")>; + +def SPRWriteResGroup167 : SchedWriteRes<[SPRPort00]> { + let Latency = 4; +} +def : InstRW<[SPRWriteResGroup167], (instregex "^MUL_F(P?)rST0$", + "^V(U?)COMISHZrr(b?)$", + "^V(U?)COMISHZrr_Int$", + "^VCVT(T?)PD2(U?)QQZrr((b|k|bk|kz)?)$", + "^VCVT(T?)PD2(U?)QQZrrbkz$", + "^VCVT(T?)PS2(U?)DQZrr((b|k|bk|kz)?)$", + "^VCVT(T?)PS2(U?)DQZrrbkz$", + "^VM(AX|IN)(C?)PSZrr((k|kz)?)$", + "^VM(AX|IN)PSZrrb((k|kz)?)$", + "^VPLZCNT(D|Q)Zrr((k|kz)?)$", + "^VPMADD52(H|L)UQZr((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup167], (instrs MUL_FST0r)>; + +def SPRWriteResGroup168 : SchedWriteRes<[SPRPort00_01_05_06, SPRPort05, SPRPort06]> { + let ResourceCycles = [7, 1, 2]; + let Latency = 20; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup168], (instrs MWAITrr)>; + +def SPRWriteResGroup169 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [6, 4, 1, 28, 15, 7, 1, 16, 1]; + let Latency = 35; + let NumMicroOps = 79; +} +def : InstRW<[SPRWriteResGroup169], (instrs OUT16ir)>; + +def SPRWriteResGroup170 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [6, 6, 27, 15, 7, 1, 16, 1]; + let Latency = 35; + let NumMicroOps = 79; +} +def : InstRW<[SPRWriteResGroup170], (instrs OUT16rr)>; + +def SPRWriteResGroup171 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [6, 4, 1, 30, 15, 9, 1, 18, 1]; + let Latency = 35; + let NumMicroOps = 85; +} +def : InstRW<[SPRWriteResGroup171], (instrs OUT32ir)>; + +def SPRWriteResGroup172 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [6, 6, 29, 15, 9, 1, 18, 1]; + let Latency = 35; + let NumMicroOps = 85; +} +def : InstRW<[SPRWriteResGroup172], (instrs OUT32rr)>; + +def SPRWriteResGroup173 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [5, 5, 1, 25, 15, 5, 1, 15, 1]; + let Latency = 35; + let NumMicroOps = 73; +} +def : InstRW<[SPRWriteResGroup173], (instrs OUT8ir)>; + +def SPRWriteResGroup174 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [5, 5, 26, 15, 5, 1, 15, 1]; + let Latency = 35; + let NumMicroOps = 73; +} +def : InstRW<[SPRWriteResGroup174], (instrs OUT8rr)>; + +def SPRWriteResGroup175 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [7, 6, 25, 16, 7, 1, 17, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 80; +} +def : InstRW<[SPRWriteResGroup175], (instrs OUTSB)>; + +def SPRWriteResGroup176 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [7, 6, 28, 16, 10, 1, 20, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 89; +} +def : InstRW<[SPRWriteResGroup176], (instrs OUTSL)>; + +def SPRWriteResGroup177 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [6, 1, 5, 27, 16, 8, 1, 18, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 83; +} +def : InstRW<[SPRWriteResGroup177], (instrs OUTSW)>; + +def SPRWriteResGroup178 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup178], (instregex "^VBROADCASTI32X2Z128rmk(z?)$", + "^VBROADCASTSSZ128rmk(z?)$", + "^VMOV(A|U)P(D|S)Z128rmk(z?)$", + "^VMOV(D|SH|SL)DUPZ128rmk(z?)$", + "^VMOVDQ(A|U)(32|64)Z128rmk(z?)$", + "^VMOVS(D|S)Zrmk(z?)$", + "^VPBROADCAST(D|Q)Z128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup178, ReadAfterVecXLd], (instregex "^(V?)P(ADD|SUB)(B|D|Q|W)rm$", + "^VP(ADD|SUB)(B|D|Q|W)Z128rm$", + "^VP(ADD|SUB)(D|Q)Z128rm(b|k|kz)$", + "^VP(ADD|SUB)(D|Q)Z128rmbk(z?)$", + "^VPTERNLOG(D|Q)Z128rm(bi|ik)$", + "^VPTERNLOG(D|Q)Z128rmbik(z?)$", + "^VPTERNLOG(D|Q)Z128rmi((kz)?)$")>; +def : InstRW<[SPRWriteResGroup178, ReadAfterVecXLd], (instrs VPBLENDDrmi)>; + +def SPRWriteResGroup179 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup179], (instregex "^VPBROADCAST(B|W)((Z128)?)rm$")>; +def : InstRW<[SPRWriteResGroup179, ReadAfterVecXLd], (instregex "^(V?)PALIGNRrmi$", + "^VALIGN(D|Q)Z128rm(bi|ik)$", + "^VALIGN(D|Q)Z128rmbik(z?)$", + "^VALIGN(D|Q)Z128rmi((kz)?)$")>; +def : InstRW<[SPRWriteResGroup179, ReadAfterVecXLd], (instrs VPALIGNRZ128rmi)>; + +def SPRWriteResGroup180 : SchedWriteRes<[SPRPort00_06, SPRPort05]> { + let Latency = 140; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup180], (instrs PAUSE)>; + +def SPRWriteResGroup181 : SchedWriteRes<[SPRPort01, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup181, ReadAfterLd], (instregex "^P(DEP|EXT)(32|64)rm$")>; + +def SPRWriteResGroup182 : SchedWriteRes<[SPRPort01_05, SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup182], (instregex "^(V?)PEXTR(D|Q)mr$", + "^VPEXTR(D|Q)Zmr$", + "^VPMOVQDZ128mr(k?)$")>; + +def SPRWriteResGroup183 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 2, 1]; + let Latency = 9; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup183, ReadAfterVecXLd], (instregex "^(V?)PH(ADD|SUB)SWrm$")>; + +def SPRWriteResGroup184 : SchedWriteRes<[SPRPort00_01, SPRPort01_05]> { + let ResourceCycles = [1, 2]; + let Latency = 2; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup184], (instregex "^(V?)PH(ADD|SUB)SWrr$", + "^VPH(ADD|SUB)SWYrr$")>; + +def SPRWriteResGroup185 : SchedWriteRes<[SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup185], (instregex "^POP(16|32|64)rmm$", + "^PUSH(16|32)rmm$")>; + +def SPRWriteResGroup186 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [6, 2, 1, 1]; + let Latency = 5; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup186], (instrs POPF16)>; + +def SPRWriteResGroup187 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 5; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup187], (instrs POPF64)>; + +def SPRWriteResGroup188 : SchedWriteRes<[SPRPort02_03_11]> { + let Latency = 0; +} +def : InstRW<[SPRWriteResGroup188], (instregex "^PREFETCHT(0|1|2)$")>; +def : InstRW<[SPRWriteResGroup188], (instrs PREFETCHNTA)>; + +def SPRWriteResGroup189 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11, SPRPort06]> { + let ResourceCycles = [1, 1, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup189], (instregex "^PTWRITE((64)?)m$")>; + +def SPRWriteResGroup190 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort06]> { + let ResourceCycles = [1, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup190], (instrs PTWRITE64r)>; + +def SPRWriteResGroup191 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort06]> { + let ResourceCycles = [2, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup191], (instrs PTWRITEr)>; + +def SPRWriteResGroup192 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup192], (instregex "^PUSH64r((mr)?)$")>; + +def SPRWriteResGroup193 : SchedWriteRes<[SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup193], (instrs PUSH64rmm)>; + +def SPRWriteResGroup194 : SchedWriteRes<[SPRPort00_06, SPRPort01, SPRPort04_09, SPRPort07_08]> { + let Latency = 4; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup194], (instrs PUSHF64)>; + +def SPRWriteResGroup195 : SchedWriteRes<[SPRPort01, SPRPort04_09, SPRPort07_08]> { + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup195], (instregex "^PUSH(F|G)S64$")>; + +def SPRWriteResGroup196 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [2, 3, 2]; + let Latency = 8; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup196], (instregex "^RC(L|R)(16|32|64)rCL$")>; + +def SPRWriteResGroup197 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let ResourceCycles = [1, 2]; + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup197, WriteRMW], (instregex "^RC(L|R)8m(1|i)$")>; + +def SPRWriteResGroup198 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [1, 5, 2]; + let Latency = 20; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup198, WriteRMW], (instrs RCL8mCL)>; + +def SPRWriteResGroup199 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [2, 5, 2]; + let Latency = 7; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup199], (instrs RCL8rCL)>; + +def SPRWriteResGroup200 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [2, 4, 3]; + let Latency = 20; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup200, WriteRMW], (instrs RCR8mCL)>; + +def SPRWriteResGroup201 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [3, 4, 3]; + let Latency = 9; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup201], (instrs RCR8rCL)>; + +def SPRWriteResGroup202 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_05, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort01_05_10, SPRPort05]> { + let ResourceCycles = [1, 6, 1, 10, 20, 8, 5, 1, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 54; +} +def : InstRW<[SPRWriteResGroup202], (instrs RDMSR)>; + +def SPRWriteResGroup203 : SchedWriteRes<[SPRPort01]> { + let Latency = SapphireRapidsModel.MaxLatency; +} +def : InstRW<[SPRWriteResGroup203], (instrs RDPID64)>; + +def SPRWriteResGroup204 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup204], (instrs RDPKRUr)>; + +def SPRWriteResGroup205 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort05]> { + let ResourceCycles = [9, 6, 2, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 18; +} +def : InstRW<[SPRWriteResGroup205], (instrs RDPMC)>; + +def SPRWriteResGroup206 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 3, 2, 5, 7, 3, 1, 2]; + let Latency = 1386; + let NumMicroOps = 25; +} +def : InstRW<[SPRWriteResGroup206], (instrs RDRAND16r)>; + +def SPRWriteResGroup207 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 3, 2, 5, 7, 3, 1, 2]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 25; +} +def : InstRW<[SPRWriteResGroup207], (instregex "^RDRAND(32|64)r$")>; + +def SPRWriteResGroup208 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 3, 3, 5, 7, 1, 4]; + let Latency = 1381; + let NumMicroOps = 25; +} +def : InstRW<[SPRWriteResGroup208], (instrs RDSEED16r)>; + +def SPRWriteResGroup209 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 3, 3, 5, 7, 1, 4]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 25; +} +def : InstRW<[SPRWriteResGroup209], (instregex "^RDSEED(32|64)r$")>; + +def SPRWriteResGroup210 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort05]> { + let ResourceCycles = [5, 6, 3, 1]; + let Latency = 18; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup210], (instrs RDTSC)>; + +def SPRWriteResGroup211 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort05]> { + let ResourceCycles = [2, 2, 1, 2, 7, 4, 3]; + let Latency = 42; + let NumMicroOps = 21; +} +def : InstRW<[SPRWriteResGroup211], (instrs RDTSCP)>; + +def SPRWriteResGroup212 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup212], (instrs RET64)>; + +def SPRWriteResGroup213 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 6; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup213], (instregex "^RETI(16|32|64)$")>; + +def SPRWriteResGroup214 : SchedWriteRes<[]>; +def : InstRW<[SPRWriteResGroup214], (instrs REX64_PREFIX)>; + +def SPRWriteResGroup215 : SchedWriteRes<[SPRPort00_06]> { + let ResourceCycles = [2]; + let Latency = 12; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup215, WriteRMW], (instregex "^RO(L|R)(16|32|64)m(1|i|CL)$")>; + +def SPRWriteResGroup216 : SchedWriteRes<[SPRPort00_06]> { + let ResourceCycles = [2]; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup216], (instregex "^RO(L|R)(8|16|32|64)r(1|i)$")>; + +def SPRWriteResGroup217 : SchedWriteRes<[SPRPort00_06]> { + let ResourceCycles = [2]; + let Latency = 13; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup217, WriteRMW], (instregex "^RO(L|R)8m(1|i)$", + "^(RO|SH)L8mCL$", + "^(RO|SA|SH)R8mCL$")>; + +def SPRWriteResGroup218 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 15; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup218], (instregex "^(V?)ROUNDP(D|S)m$")>; +def : InstRW<[SPRWriteResGroup218, ReadAfterVecXLd], (instregex "^(V?)ROUNDS(D|S)m((_Int)?)$", + "^VRNDSCALEP(D|S)Z128rm(bi|ik)$", + "^VRNDSCALEP(D|S)Z128rmbik(z?)$", + "^VRNDSCALEP(D|S)Z128rmi((kz)?)$", + "^VRNDSCALES(D|S)Zm$", + "^VRNDSCALES(D|S)Zm_Int((k|kz)?)$")>; + +def SPRWriteResGroup219 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [2]; + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup219], (instregex "^(V?)ROUND(PD|SS)r$", + "^(V?)ROUND(PS|SD)r$", + "^(V?)ROUNDS(D|S)r_Int$", + "^VRNDSCALEP(D|S)Z(128|256)rri((k|kz)?)$", + "^VRNDSCALES(D|S)Zr$", + "^VRNDSCALES(D|S)Zr(b?)_Int((k|kz)?)$", + "^VROUNDP(D|S)Yr$")>; + +def SPRWriteResGroup220 : SchedWriteRes<[SPRPort00_06]> { + let ResourceCycles = [2]; + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup220], (instrs SAHF)>; + +def SPRWriteResGroup221 : SchedWriteRes<[SPRPort00_06]> { + let Latency = 13; +} +def : InstRW<[SPRWriteResGroup221, WriteRMW], (instregex "^S(A|H)R8m(1|i)$", + "^SHL8m(1|i)$")>; + +def SPRWriteResGroup222 : SchedWriteRes<[SPRPort00_06, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup222, ReadAfterLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^S(A|H)RX(32|64)rm$", + "^SHLX(32|64)rm$")>; + +def SPRWriteResGroup223 : SchedWriteRes<[SPRPort00_06]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup223], (instregex "^S(A|H)RX(32|64)rr$", + "^SHLX(32|64)rr$")>; + +def SPRWriteResGroup224 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 2, 1, 1, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup224], (instrs SERIALIZE)>; + +def SPRWriteResGroup225 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup225], (instrs SFENCE)>; + +def SPRWriteResGroup226 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 2, 2, 2]; + let Latency = 21; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup226], (instregex "^S(G|I)DT64m$")>; + +def SPRWriteResGroup227 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup227, ReadAfterVecXLd], (instrs SHA1MSG1rm)>; + +def SPRWriteResGroup228 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup228], (instrs SHA1MSG1rr)>; + +def SPRWriteResGroup229 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 2, 1, 2, 1]; + let Latency = 13; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup229, ReadAfterVecXLd], (instrs SHA1MSG2rm)>; + +def SPRWriteResGroup230 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort01_05]> { + let ResourceCycles = [2, 2, 1, 2]; + let Latency = 6; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup230], (instrs SHA1MSG2rr)>; + +def SPRWriteResGroup231 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup231, ReadAfterVecXLd], (instrs SHA1NEXTErm)>; + +def SPRWriteResGroup232 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05]> { + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup232], (instrs SHA1NEXTErr)>; + +def SPRWriteResGroup233 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 13; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup233], (instregex "^VPMOV(S|Z)XBWZ((256)?)rmk(z?)$", + "^VPOPCNT(B|W)Z(128|256)rmk(z?)$", + "^VPOPCNT(B|W)Zrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup233, ReadAfterVecXLd], (instregex "^VDBPSADBWZ128rmik(z?)$", + "^VPACK(S|U)SDWZ128rm(bk|kz)$", + "^VPACK(S|U)SDWZ128rmbkz$", + "^VPACK(S|U)S(DW|WB)Z128rmk$", + "^VPACK(S|U)SWBZ128rmkz$", + "^VPMULTISHIFTQBZ128rm(bk|kz)$", + "^VPMULTISHIFTQBZ128rm(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup233, ReadAfterVecXLd], (instrs SHA1RNDS4rmi, + SHA256RNDS2rm)>; +def : InstRW<[SPRWriteResGroup233, ReadAfterVecYLd], (instregex "^VDBPSADBWZ((256)?)rmik(z?)$", + "^VPACK(S|U)SDWZ((256)?)rm(bk|kz)$", + "^VPACK(S|U)SDWZ((256)?)rmbkz$", + "^VPACK(S|U)S(DW|WB)Z((256)?)rmk$", + "^VPACK(S|U)SWBZ((256)?)rmkz$", + "^VPERMBZ(128|256)rmk(z?)$", + "^VPERMBZrmk(z?)$", + "^VPMULTISHIFTQBZ((256)?)rm(bk|kz)$", + "^VPMULTISHIFTQBZ((256)?)rm(k|bkz)$")>; + +def SPRWriteResGroup234 : SchedWriteRes<[SPRPort05]> { + let Latency = 6; +} +def : InstRW<[SPRWriteResGroup234], (instrs SHA1RNDS4rri, + SHA256RNDS2rr)>; + +def SPRWriteResGroup235 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [3, 2, 1, 1, 1]; + let Latency = 12; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup235, ReadAfterVecXLd], (instrs SHA256MSG1rm)>; + +def SPRWriteResGroup236 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [3, 2, 1, 1]; + let Latency = 5; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup236], (instrs SHA256MSG1rr)>; + +def SPRWriteResGroup237 : SchedWriteRes<[SPRPort05]> { + let ResourceCycles = [2]; + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup237], (instregex "^VPMOV(D|Q|W|SQ|SW)BZrrk(z?)$", + "^VPMOV((S|US)?)(D|Q)WZrrk(z?)$", + "^VPMOV(U?)SDBZrrk(z?)$", + "^VPMOVUS(Q|W)BZrrk(z?)$")>; +def : InstRW<[SPRWriteResGroup237], (instrs SHA256MSG2rr)>; + +def SPRWriteResGroup238 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort07_08]> { + let Latency = 13; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup238], (instrs SHRD16mri8)>; + +def SPRWriteResGroup239 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup239], (instregex "^SLDT(32|64)r$")>; + +def SPRWriteResGroup240 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort05]> { + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup240], (instrs SMSW16r)>; + +def SPRWriteResGroup241 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort05]> { + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup241], (instregex "^SMSW(32|64)r$")>; + +def SPRWriteResGroup242 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 24; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup242, ReadAfterVecLd], (instregex "^(V?)SQRTSDm_Int$")>; +def : InstRW<[SPRWriteResGroup242, ReadAfterVecLd], (instrs VSQRTSDZm_Int)>; + +def SPRWriteResGroup243 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup243], (instrs STD)>; + +def SPRWriteResGroup244 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [1, 4, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup244], (instrs STI)>; + +def SPRWriteResGroup245 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup245], (instrs STOSB)>; + +def SPRWriteResGroup246 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 7; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup246], (instregex "^STOS(L|Q|W)$")>; + +def SPRWriteResGroup247 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort01]> { + let Latency = 5; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup247], (instregex "^STR(32|64)r$")>; + +def SPRWriteResGroup248 : SchedWriteRes<[SPRPort00]> { + let Latency = 2; +} +def : InstRW<[SPRWriteResGroup248], (instregex "^(TST|XAM)_F$")>; +def : InstRW<[SPRWriteResGroup248], (instrs UCOM_FPPr)>; + +def SPRWriteResGroup249 : SchedWriteRes<[SPRPort01_05]> { + let Latency = 4; +} +def : InstRW<[SPRWriteResGroup249], (instregex "^V(ADD|SUB)P(D|S)Z(128|256)rrkz$", + "^V(ADD|SUB)S(D|S)Zrr(b?)_Intkz$")>; + +def SPRWriteResGroup250 : SchedWriteRes<[SPRPort00_05]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup250], (instregex "^V(ADD|SUB)P(D|S)Zrr(b?)$", + "^VMOVDQU(8|16)Zrrk(z?)((_REV)?)$", + "^VP(ADD|SUB)(B|W)Zrrk(z?)$", + "^VPBLENDM(B|W)Zrrk(z?)$", + "^VPMOVM2(B|W)Zrr$")>; + +def SPRWriteResGroup251 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 6; +} +def : InstRW<[SPRWriteResGroup251], (instregex "^V(ADD|SUB)PHZ(128|256)rrk(z?)$", + "^V(ADD|SUB)SHZrr(b?)_Intk(z?)$", + "^VCVT(T?)PH2(U?)WZ(128|256)rrk(z?)$", + "^VCVT(U?)W2PHZ(128|256)rrk(z?)$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZ(128|256)rk(z?)$", + "^VF(N?)M(ADD|SUB)(132|213|231)SHZr(b?)_Intk(z?)$", + "^VFMADDSUB(132|213|231)PHZ(128|256)rk(z?)$", + "^VFMSUBADD(132|213|231)PHZ(128|256)rk(z?)$", + "^VGETEXPPHZ(128|256)rk(z?)$", + "^VGETEXPSHZr(bk|kz)$", + "^VGETEXPSHZr(k|bkz)$", + "^VGETMANTPHZ(128|256)rrik(z?)$", + "^VGETMANTSHZrri(bk|kz)$", + "^VGETMANTSHZrri(k|bkz)$", + "^VM(AX|IN)CPHZ(128|256)rrk(z?)$", + "^VM(AX|IN|UL)PHZ(128|256)rrk(z?)$", + "^VM(AX|IN|UL)SHZrr(b?)_Intk(z?)$")>; + +def SPRWriteResGroup252 : SchedWriteRes<[SPRPort00]> { + let Latency = 5; +} +def : InstRW<[SPRWriteResGroup252], (instregex "^V(ADD|SUB)PHZrr(b?)$", + "^VAES(DE|EN)C((LAST)?)Zrr$", + "^VCVT(T?)PH2(U?)WZrr(b?)$", + "^VCVT(U?)W2PHZrr(b?)$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZr(b?)$", + "^VFMADDSUB(132|213|231)PHZr(b?)$", + "^VFMSUBADD(132|213|231)PHZr(b?)$", + "^VGETEXPPHZr(b?)$", + "^VGETMANTPHZrri(b?)$", + "^VM(AX|IN)CPHZrr$", + "^VM(AX|IN|UL)PHZrr(b?)$", + "^VMOVMSKP(D|S)Yrr$")>; +def : InstRW<[SPRWriteResGroup252], (instrs VGF2P8MULBZrr)>; + +def SPRWriteResGroup253 : SchedWriteRes<[SPRPort00]> { + let Latency = 6; +} +def : InstRW<[SPRWriteResGroup253], (instregex "^V(ADD|SUB)PHZrr(bk|kz)$", + "^V(ADD|SUB)PHZrr(k|bkz)$", + "^VCVT(T?)PH2(U?)WZrr(bk|kz)$", + "^VCVT(T?)PH2(U?)WZrr(k|bkz)$", + "^VCVT(U?)W2PHZrr(bk|kz)$", + "^VCVT(U?)W2PHZrr(k|bkz)$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZr(bk|kz)$", + "^VF(N?)M(ADD|SUB)(132|213|231)PHZr(k|bkz)$", + "^VFMADDSUB(132|213|231)PHZr(bk|kz)$", + "^VFMADDSUB(132|213|231)PHZr(k|bkz)$", + "^VFMSUBADD(132|213|231)PHZr(bk|kz)$", + "^VFMSUBADD(132|213|231)PHZr(k|bkz)$", + "^VGETEXPPHZr(bk|kz)$", + "^VGETEXPPHZr(k|bkz)$", + "^VGETMANTPHZrri(bk|kz)$", + "^VGETMANTPHZrri(k|bkz)$", + "^VM(AX|IN)CPHZrrk(z?)$", + "^VM(AX|IN|UL)PHZrr(bk|kz)$", + "^VM(AX|IN|UL)PHZrr(k|bkz)$")>; + +def SPRWriteResGroup254 : SchedWriteRes<[SPRPort01_05, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup254], (instregex "^VPMOV(S|Z)XBWZ128rmk(z?)$", + "^VPSHUF(H|L)WZ(128|256)mik(z?)$")>; +def : InstRW<[SPRWriteResGroup254, ReadAfterVecYLd], (instregex "^V(ADD|SUB)PSYrm$", + "^V(ADD|SUB)PSZ256rm((b|k|bk|kz)?)$", + "^V(ADD|SUB)PSZ256rmbkz$", + "^VPSHUFBZ256rmk(z?)$", + "^VPUNPCK(H|L)(BW|WD)Z256rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup254, ReadAfterVecYLd], (instrs VADDSUBPSYrm)>; +def : InstRW<[SPRWriteResGroup254, ReadAfterVecXLd], (instregex "^VPSHUFBZ128rmk(z?)$", + "^VPUNPCK(H|L)(BW|WD)Z128rmk(z?)$")>; + +def SPRWriteResGroup255 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup255], (instregex "^VMOVDQU(8|16)Zrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup255, ReadAfterVecYLd], (instregex "^V(ADD|SUB)PSZrm((b|k|bk|kz)?)$", + "^V(ADD|SUB)PSZrmbkz$", + "^VP(ADD|SUB)(B|W)Zrmk(z?)$", + "^VPBLENDM(B|W)Zrmk(z?)$")>; + +def SPRWriteResGroup256 : SchedWriteRes<[SPRPort00_05]> { + let Latency = 4; +} +def : InstRW<[SPRWriteResGroup256], (instregex "^V(ADD|SUB)PSZrr(bk|kz)$", + "^V(ADD|SUB)PSZrr(k|bkz)$")>; + +def SPRWriteResGroup257 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 12; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup257], (instregex "^VCVT(T?)PS2(U?)DQZrm((b|k|bk|kz)?)$", + "^VCVT(T?)PS2(U?)DQZrmbkz$", + "^VPLZCNT(D|Q)Zrm((b|k|bk|kz)?)$", + "^VPLZCNT(D|Q)Zrmbkz$")>; +def : InstRW<[SPRWriteResGroup257, ReadAfterVecXLd], (instregex "^VAES(DE|EN)C((LAST)?)Zrm$")>; +def : InstRW<[SPRWriteResGroup257, ReadAfterVecYLd], (instregex "^VGF2P8AFFINE((INV)?)QBZrm(b?)i$")>; +def : InstRW<[SPRWriteResGroup257, ReadAfterVecYLd], (instrs VGF2P8MULBZrm)>; +def : InstRW<[SPRWriteResGroup257, ReadAfterVecYLd, ReadAfterVecYLd], (instregex "^VPMADD52(H|L)UQZm((b|k|bk|kz)?)$", + "^VPMADD52(H|L)UQZmbkz$")>; + +def SPRWriteResGroup258 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup258], (instregex "^VPBROADCAST(B|W)Z128rmk(z?)$", + "^VPOPCNT(B|D|Q|W)Z((256)?)rm$", + "^VPOPCNT(D|Q)Z((256)?)rm(b|k|kz)$", + "^VPOPCNT(D|Q)Z((256)?)rmbk(z?)$", + "^VPSHUF(H|L)WZmik(z?)$")>; +def : InstRW<[SPRWriteResGroup258, ReadAfterVecYLd], (instregex "^VALIGN(D|Q)Z((256)?)rm(bi|ik)$", + "^VALIGN(D|Q)Z((256)?)rmbik(z?)$", + "^VALIGN(D|Q)Z((256)?)rmi((kz)?)$", + "^VFPCLASSP(D|H|S)Z((256)?)rmb$", + "^VPACK(S|U)S(DW|WB)(Y|Z)rm$", + "^VPACK(S|U)S(DW|WB)Z256rm$", + "^VPACK(S|U)SDWZ((256)?)rmb$", + "^VPALIGNRZ((256)?)rmik(z?)$", + "^VPM(AX|IN)(S|U)QZ((256)?)rm((b|k|bk|kz)?)$", + "^VPM(AX|IN)(S|U)QZ((256)?)rmbkz$", + "^VPMULTISHIFTQBZ((256)?)rm(b?)$", + "^VPUNPCK(H|L)(BW|WD)Zrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup258, ReadAfterVecYLd], (instrs VPCMPGTQYrm)>; +def : InstRW<[SPRWriteResGroup258, ReadAfterVecXLd], (instregex "^VPALIGNRZ128rmik(z?)$", + "^VPCLMULQDQ(Y|Z)rm$")>; +def : InstRW<[SPRWriteResGroup258, ReadAfterVecXLd], (instrs VPCLMULQDQZ256rm)>; + +def SPRWriteResGroup259 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup259, ReadAfterVecYLd, ReadAfterVecYLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^VBLENDVP(D|S)Yrm$")>; +def : InstRW<[SPRWriteResGroup259, ReadAfterVecYLd, ReadAfterVecYLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instrs VPBLENDVBYrm)>; + +def SPRWriteResGroup260 : SchedWriteRes<[SPRPort00_01_05]> { + let ResourceCycles = [3]; + let Latency = 3; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup260], (instregex "^VBLENDVP(S|DY)rr$", + "^VBLENDVP(D|SY)rr$", + "^VPBLENDVB(Y?)rr$")>; + +def SPRWriteResGroup261 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 9; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup261, ReadAfterVecXLd, ReadAfterVecXLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instregex "^VBLENDVP(D|S)rm$")>; +def : InstRW<[SPRWriteResGroup261, ReadAfterVecXLd, ReadAfterVecXLd, ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault], (instrs VPBLENDVBrm)>; + +def SPRWriteResGroup262 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup262], (instregex "^VBROADCAST(F|I)32X(2|4)Z256rmk(z?)$", + "^VBROADCAST(F|I)64X2Z128rmk(z?)$", + "^VBROADCASTS(D|S)Z256rmk(z?)$", + "^VMOV(A|U)P(D|S)Z256rmk(z?)$", + "^VMOV(D|SH|SL)DUPZ256rmk(z?)$", + "^VMOVDQ(A|U)(32|64)Z256rmk(z?)$", + "^VPBROADCAST(D|Q)Z256rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup262, ReadAfterVecYLd], (instregex "^VINSERT(F|I)128rm$", + "^VINSERT(F|I)(32x4|64x2)Z256rm((k|kz)?)$", + "^VP(ADD|SUB)(B|D|Q|W)(Y|Z256)rm$", + "^VP(ADD|SUB)(D|Q)Z256rm(b|k|kz)$", + "^VP(ADD|SUB)(D|Q)Z256rmbk(z?)$", + "^VPTERNLOG(D|Q)Z256rm(bi|ik)$", + "^VPTERNLOG(D|Q)Z256rmbik(z?)$", + "^VPTERNLOG(D|Q)Z256rmi((kz)?)$")>; + +def SPRWriteResGroup263 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup263, ReadAfterVecXLd], (instregex "^VCMPP(D|H|S)Z128rm(bi|ik)$", + "^VCMPP(D|H|S)Z128rm(i|bik)$", + "^VFPCLASSP(D|H|S)Z128rm(b?)k$", + "^VPCMP(B|D|Q|W|UD|UQ|UW)Z128rmi(k?)$", + "^VPCMP(D|Q|UQ)Z128rmib(k?)$", + "^VPCMP(EQ|GT)(B|D|Q|W)Z128rm(k?)$", + "^VPCMP(EQ|GT)(D|Q)Z128rmb(k?)$", + "^VPCMPUBZ128rmi(k?)$", + "^VPCMPUDZ128rmib(k?)$", + "^VPTEST(N?)M(B|D|Q|W)Z128rm(k?)$", + "^VPTEST(N?)M(D|Q)Z128rmb(k?)$")>; +def : InstRW<[SPRWriteResGroup263, ReadAfterVecYLd], (instregex "^VCMPP(D|H|S)Z((256)?)rm(bi|ik)$", + "^VCMPP(D|H|S)Z((256)?)rm(i|bik)$", + "^VFPCLASSP(D|H|S)Z((256)?)rm(b?)k$", + "^VPCMP(B|D|Q|W|UD|UQ|UW)Z((256)?)rmi(k?)$", + "^VPCMP(D|Q|UQ)Z((256)?)rmib(k?)$", + "^VPCMP(EQ|GT)(B|D|Q|W)Z((256)?)rm(k?)$", + "^VPCMP(EQ|GT)(D|Q)Z((256)?)rmb(k?)$", + "^VPCMPUBZ((256)?)rmi(k?)$", + "^VPCMPUDZ((256)?)rmib(k?)$", + "^VPTEST(N?)M(B|D|Q|W)Z((256)?)rm(k?)$", + "^VPTEST(N?)M(D|Q)Z((256)?)rmb(k?)$")>; +def : InstRW<[SPRWriteResGroup263, ReadAfterVecLd], (instregex "^VCMPS(D|H|S)Zrm$", + "^VCMPS(D|H|S)Zrm_Int(k?)$", + "^VFPCLASSS(D|H|S)Zrmk$")>; + +def SPRWriteResGroup264 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 10; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup264, ReadAfterVecLd], (instregex "^V(U?)COMISHZrm((_Int)?)$")>; + +def SPRWriteResGroup265 : SchedWriteRes<[SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 2, 1]; + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup265], (instregex "^VCOMPRESSP(D|S)Z(128|256)mr$", + "^VCOMPRESSP(D|S)Zmr$", + "^VPCOMPRESS(D|Q)Z(128|256)mr$", + "^VPCOMPRESS(D|Q)Zmr$", + "^VPMOV(D|Q|W|SQ|SW)BZmr$", + "^VPMOV((S|US)?)(D|Q)WZmr$", + "^VPMOV(U?)S(DB|QD)Zmr$", + "^VPMOVUS(Q|W)BZmr$")>; + +def SPRWriteResGroup266 : SchedWriteRes<[SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 2, 1]; + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup266], (instregex "^VCOMPRESSP(D|S)Z(128|256)mrk$", + "^VCOMPRESSP(D|S)Zmrk$", + "^VPCOMPRESS(D|Q)Z(128|256)mrk$", + "^VPCOMPRESS(D|Q)Zmrk$", + "^VPMOV(D|Q|W|SQ|SW)BZmrk$", + "^VPMOV((S|US)?)(D|Q)WZmrk$", + "^VPMOV(U?)S(DB|QD)Zmrk$", + "^VPMOVUS(Q|W)BZmrk$")>; + +def SPRWriteResGroup267 : SchedWriteRes<[SPRPort05]> { + let ResourceCycles = [2]; + let Latency = 3; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup267], (instregex "^VCOMPRESSP(D|S)Z(128|256)rr$", + "^VCOMPRESSP(D|S)Zrr$", + "^VEXPANDP(D|S)Z(128|256)rr$", + "^VEXPANDP(D|S)Zrr$", + "^VPCOMPRESS(B|D|Q|W)Z(128|256)rr$", + "^VPCOMPRESS(B|D|Q|W)Zrr$", + "^VPEXPAND(B|D|Q|W)Z(128|256)rr$", + "^VPEXPAND(B|D|Q|W)Zrr$")>; + +def SPRWriteResGroup268 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let Latency = 7; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup268], (instregex "^VCVT(U?)DQ2PDZrr((k|kz)?)$", + "^VCVT(T?)PS2(U?)QQZrr((b|k|bk|kz)?)$", + "^VCVT(T?)PS2(U?)QQZrrbkz$", + "^VCVT(U?)QQ2PSZrr((b|k|bk|kz)?)$", + "^VCVT(U?)QQ2PSZrrbkz$")>; + +def SPRWriteResGroup269 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup269], (instregex "^VCVT(U?)DQ2PHZ128rm(b?)$", + "^VCVTNEPS2BF16Z128rm(b?)$")>; + +def SPRWriteResGroup270 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 19; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup270], (instregex "^VCVT(U?)DQ2PHZ128rm(bk|kz)$", + "^VCVT(U?)DQ2PHZ128rm(k|bkz)$")>; + +def SPRWriteResGroup271 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup271], (instregex "^VCVT(U?)DQ2PHZ128rr$")>; + +def SPRWriteResGroup272 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup272], (instregex "^VCVT(U?)DQ2PHZ128rrk(z?)$")>; + +def SPRWriteResGroup273 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 17; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup273], (instregex "^VCVT(U?)DQ2PHZ256rm(b?)$", + "^VCVTNEPS2BF16Z128rm(bk|kz)$", + "^VCVTNEPS2BF16Z128rm(k|bkz)$")>; + +def SPRWriteResGroup274 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 21; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup274], (instregex "^VCVT(U?)DQ2PHZ256rm(bk|kz)$", + "^VCVT(U?)DQ2PHZ256rm(k|bkz)$")>; + +def SPRWriteResGroup275 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup275], (instregex "^VCVT(U?)DQ2PHZ256rr$")>; + +def SPRWriteResGroup276 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup276], (instregex "^VCVT(U?)DQ2PHZ256rrk(z?)$")>; + +def SPRWriteResGroup277 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 17; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup277], (instregex "^VCVT(U?)DQ2PHZrm(b?)$")>; + +def SPRWriteResGroup278 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 21; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup278], (instregex "^VCVT(U?)DQ2PHZrm(bk|kz)$", + "^VCVT(U?)DQ2PHZrm(k|bkz)$")>; + +def SPRWriteResGroup279 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup279], (instregex "^VCVT(U?)DQ2PHZrr(b?)$")>; + +def SPRWriteResGroup280 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup280], (instregex "^VCVT(U?)DQ2PHZrr(bk|kz)$", + "^VCVT(U?)DQ2PHZrr(k|bkz)$")>; + +def SPRWriteResGroup281 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1]; + let Latency = 15; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup281, ReadAfterVecXLd], (instregex "^VCVTNE2PS2BF16Z128rm(b?)$")>; + +def SPRWriteResGroup282 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1]; + let Latency = 17; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup282, ReadAfterVecXLd], (instregex "^VCVTNE2PS2BF16Z128rm(bk|kz)$", + "^VCVTNE2PS2BF16Z128rm(k|bkz)$")>; + +def SPRWriteResGroup283 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup283], (instregex "^VCVTNE2PS2BF16Z(128|256)rr$")>; + +def SPRWriteResGroup284 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup284], (instregex "^VCVTNE2PS2BF16Z(128|256)rrk(z?)$")>; + +def SPRWriteResGroup285 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1]; + let Latency = 16; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup285, ReadAfterVecYLd], (instregex "^VCVTNE2PS2BF16Z256rm(b?)$")>; + +def SPRWriteResGroup286 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1]; + let Latency = 18; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup286, ReadAfterVecYLd], (instregex "^VCVTNE2PS2BF16Z256rm(bk|kz)$", + "^VCVTNE2PS2BF16Z256rm(k|bkz)$")>; + +def SPRWriteResGroup287 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 16; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup287, ReadAfterVecYLd], (instregex "^VCVTNE2PS2BF16Zrm(b?)$", + "^VDPBF16PSZm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup287, ReadAfterVecYLd], (instrs VDPBF16PSZmbkz)>; + +def SPRWriteResGroup288 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 18; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup288, ReadAfterVecYLd], (instregex "^VCVTNE2PS2BF16Zrm(bk|kz)$", + "^VCVTNE2PS2BF16Zrm(k|bkz)$")>; + +def SPRWriteResGroup289 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup289], (instregex "^VDPBF16PSZr((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup289], (instrs VCVTNE2PS2BF16Zrr)>; + +def SPRWriteResGroup290 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup290], (instregex "^VCVTNE2PS2BF16Zrrk(z?)$")>; + +def SPRWriteResGroup291 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup291], (instregex "^VCVTNEPS2BF16Z(128|256)rr$")>; + +def SPRWriteResGroup292 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort05]> { + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup292], (instregex "^VCVTNEPS2BF16Z(128|256)rrk(z?)$")>; + +def SPRWriteResGroup293 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup293], (instregex "^VCVTNEPS2BF16Z256rm(b?)$")>; + +def SPRWriteResGroup294 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 18; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup294], (instregex "^VCVTNEPS2BF16Z256rm(bk|kz)$", + "^VCVTNEPS2BF16Z256rm(k|bkz)$")>; + +def SPRWriteResGroup295 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup295], (instregex "^VCVTNEPS2BF16Zrm(b?)$")>; + +def SPRWriteResGroup296 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 18; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup296], (instregex "^VCVTNEPS2BF16Zrm(bk|kz)$", + "^VCVTNEPS2BF16Zrm(k|bkz)$")>; + +def SPRWriteResGroup297 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup297], (instrs VCVTNEPS2BF16Zrr)>; + +def SPRWriteResGroup298 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup298], (instregex "^VCVTNEPS2BF16Zrrk(z?)$")>; + +def SPRWriteResGroup299 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 15; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup299], (instregex "^VCVT(T?)PD2DQYrm$", + "^VCVT(T?)P(D|H)2(U?)DQZ256rm(b?)$", + "^VCVT(T?)PD2(U?)DQZ256rm(bk|kz)$", + "^VCVT(T?)PD2(U?)DQZ256rm(k|bkz)$", + "^VCVTPH2PSXZ128rm(bk|kz)$", + "^VCVTPH2PSXZ128rm(k|bkz)$", + "^VCVTPH2PSXZ256rm(b?)$", + "^VCVT(U?)QQ2PSZ256rm((b|k|bk|kz)?)$", + "^VCVT(U?)QQ2PSZ256rmbkz$")>; + +def SPRWriteResGroup300 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 15; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup300], (instregex "^VCVT(T?)P(D|H)2(U?)DQZrm(b?)$", + "^VCVT(T?)PD2(U?)DQZrm(bk|kz)$", + "^VCVT(T?)PD2(U?)DQZrm(k|bkz)$", + "^VCVTPH2PSXZrm(b?)$", + "^VCVT(U?)QQ2PSZrm((b|k|bk|kz)?)$", + "^VCVT(U?)QQ2PSZrmbkz$")>; + +def SPRWriteResGroup301 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1, 2]; + let Latency = 19; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup301], (instregex "^VCVTPD2PHZ128rm(b?)$")>; + +def SPRWriteResGroup302 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1, 2]; + let Latency = 22; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup302], (instregex "^VCVTPD2PHZ128rm(bk|kz)$", + "^VCVTPD2PHZ128rm(k|bkz)$")>; + +def SPRWriteResGroup303 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 12; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup303], (instrs VCVTPD2PHZ128rr)>; + +def SPRWriteResGroup304 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 15; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup304], (instregex "^VCVTPD2PHZ128rrk(z?)$")>; + +def SPRWriteResGroup305 : SchedWriteRes<[SPRPort00_01, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 21; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup305], (instregex "^VCVTPD2PHZ256rm(b?)$")>; + +def SPRWriteResGroup306 : SchedWriteRes<[SPRPort00_01, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 24; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup306], (instregex "^VCVTPD2PHZ256rm(bk|kz)$", + "^VCVTPD2PHZ256rm(k|bkz)$")>; + +def SPRWriteResGroup307 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 13; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup307], (instrs VCVTPD2PHZ256rr)>; + +def SPRWriteResGroup308 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup308], (instregex "^VCVTPD2PHZ256rrk(z?)$")>; + +def SPRWriteResGroup309 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 23; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup309], (instregex "^VCVTP(D2PH|H2PD)Zrm(b?)$")>; + +def SPRWriteResGroup310 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 26; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup310], (instregex "^VCVTP(D2PH|H2PD)Zrm(bk|kz)$", + "^VCVTP(D2PH|H2PD)Zrm(k|bkz)$")>; + +def SPRWriteResGroup311 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup311], (instregex "^VCVTP(D2PH|H2PD)Zrr(b?)$")>; + +def SPRWriteResGroup312 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 18; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup312], (instregex "^VCVTP(D2PH|H2PD)Zrr(bk|kz)$", + "^VCVTP(D2PH|H2PD)Zrr(k|bkz)$")>; + +def SPRWriteResGroup313 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup313], (instregex "^VCVT(T?)PD2(U?)QQZ128rm((b|k|bk|kz)?)$", + "^VCVT(T?)PD2(U?)QQZ128rmbkz$", + "^VPABS(B|W)Z(128|256)rmk(z?)$", + "^VPLZCNT(D|Q)Z128rm((b|k|bk|kz)?)$", + "^VPLZCNT(D|Q)Z128rmbkz$", + "^VPS(L|R)LWZ(128|256)mik(z?)$", + "^VPSRAWZ(128|256)mik(z?)$")>; +def : InstRW<[SPRWriteResGroup313, ReadAfterVecLd], (instregex "^VFIXUPIMMS(D|S)Zrmi((k|kz)?)$", + "^VSCALEFS(D|S)Zrm((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup313, ReadAfterVecXLd], (instregex "^VP(ADD|SUB)(U?)S(B|W)Z128rmk(z?)$", + "^VPAVG(B|W)Z128rmk(z?)$", + "^VPM(AX|IN)(SB|UW)Z128rmk(z?)$", + "^VPM(AX|IN)(SW|UB)Z128rmk(z?)$", + "^VPSH(L|R)DVWZ128mk(z?)$", + "^VPS(L|R)L(V?)WZ128rmk(z?)$", + "^VPSRA(V?)WZ128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup313, ReadAfterVecYLd], (instregex "^VP(ADD|SUB)(U?)S(B|W)Z256rmk(z?)$", + "^VPAVG(B|W)Z256rmk(z?)$", + "^VPM(AX|IN)(SB|UW)Z256rmk(z?)$", + "^VPM(AX|IN)(SW|UB)Z256rmk(z?)$", + "^VPSH(L|R)DVWZ256mk(z?)$", + "^VPS(L|R)L(V?)WZ256rmk(z?)$", + "^VPSRA(V?)WZ256rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup313, ReadAfterVecXLd, ReadAfterVecXLd], (instregex "^VPMADD52(H|L)UQZ128m((b|k|bk|kz)?)$", + "^VPMADD52(H|L)UQZ128mbkz$")>; + +def SPRWriteResGroup314 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 4; +} +def : InstRW<[SPRWriteResGroup314], (instregex "^VCVT(T?)PD2(U?)QQZ(128|256)rr((k|kz)?)$", + "^VCVT(U?)QQ2PDZ(128|256)rr((k|kz)?)$", + "^VFIXUPIMMS(D|S)Zrri((k|kz)?)$", + "^VPLZCNT(D|Q)Z(128|256)rr((k|kz)?)$", + "^VPMADD52(H|L)UQZ(128|256)r((k|kz)?)$", + "^VSCALEFS(D|S)Zrr((k|kz)?)$", + "^VSCALEFS(D|S)Zrrb_Int((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup314, ReadAfterVecLd], (instregex "^VFIXUPIMMS(D|S)Zrrib((k|kz)?)$")>; + +def SPRWriteResGroup315 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup315], (instregex "^VCVT(T?)PH2(U?)DQZ128rm(b?)$", + "^VCVTPS2PHXZ128rm(b?)$")>; + +def SPRWriteResGroup316 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 17; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup316], (instregex "^VCVT(T?)PH2(U?)DQZ128rm(bk|kz)$", + "^VCVT(T?)PH2(U?)DQZ128rm(k|bkz)$")>; + +def SPRWriteResGroup317 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup317], (instregex "^VCVT(T?)PH2(U?)DQZ(128|256)rrk(z?)$", + "^VCVTP(H2PS|S2PH)(X?)Z256rrk(z?)$")>; + +def SPRWriteResGroup318 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 18; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup318], (instregex "^VCVT(T?)PH2(U?)DQZ256rm(bk|kz)$", + "^VCVT(T?)PH2(U?)DQZ256rm(k|bkz)$", + "^VCVTP(H2PS|S2PH)XZ256rm(bk|kz)$", + "^VCVTP(H2PS|S2PH)XZ256rm(k|bkz)$")>; + +def SPRWriteResGroup319 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 18; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup319], (instregex "^VCVT(T?)PH2(U?)DQZrm(bk|kz)$", + "^VCVT(T?)PH2(U?)DQZrm(k|bkz)$", + "^VCVTP(H2PS|S2PH)XZrm(bk|kz)$", + "^VCVTP(H2PS|S2PH)XZrm(k|bkz)$")>; + +def SPRWriteResGroup320 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup320], (instregex "^VCVT(T?)PH2(U?)DQZrr(b?)$", + "^VCVTP(H2PS|S2PH)(X?)Zrr(b?)$", + "^VPSHUFBITQMBZ(128|256)rrk$")>; +def : InstRW<[SPRWriteResGroup320], (instrs VPSHUFBITQMBZrrk)>; + +def SPRWriteResGroup321 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup321], (instregex "^VCVT(T?)PH2(U?)DQZrr(bk|kz)$", + "^VCVT(T?)PH2(U?)DQZrr(k|bkz)$", + "^VCVTP(H2PS|S2PH)XZrr(bk|kz)$", + "^VCVTP(H2PS|S2PH)XZrr(k|bkz)$")>; + +def SPRWriteResGroup322 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1, 2]; + let Latency = 23; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup322], (instregex "^VCVTPH2PDZ128rm(b?)$")>; + +def SPRWriteResGroup323 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 1, 2]; + let Latency = 26; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup323], (instregex "^VCVTPH2PDZ128rm(bk|kz)$", + "^VCVTPH2PDZ128rm(k|bkz)$")>; + +def SPRWriteResGroup324 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 16; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup324], (instrs VCVTPH2PDZ128rr)>; + +def SPRWriteResGroup325 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [2, 1, 1, 2]; + let Latency = 19; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup325], (instregex "^VCVTPH2PDZ128rrk(z?)$")>; + +def SPRWriteResGroup326 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 22; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup326], (instregex "^VCVTPH2PDZ256rm(b?)$")>; + +def SPRWriteResGroup327 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 25; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup327], (instregex "^VCVTPH2PDZ256rm(bk|kz)$", + "^VCVTPH2PDZ256rm(k|bkz)$")>; + +def SPRWriteResGroup328 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup328], (instrs VCVTPH2PDZ256rr)>; + +def SPRWriteResGroup329 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 18; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup329], (instregex "^VCVTPH2PDZ256rrk(z?)$")>; + +def SPRWriteResGroup330 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup330], (instregex "^VCVTP(H2PS|S2PH)(X?)Z128rrk(z?)$")>; + +def SPRWriteResGroup331 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 14; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup331], (instregex "^VCVTPH2PSZ(128|256)rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup331, ReadAfterVecLd], (instregex "^VCVTSH2SSZrm_Intk(z?)$")>; +def : InstRW<[SPRWriteResGroup331, ReadAfterVecXLd], (instregex "^VPMADDUBSWZ128rmk(z?)$", + "^VPMULH((U|RS)?)WZ128rmk(z?)$", + "^VPMULLWZ128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup331, ReadAfterVecYLd], (instregex "^VPMADDUBSWZ256rmk(z?)$", + "^VPMULH((U|RS)?)WZ256rmk(z?)$", + "^VPMULLWZ256rmk(z?)$")>; + +def SPRWriteResGroup332 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup332], (instregex "^VCVT(T?)PS2(U?)QQZrm((b|k|bk|kz)?)$", + "^VCVT(T?)PS2(U?)QQZrmbkz$")>; +def : InstRW<[SPRWriteResGroup332], (instrs VCVTPH2PSZrm)>; +def : InstRW<[SPRWriteResGroup332, ReadAfterVecYLd], (instregex "^VPERMWZrmk(z?)$")>; + +def SPRWriteResGroup333 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2, 1, 1, 1]; + let Latency = 17; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup333], (instregex "^VCVT(T?)PH2(U?)QQZ128rm((b|k|bk|kz)?)$", + "^VCVT(T?)PH2(U?)QQZ128rmbkz$")>; + +def SPRWriteResGroup334 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [1, 2, 1]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup334], (instregex "^VCVT(T?)PH2(U?)QQZ(128|256)rr((k|kz)?)$")>; + +def SPRWriteResGroup335 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2, 1, 1, 1]; + let Latency = 18; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup335], (instregex "^VCVT(T?)PH2(U?)QQZ256rm((b|k|bk|kz)?)$", + "^VCVT(T?)PH2(U?)QQZ256rmbkz$")>; + +def SPRWriteResGroup336 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup336], (instregex "^VCVTPS2PHXZ128rm(bk|kz)$", + "^VCVTPS2PHXZ128rm(k|bkz)$", + "^VCVTPS2PHXZ256rm(b?)$")>; + +def SPRWriteResGroup337 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup337], (instregex "^VCVTPS2PHXZrm(b?)$")>; + +def SPRWriteResGroup338 : SchedWriteRes<[SPRPort00_01, SPRPort04_09, SPRPort07_08]> { + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup338], (instregex "^VCVTPS2PHZ(128|256)mrk$")>; + +def SPRWriteResGroup339 : SchedWriteRes<[SPRPort00, SPRPort04_09, SPRPort07_08]> { + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup339], (instrs VCVTPS2PHZmrk)>; + +def SPRWriteResGroup340 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 5; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup340], (instregex "^VCVT(T?)PS2(U?)QQZ128rr((k|kz)?)$", + "^VCVT(U?)QQ2PSZ128rr((k|kz)?)$")>; + +def SPRWriteResGroup341 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 15; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup341], (instregex "^VCVT(U?)QQ2PHZ128rm(b?)$")>; + +def SPRWriteResGroup342 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 17; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup342], (instregex "^VCVT(U?)QQ2PHZ128rm(bk|kz)$", + "^VCVT(U?)QQ2PHZ128rm(k|bkz)$")>; + +def SPRWriteResGroup343 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup343], (instregex "^VCVT(U?)QQ2PHZ128rr$")>; + +def SPRWriteResGroup344 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort05]> { + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup344], (instregex "^VCVT(U?)QQ2PHZ128rrk(z?)$", + "^VCVT(U?)QQ2PHZ256rr$")>; + +def SPRWriteResGroup345 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 18; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup345], (instregex "^VCVT(U?)QQ2PHZ256rm(b?)$")>; + +def SPRWriteResGroup346 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let Latency = 20; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup346], (instregex "^VCVT(U?)QQ2PHZ256rm(bk|kz)$", + "^VCVT(U?)QQ2PHZ256rm(k|bkz)$")>; + +def SPRWriteResGroup347 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort05]> { + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup347], (instregex "^VCVT(U?)QQ2PHZ256rrk(z?)$")>; + +def SPRWriteResGroup348 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 1, 2]; + let Latency = 18; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup348], (instregex "^VCVT(U?)QQ2PHZrm(b?)$")>; + +def SPRWriteResGroup349 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 1, 2]; + let Latency = 20; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup349], (instregex "^VCVT(U?)QQ2PHZrm(bk|kz)$", + "^VCVT(U?)QQ2PHZrm(k|bkz)$")>; + +def SPRWriteResGroup350 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup350], (instregex "^VCVT(U?)QQ2PHZrr(b?)$")>; + +def SPRWriteResGroup351 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup351], (instregex "^VCVT(U?)QQ2PHZrr(bk|kz)$", + "^VCVT(U?)QQ2PHZrr(k|bkz)$")>; + +def SPRWriteResGroup352 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 2, 1, 1, 1]; + let Latency = 18; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup352, ReadAfterVecLd], (instregex "^VCVTSD2SHZrm((_Int)?)$")>; + +def SPRWriteResGroup353 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 2, 1, 1, 1]; + let Latency = 21; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup353, ReadAfterVecLd], (instregex "^VCVTSD2SHZrm_Intk(z?)$")>; + +def SPRWriteResGroup354 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 11; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup354], (instregex "^VCVTSD2SHZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup354], (instrs VCVTSD2SHZrr)>; + +def SPRWriteResGroup355 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 14; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup355], (instregex "^VCVTSD2SHZrr(b?)_Intk(z?)$")>; + +def SPRWriteResGroup356 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 18; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup356, ReadAfterVecLd], (instregex "^VCVTSH2SDZrm((_Int)?)$")>; + +def SPRWriteResGroup357 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 20; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup357, ReadAfterVecLd], (instregex "^VCVTSH2SDZrm_Intk(z?)$")>; + +def SPRWriteResGroup358 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 1]; + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup358], (instregex "^VCVTSH2SDZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup358], (instrs VCVTSH2SDZrr)>; + +def SPRWriteResGroup359 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 1]; + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup359], (instregex "^VCVTSH2SDZrr(b?)_Intk(z?)$")>; + +def SPRWriteResGroup360 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort02_03_11]> { + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup360, ReadAfterVecLd], (instregex "^VCVT(T?)SH2(U?)SI((64)?)Zrm_Int$", + "^VCVTTSH2(U?)SI((64)?)Zrm$")>; + +def SPRWriteResGroup361 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05]> { + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup361], (instregex "^VCVT(T?)SH2(U?)SI((64)?)Zrr(b?)_Int$", + "^VCVTTSH2(U?)SI((64)?)Zrr$")>; + +def SPRWriteResGroup362 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 8; +} +def : InstRW<[SPRWriteResGroup362], (instregex "^VCVTSH2SSZrr(b?)_Intk(z?)$")>; + +def SPRWriteResGroup363 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup363, ReadAfterVecLd], (instregex "^VCVT(U?)SI((64)?)2SHZrm((_Int)?)$", + "^VCVTSS2SHZrm((_Int)?)$")>; + +def SPRWriteResGroup364 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup364, ReadAfterVecLd], (instregex "^VCVTSS2SHZrm_Intk(z?)$")>; + +def SPRWriteResGroup365 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup365], (instregex "^VCVTSS2SHZrr(b?)_Int$")>; +def : InstRW<[SPRWriteResGroup365], (instrs VCVTSS2SHZrr)>; + +def SPRWriteResGroup366 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup366], (instregex "^VCVTSS2SHZrr(b?)_Intk(z?)$")>; + +def SPRWriteResGroup367 : SchedWriteRes<[SPRPort05]> { + let Latency = 5; +} +def : InstRW<[SPRWriteResGroup367], (instregex "^VDBPSADBWZ(128|256)rrik(z?)$", + "^VDBPSADBWZrrik(z?)$", + "^VPACK(S|U)S(DW|WB)Z(128|256)rrk(z?)$", + "^VPACK(S|U)S(DW|WB)Zrrk(z?)$", + "^VPBROADCAST(B|W|Dr|Qr|Wr)Z((256)?)rrk(z?)$", + "^VPBROADCAST(B|D|Q|W)rZ(128|256)rr$", + "^VPBROADCASTBrZ(128|256)rrk(z?)$", + "^VPBROADCAST(B|D|Q|W)rZrr$", + "^VPBROADCASTBrZrrk(z?)$", + "^VPBROADCAST(D|Q|W)rZ128rrk(z?)$", + "^VPERMBZ(128|256)rrk(z?)$", + "^VPERMBZrrk(z?)$", + "^VPMOV(S|Z)XBWZ((256)?)rrk(z?)$", + "^VPMULTISHIFTQBZ(128|256)rrk(z?)$", + "^VPMULTISHIFTQBZrrk(z?)$", + "^VPOPCNT(B|W)Z(128|256)rrk(z?)$", + "^VPOPCNT(B|W)Zrrk(z?)$")>; + +def SPRWriteResGroup368 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 36; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup368, ReadAfterVecXLd], (instregex "^VDIVPHZ128rm(b?)$")>; + +def SPRWriteResGroup369 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 38; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup369, ReadAfterVecXLd], (instregex "^VDIVPHZ128rm(bk|kz)$", + "^VDIVPHZ128rm(k|bkz)$")>; + +def SPRWriteResGroup370 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let ResourceCycles = [2, 1]; + let Latency = 31; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup370], (instregex "^VDIVPHZ(128|256)rr$")>; + +def SPRWriteResGroup371 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let ResourceCycles = [2, 1]; + let Latency = 33; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup371], (instregex "^VDIVPHZ(128|256)rrk$", + "^VSQRTPHZ(128|256)r$")>; +def : InstRW<[SPRWriteResGroup371], (instrs VDIVPHZ128rrkz)>; + +def SPRWriteResGroup372 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 37; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup372, ReadAfterVecYLd], (instregex "^VDIVPHZ256rm(b?)$")>; + +def SPRWriteResGroup373 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 39; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup373, ReadAfterVecYLd], (instregex "^VDIVPHZ256rm(bk|kz)$", + "^VDIVPHZ256rm(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup373, ReadAfterVecXLd], (instregex "^VSQRTPHZ128m(b?)$")>; + +def SPRWriteResGroup374 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let ResourceCycles = [2, 1]; + let Latency = 11; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup374], (instrs VDIVPHZ256rrkz)>; + +def SPRWriteResGroup375 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [4, 2, 1, 1, 1]; + let Latency = 49; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup375, ReadAfterVecYLd], (instregex "^VDIVPHZrm(b?)$")>; + +def SPRWriteResGroup376 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [4, 2, 1, 1, 1]; + let Latency = 51; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup376, ReadAfterVecYLd], (instregex "^VDIVPHZrm(bk|kz)$", + "^VDIVPHZrm(k|bkz)$")>; + +def SPRWriteResGroup377 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [4, 1, 1]; + let Latency = 41; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup377], (instregex "^VDIVPHZrr(b?)$")>; + +def SPRWriteResGroup378 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [4, 1, 1]; + let Latency = 43; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup378], (instregex "^VDIVPHZrr(bk|kz)$", + "^VDIVPHZrr(k|bkz)$")>; + +def SPRWriteResGroup379 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let ResourceCycles = [2, 1]; + let Latency = 17; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup379], (instrs VDIVPSZrr)>; + +def SPRWriteResGroup380 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 21; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup380, ReadAfterVecLd], (instregex "^VDIVSHZrm_Int((k|kz)?)$")>; +def : InstRW<[SPRWriteResGroup380, ReadAfterVecLd], (instrs VDIVSHZrm)>; + +def SPRWriteResGroup381 : SchedWriteRes<[SPRPort00]> { + let Latency = 14; +} +def : InstRW<[SPRWriteResGroup381], (instrs VDIVSHZrr_Int, + VSQRTSHZr_Int)>; + +def SPRWriteResGroup382 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 15; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup382, ReadAfterVecXLd], (instregex "^VDPBF16PSZ128m((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup382, ReadAfterVecXLd], (instrs VDPBF16PSZ128mbkz)>; + +def SPRWriteResGroup383 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let ResourceCycles = [2, 2]; + let Latency = 8; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup383], (instregex "^VDPBF16PSZ(128|256)r((k|kz)?)$")>; + +def SPRWriteResGroup384 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [2, 1, 2]; + let Latency = 16; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup384, ReadAfterVecYLd], (instregex "^VDPBF16PSZ256m((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup384, ReadAfterVecYLd], (instrs VDPBF16PSZ256mbkz)>; + +def SPRWriteResGroup385 : SchedWriteRes<[SPRPort00, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [6, 7, 18]; + let Latency = 81; + let NumMicroOps = 31; +} +def : InstRW<[SPRWriteResGroup385], (instrs VERRm)>; + +def SPRWriteResGroup386 : SchedWriteRes<[SPRPort00, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [6, 7, 17]; + let Latency = 74; + let NumMicroOps = 30; +} +def : InstRW<[SPRWriteResGroup386], (instrs VERRr)>; + +def SPRWriteResGroup387 : SchedWriteRes<[SPRPort00, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [5, 8, 21]; + let Latency = 81; + let NumMicroOps = 34; +} +def : InstRW<[SPRWriteResGroup387], (instrs VERWm)>; + +def SPRWriteResGroup388 : SchedWriteRes<[SPRPort00, SPRPort01, SPRPort02_03_11]> { + let ResourceCycles = [5, 8, 20]; + let Latency = 74; + let NumMicroOps = 33; +} +def : InstRW<[SPRWriteResGroup388], (instrs VERWr)>; + +def SPRWriteResGroup389 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup389, ReadAfterVecYLd], (instregex "^VEXPANDP(D|S)Z128rm((k|kz)?)$", + "^VPEXPAND(B|D|Q|W)Z128rm$", + "^VPEXPAND(D|Q)Z128rmk(z?)$")>; + +def SPRWriteResGroup390 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup390], (instregex "^VF(C?)MADDCPHZ(128|256)m(b?)$", + "^VROUNDP(D|S)Ym$")>; +def : InstRW<[SPRWriteResGroup390, ReadAfterVecXLd], (instregex "^VF(C?)MADDCSHZm$", + "^VF(C?)MULCPHZ128rm(b?)$", + "^VF(C?)MULCSHZrm$", + "^VRNDSCALEPHZ128rm(b?)i$", + "^VRNDSCALESHZm((_Int)?)$", + "^VSCALEFPHZ128rm(b?)$")>; +def : InstRW<[SPRWriteResGroup390, ReadAfterVecYLd], (instregex "^VF(C?)MULCPHZ256rm(b?)$", + "^VRNDSCALEP(D|H|S)Z256rm(b?)i$", + "^VRNDSCALEP(D|S)Z256rm(b?)ik(z?)$", + "^VSCALEFPHZ256rm(b?)$")>; +def : InstRW<[SPRWriteResGroup390, ReadAfterVecLd], (instrs VSCALEFSHZrm)>; + +def SPRWriteResGroup391 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 21; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup391], (instregex "^VF(C?)MADDCPHZ(128|256)m(bk|kz)$", + "^VF(C?)MADDCPHZ(128|256)m(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup391, ReadAfterVecXLd], (instregex "^VF(C?)MADDCSHZmk(z?)$", + "^VF(C?)MULCPHZ128rm(bk|kz)$", + "^VF(C?)MULCPHZ128rm(k|bkz)$", + "^VF(C?)MULCSHZrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup391, ReadAfterVecYLd], (instregex "^VF(C?)MULCPHZ256rm(bk|kz)$", + "^VF(C?)MULCPHZ256rm(k|bkz)$")>; + +def SPRWriteResGroup392 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [2]; + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup392], (instregex "^VF(C?)MADDCPHZ(128|256)r$", + "^VF(C?)MADDCSHZr(b?)$", + "^VF(C?)MULCPHZ(128|256)rr$", + "^VF(C?)MULCSHZrr(b?)$", + "^VRNDSCALEPHZ(128|256)rri$", + "^VRNDSCALESHZr(b?)_Int$", + "^VSCALEFPHZ(128|256)rr$")>; +def : InstRW<[SPRWriteResGroup392], (instrs VRNDSCALESHZr, + VSCALEFSHZrr, + VSCALEFSHZrrb_Int)>; + +def SPRWriteResGroup393 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [2]; + let Latency = 15; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup393], (instregex "^VF(C?)MADDCPHZ(128|256)rk(z?)$", + "^VF(C?)MADDCSHZr(bk|kz)$", + "^VF(C?)MADDCSHZr(k|bkz)$", + "^VF(C?)MULCPHZ(128|256)rrk(z?)$", + "^VF(C?)MULCSHZrr(bk|kz)$", + "^VF(C?)MULCSHZrr(k|bkz)$")>; + +def SPRWriteResGroup394 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup394], (instregex "^VF(C?)MADDCPHZm(b?)$")>; +def : InstRW<[SPRWriteResGroup394, ReadAfterVecYLd], (instregex "^VF(C?)MULCPHZrm(b?)$", + "^VRNDSCALEP(D|H|S)Zrm(b?)i$", + "^VRNDSCALEP(D|S)Zrm(b?)ik(z?)$", + "^VSCALEFPHZrm(b?)$")>; + +def SPRWriteResGroup395 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 21; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup395], (instregex "^VF(C?)MADDCPHZm(bk|kz)$", + "^VF(C?)MADDCPHZm(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup395, ReadAfterVecYLd], (instregex "^VF(C?)MULCPHZrm(bk|kz)$", + "^VF(C?)MULCPHZrm(k|bkz)$")>; + +def SPRWriteResGroup396 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [2]; + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup396], (instregex "^VF(C?)MADDCPHZr(b?)$", + "^VF(C?)MULCPHZrr(b?)$", + "^VRNDSCALEPHZrri(b?)$", + "^VSCALEFPHZrr(b?)$")>; + +def SPRWriteResGroup397 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [2]; + let Latency = 15; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup397], (instregex "^VF(C?)MADDCPHZr(bk|kz)$", + "^VF(C?)MADDCPHZr(k|bkz)$", + "^VF(C?)MULCPHZrr(bk|kz)$", + "^VF(C?)MULCPHZrr(k|bkz)$")>; + +def SPRWriteResGroup398 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 1, 2, 4]; + let Latency = 29; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup398, WriteVecMaskedGatherWriteback], (instregex "^VGATHER(D|Q)PDYrm$", + "^VPGATHER(D|Q)QYrm$")>; +def : InstRW<[SPRWriteResGroup398, WriteVecMaskedGatherWriteback], (instrs VGATHERQPSYrm, + VPGATHERQDYrm)>; + +def SPRWriteResGroup399 : SchedWriteRes<[SPRPort00, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 20; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup399, WriteVecMaskedGatherWriteback], (instregex "^VGATHER(D|Q)PDZ128rm$", + "^VPGATHER(D|Q)QZ128rm$")>; +def : InstRW<[SPRWriteResGroup399, WriteVecMaskedGatherWriteback], (instrs VGATHERQPSZ128rm, + VPGATHERQDZ128rm)>; + +def SPRWriteResGroup400 : SchedWriteRes<[SPRPort00, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 2, 4]; + let Latency = 28; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup400, WriteVecMaskedGatherWriteback], (instregex "^VGATHER(D|Q)PDZ256rm$", + "^VPGATHER(D|Q)QZ256rm$")>; +def : InstRW<[SPRWriteResGroup400, WriteVecMaskedGatherWriteback], (instrs VGATHERQPSZ256rm, + VPGATHERQDZ256rm)>; + +def SPRWriteResGroup401 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 8, 2]; + let Latency = 28; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup401, WriteVecMaskedGatherWriteback], (instregex "^VGATHER(D|Q)PDZrm$", + "^VPGATHER(D|Q)QZrm$")>; +def : InstRW<[SPRWriteResGroup401, WriteVecMaskedGatherWriteback], (instrs VGATHERQPSZrm, + VPGATHERQDZrm)>; + +def SPRWriteResGroup402 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 1, 1, 2]; + let Latency = 20; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup402, WriteVecMaskedGatherWriteback], (instregex "^VGATHER(D|Q)PDrm$", + "^VPGATHER(D|Q)Qrm$")>; +def : InstRW<[SPRWriteResGroup402, WriteVecMaskedGatherWriteback], (instrs VGATHERQPSrm, + VPGATHERQDrm)>; + +def SPRWriteResGroup403 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 1, 2, 8]; + let Latency = 30; + let NumMicroOps = 12; +} +def : InstRW<[SPRWriteResGroup403, WriteVecMaskedGatherWriteback], (instrs VGATHERDPSYrm, + VPGATHERDDYrm)>; + +def SPRWriteResGroup404 : SchedWriteRes<[SPRPort00, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 2, 4]; + let Latency = 27; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup404, WriteVecMaskedGatherWriteback], (instrs VGATHERDPSZ128rm, + VPGATHERDDZ128rm)>; + +def SPRWriteResGroup405 : SchedWriteRes<[SPRPort00, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 2, 8]; + let Latency = 29; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup405, WriteVecMaskedGatherWriteback], (instrs VGATHERDPSZ256rm, + VPGATHERDDZ256rm)>; + +def SPRWriteResGroup406 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 16, 2]; + let Latency = 30; + let NumMicroOps = 19; +} +def : InstRW<[SPRWriteResGroup406, WriteVecMaskedGatherWriteback], (instrs VGATHERDPSZrm, + VPGATHERDDZrm)>; + +def SPRWriteResGroup407 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 1, 2, 4]; + let Latency = 28; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup407, WriteVecMaskedGatherWriteback], (instrs VGATHERDPSrm, + VPGATHERDDrm)>; + +def SPRWriteResGroup408 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 15; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup408, ReadAfterVecXLd], (instregex "^VGF2P8AFFINE((INV)?)QBZ128rm(b?)ik(z?)$", + "^VGF2P8MULBZ128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup408, ReadAfterVecYLd], (instregex "^VGF2P8AFFINE((INV)?)QBZ256rm(b?)ik(z?)$", + "^VGF2P8MULBZ256rmk(z?)$")>; + +def SPRWriteResGroup409 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 9; +} +def : InstRW<[SPRWriteResGroup409], (instregex "^VGF2P8AFFINE((INV)?)QBZ(128|256)rrik$", + "^VGF2P8MULBZ(128|256)rrk$")>; + +def SPRWriteResGroup410 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 10; +} +def : InstRW<[SPRWriteResGroup410], (instregex "^VGF2P8AFFINE((INV)?)QBZ(128|256)rrikz$", + "^VGF2P8MULBZ(128|256)rrkz$")>; + +def SPRWriteResGroup411 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 15; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup411, ReadAfterVecYLd], (instregex "^VGF2P8AFFINE((INV)?)QBZrm(b?)ik(z?)$", + "^VGF2P8MULBZrmk(z?)$")>; + +def SPRWriteResGroup412 : SchedWriteRes<[SPRPort00]> { + let Latency = 9; +} +def : InstRW<[SPRWriteResGroup412], (instregex "^VGF2P8AFFINE((INV)?)QBZrrik$")>; +def : InstRW<[SPRWriteResGroup412], (instrs VGF2P8MULBZrrk)>; + +def SPRWriteResGroup413 : SchedWriteRes<[SPRPort00]> { + let Latency = 10; +} +def : InstRW<[SPRWriteResGroup413], (instregex "^VGF2P8AFFINE((INV)?)QBZrrikz$")>; +def : InstRW<[SPRWriteResGroup413], (instrs VGF2P8MULBZrrkz)>; + +def SPRWriteResGroup414 : SchedWriteRes<[SPRPort01_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 5; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup414], (instregex "^VH(ADD|SUB)P(D|S)rr$")>; + +def SPRWriteResGroup415 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort02_03_11]> { + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup415], (instrs VLDMXCSR)>; + +def SPRWriteResGroup416 : SchedWriteRes<[SPRPort01, SPRPort01_05, SPRPort02_03, SPRPort02_03_11, SPRPort04, SPRPort04_09, SPRPort05, SPRPort06]> { + let ResourceCycles = [1, 1, 1, 8, 1, 1, 2, 3]; + let Latency = 40; + let NumMicroOps = 18; +} +def : InstRW<[SPRWriteResGroup416], (instrs VMCLEARm)>; + +def SPRWriteResGroup417 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup417], (instregex "^VMOVDQU(8|16)Z(128|256)rmk(z?)$", + "^VMOVSHZrmk(z?)$")>; +def : InstRW<[SPRWriteResGroup417, ReadAfterVecXLd], (instregex "^VP(ADD|SUB)(B|W)Z128rmk(z?)$", + "^VPBLENDM(B|W)Z128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup417, ReadAfterVecYLd], (instregex "^VP(ADD|SUB)(B|W)Z256rmk(z?)$", + "^VPBLENDM(B|W)Z256rmk(z?)$")>; + +def SPRWriteResGroup418 : SchedWriteRes<[SPRPort00_01_05]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup418], (instregex "^VMOVDQU(8|16)Z(128|256)rrk(z?)((_REV)?)$", + "^VMOVSHZrrk(z?)((_REV)?)$", + "^VP(ADD|SUB)(B|W)Z(128|256)rrk(z?)$", + "^VPBLENDM(B|W)Z(128|256)rrk(z?)$", + "^VPMOVM2(B|W)Z(128|256)rr$")>; + +def SPRWriteResGroup419 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 2, 2]; + let Latency = 12; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup419], (instrs VMOVDQU8Zmrk)>; + +def SPRWriteResGroup420 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 477; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup420], (instrs VMOVNTDQZ128mr)>; + +def SPRWriteResGroup421 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 470; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup421], (instrs VMOVNTDQZ256mr, + VMOVNTPSmr)>; + +def SPRWriteResGroup422 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 473; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup422], (instregex "^VMOVNT(PD|DQZ)mr$")>; + +def SPRWriteResGroup423 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 521; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup423], (instrs VMOVNTDQmr)>; + +def SPRWriteResGroup424 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 550; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup424], (instrs VMOVNTPDZ128mr)>; + +def SPRWriteResGroup425 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 474; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup425], (instrs VMOVNTPDZ256mr)>; + +def SPRWriteResGroup426 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 464; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup426], (instrs VMOVNTPDZmr)>; + +def SPRWriteResGroup427 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 494; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup427], (instrs VMOVNTPSYmr)>; + +def SPRWriteResGroup428 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 475; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup428], (instrs VMOVNTPSZ128mr)>; + +def SPRWriteResGroup429 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 476; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup429], (instrs VMOVNTPSZ256mr)>; + +def SPRWriteResGroup430 : SchedWriteRes<[SPRPort04_09, SPRPort07_08]> { + let Latency = 471; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup430], (instrs VMOVNTPSZmr)>; + +def SPRWriteResGroup431 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [3, 1, 8]; + let Latency = 10; + let NumMicroOps = 12; +} +def : InstRW<[SPRWriteResGroup431, ReadAfterVecXLd], (instregex "^VP2INTERSECTDZ128rm(b?)$")>; +def : InstRW<[SPRWriteResGroup431, ReadAfterVecYLd], (instregex "^VP2INTERSECTQZ256rm(b?)$")>; + +def SPRWriteResGroup432 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [4, 8]; + let Latency = 10; + let NumMicroOps = 12; +} +def : InstRW<[SPRWriteResGroup432], (instrs VP2INTERSECTDZ128rr, + VP2INTERSECTQZ256rr)>; + +def SPRWriteResGroup433 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 8, 7, 2, 1, 11]; + let Latency = 27; + let NumMicroOps = 30; +} +def : InstRW<[SPRWriteResGroup433, ReadAfterVecYLd], (instregex "^VP2INTERSECTDZ256rm(b?)$")>; + +def SPRWriteResGroup434 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05, SPRPort01_05, SPRPort05]> { + let ResourceCycles = [1, 8, 8, 2, 11]; + let Latency = 27; + let NumMicroOps = 30; +} +def : InstRW<[SPRWriteResGroup434], (instrs VP2INTERSECTDZ256rr)>; + +def SPRWriteResGroup435 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [13, 9, 1, 23]; + let Latency = 40; + let NumMicroOps = 46; +} +def : InstRW<[SPRWriteResGroup435, ReadAfterVecYLd], (instregex "^VP2INTERSECTDZrm(b?)$")>; + +def SPRWriteResGroup436 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [13, 10, 23]; + let Latency = 40; + let NumMicroOps = 46; +} +def : InstRW<[SPRWriteResGroup436], (instrs VP2INTERSECTDZrr)>; + +def SPRWriteResGroup437 : SchedWriteRes<[SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 4]; + let Latency = 6; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup437, ReadAfterVecXLd], (instregex "^VP2INTERSECTQZ128rm(b?)$")>; + +def SPRWriteResGroup438 : SchedWriteRes<[SPRPort05]> { + let ResourceCycles = [4]; + let Latency = 6; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup438], (instrs VP2INTERSECTQZ128rr)>; + +def SPRWriteResGroup439 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [8, 7, 1, 14]; + let Latency = 29; + let NumMicroOps = 30; +} +def : InstRW<[SPRWriteResGroup439, ReadAfterVecYLd], (instregex "^VP2INTERSECTQZrm(b?)$")>; + +def SPRWriteResGroup440 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [8, 8, 14]; + let Latency = 30; + let NumMicroOps = 30; +} +def : InstRW<[SPRWriteResGroup440], (instrs VP2INTERSECTQZrr)>; + +def SPRWriteResGroup441 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 3; +} +def : InstRW<[SPRWriteResGroup441], (instregex "^VP(A|SU)BS(B|W)Z(128|256)rrk(z?)$", + "^VPADD(U?)S(B|W)Z(128|256)rrk(z?)$", + "^VPAVG(B|W)Z(128|256)rrk(z?)$", + "^VPM(AX|IN)(SB|UW)Z(128|256)rrk(z?)$", + "^VPM(AX|IN)(SW|UB)Z(128|256)rrk(z?)$", + "^VPSH(L|R)DVWZ(128|256)rk(z?)$", + "^VPS(L|R)LVWZ(128|256)rrk(z?)$", + "^VPS(L|R)LWZ(128|256)rik(z?)$", + "^VPSRAVWZ(128|256)rrk(z?)$", + "^VPSRAWZ(128|256)rik(z?)$", + "^VPSUBUS(B|W)Z(128|256)rrk(z?)$")>; + +def SPRWriteResGroup442 : SchedWriteRes<[SPRPort01_05, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup442, ReadAfterVecYLd], (instregex "^VSHUFP(D|S)Yrmi$", + "^VSHUFP(D|S)Z256rm(bi|ik)$", + "^VSHUFP(D|S)Z256rmbik(z?)$", + "^VSHUFP(D|S)Z256rmi((kz)?)$")>; +def : InstRW<[SPRWriteResGroup442, ReadAfterVecYLd], (instrs VPBLENDWYrmi)>; + +def SPRWriteResGroup443 : SchedWriteRes<[SPRPort00, SPRPort05]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup443], (instregex "^VPBROADCASTM(B2Q|W2D)Z(128|256)rr$", + "^VPBROADCASTM(B2Q|W2D)Zrr$", + "^VP(ERM|SRA)WZrrk(z?)$", + "^VPSHUFBITQMBZ(128|256)rr$", + "^VPS(L|R)LWZrrk(z?)$")>; +def : InstRW<[SPRWriteResGroup443], (instrs VPSHUFBITQMBZrr)>; + +def SPRWriteResGroup444 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 1, 1, 2, 1]; + let Latency = 12; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup444], (instregex "^VPCOMPRESS(B|W)Z(128|256)mr$")>; +def : InstRW<[SPRWriteResGroup444], (instrs VPCOMPRESSWZmr)>; + +def SPRWriteResGroup445 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 1, 1, 2, 1]; + let Latency = 14; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup445], (instregex "^VPCOMPRESS(B|W)Z(128|256)mrk$")>; +def : InstRW<[SPRWriteResGroup445], (instrs VPCOMPRESSWZmrk)>; + +def SPRWriteResGroup446 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 1, 2, 2, 2]; + let Latency = 12; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup446], (instrs VPCOMPRESSBZmr)>; + +def SPRWriteResGroup447 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 1, 2, 2, 2]; + let Latency = 14; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup447], (instrs VPCOMPRESSBZmrk)>; + +def SPRWriteResGroup448 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [5, 4, 1, 5]; + let Latency = 17; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup448], (instregex "^VPCONFLICTDZ128rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup448], (instrs VPCONFLICTDZ128rmbkz)>; + +def SPRWriteResGroup449 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [5, 5, 5]; + let Latency = 12; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup449], (instregex "^VPCONFLICTDZ128rr((k|kz)?)$")>; + +def SPRWriteResGroup450 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 5, 1, 1, 9]; + let Latency = 24; + let NumMicroOps = 23; +} +def : InstRW<[SPRWriteResGroup450], (instregex "^VPCONFLICTDZ256rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup450], (instrs VPCONFLICTDZ256rmbkz)>; + +def SPRWriteResGroup451 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [7, 6, 1, 9]; + let Latency = 17; + let NumMicroOps = 23; +} +def : InstRW<[SPRWriteResGroup451], (instregex "^VPCONFLICTDZ256rr((k|kz)?)$")>; + +def SPRWriteResGroup452 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [11, 8, 1, 17]; + let Latency = 33; + let NumMicroOps = 37; +} +def : InstRW<[SPRWriteResGroup452], (instregex "^VPCONFLICTDZrm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup452], (instrs VPCONFLICTDZrmbkz)>; + +def SPRWriteResGroup453 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [11, 9, 17]; + let Latency = 26; + let NumMicroOps = 37; +} +def : InstRW<[SPRWriteResGroup453], (instregex "^VPCONFLICTDZrr((kz)?)$")>; + +def SPRWriteResGroup454 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [11, 9, 17]; + let Latency = 25; + let NumMicroOps = 37; +} +def : InstRW<[SPRWriteResGroup454], (instrs VPCONFLICTDZrrk)>; + +def SPRWriteResGroup455 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 11; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup455], (instregex "^VPCONFLICTQZ128rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup455], (instrs VPCONFLICTQZ128rmbkz)>; +def : InstRW<[SPRWriteResGroup455, ReadAfterVecYLd], (instregex "^VPERM(I|T)2B128rm$")>; + +def SPRWriteResGroup456 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 4; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup456], (instregex "^VPCONFLICTQZ128rr((k|kz)?)$")>; + +def SPRWriteResGroup457 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [5, 4, 1, 5]; + let Latency = 20; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup457], (instregex "^VPCONFLICTQZ256rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup457], (instrs VPCONFLICTQZ256rmbkz)>; + +def SPRWriteResGroup458 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [5, 5, 5]; + let Latency = 13; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup458], (instregex "^VPCONFLICTQZ256rr((k|kz)?)$")>; + +def SPRWriteResGroup459 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [7, 5, 1, 9]; + let Latency = 23; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup459], (instregex "^VPCONFLICTQZrm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup459], (instrs VPCONFLICTQZrmbkz)>; + +def SPRWriteResGroup460 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [7, 6, 9]; + let Latency = 17; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup460], (instregex "^VPCONFLICTQZrr((kz)?)$")>; + +def SPRWriteResGroup461 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort05]> { + let ResourceCycles = [7, 6, 9]; + let Latency = 16; + let NumMicroOps = 22; +} +def : InstRW<[SPRWriteResGroup461], (instrs VPCONFLICTQZrrk)>; + +def SPRWriteResGroup462 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 13; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup462, ReadAfterVecYLd], (instregex "^VPERM(I|T)2B128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup462, ReadAfterVecYLd], (instrs VPERMT2W128rm)>; + +def SPRWriteResGroup463 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 5; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup463], (instregex "^VPERM(I|T)2B(128|256)rr$")>; + +def SPRWriteResGroup464 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup464], (instregex "^VPERM(I|T)2B(128|256)rrk(z?)$", + "^VPERM(I|T)2W(128|256)rr$")>; + +def SPRWriteResGroup465 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup465, ReadAfterVecYLd], (instregex "^VPERM(I|T)2B256rm$")>; + +def SPRWriteResGroup466 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 14; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup466, ReadAfterVecYLd], (instregex "^VPERM(I|T)2B256rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup466, ReadAfterVecYLd], (instrs VPERMI2W128rm, + VPERMT2W256rm)>; + +def SPRWriteResGroup467 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup467, ReadAfterVecYLd], (instregex "^VPERM(I|T)2Brm$")>; + +def SPRWriteResGroup468 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 14; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup468, ReadAfterVecYLd], (instregex "^VPERM(I|T)2Brmk(z?)$")>; +def : InstRW<[SPRWriteResGroup468, ReadAfterVecYLd], (instrs VPERMT2Wrm)>; + +def SPRWriteResGroup469 : SchedWriteRes<[SPRPort00_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 5; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup469], (instregex "^VPERM(I|T)2Brr$")>; + +def SPRWriteResGroup470 : SchedWriteRes<[SPRPort00_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup470], (instregex "^VPERM(I|T)2Brrk(z?)$", + "^VPERM(I|T)2Wrr$")>; + +def SPRWriteResGroup471 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup471, ReadAfterVecYLd], (instregex "^VPERMI2W128rmk(z?)$", + "^VPERMT2W256rmk(z?)$")>; + +def SPRWriteResGroup472 : SchedWriteRes<[SPRPort00_01_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup472], (instregex "^VPERM(I|T)2W(128|256)rrk(z?)$")>; + +def SPRWriteResGroup473 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup473, ReadAfterVecYLd], (instregex "^VPERMT2W128rmk(z?)$")>; +def : InstRW<[SPRWriteResGroup473, ReadAfterVecYLd], (instrs VPERMI2W256rm)>; + +def SPRWriteResGroup474 : SchedWriteRes<[SPRPort00_01_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 17; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup474, ReadAfterVecYLd], (instregex "^VPERMI2W256rmk(z?)$")>; + +def SPRWriteResGroup475 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup475, ReadAfterVecYLd], (instrs VPERMI2Wrm)>; + +def SPRWriteResGroup476 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 17; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup476, ReadAfterVecYLd], (instregex "^VPERMI2Wrmk(z?)$")>; + +def SPRWriteResGroup477 : SchedWriteRes<[SPRPort00_05, SPRPort05]> { + let ResourceCycles = [1, 2]; + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup477], (instregex "^VPERM(I|T)2Wrrk(z?)$")>; + +def SPRWriteResGroup478 : SchedWriteRes<[SPRPort00_05, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [1, 1, 2]; + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup478, ReadAfterVecYLd], (instregex "^VPERMT2Wrmk(z?)$")>; + +def SPRWriteResGroup479 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup479, ReadAfterVecYLd], (instrs VPERMWZ128rm)>; + +def SPRWriteResGroup480 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup480, ReadAfterVecYLd], (instregex "^VPERMWZ(128|256)rmk(z?)$")>; + +def SPRWriteResGroup481 : SchedWriteRes<[SPRPort00_01, SPRPort05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup481], (instregex "^VPERMWZ(128|256)rr$")>; + +def SPRWriteResGroup482 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11, SPRPort05]> { + let Latency = 11; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup482, ReadAfterVecYLd], (instrs VPERMWZ256rm)>; + +def SPRWriteResGroup483 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 11; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup483, ReadAfterVecYLd], (instrs VPERMWZrm)>; + +def SPRWriteResGroup484 : SchedWriteRes<[SPRPort05]> { + let ResourceCycles = [2]; + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup484], (instregex "^VPEXPAND(B|W)Z(128|256)rrk(z?)$", + "^VPEXPAND(B|W)Zrrk(z?)$")>; + +def SPRWriteResGroup485 : SchedWriteRes<[SPRPort00_01, SPRPort01_05, SPRPort02_03_11]> { + let ResourceCycles = [1, 2, 1]; + let Latency = 10; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup485, ReadAfterVecYLd], (instregex "^VPH(ADD|SUB)SWYrm$")>; + +def SPRWriteResGroup486 : SchedWriteRes<[SPRPort00_01]> { + let Latency = 7; +} +def : InstRW<[SPRWriteResGroup486], (instregex "^VPMADDUBSWZ(128|256)rrk(z?)$", + "^VPMULH((U|RS)?)WZ(128|256)rrk(z?)$", + "^VPMULLWZ(128|256)rrk(z?)$")>; + +def SPRWriteResGroup487 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 14; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup487, ReadAfterVecYLd], (instregex "^VPMADDUBSWZrmk(z?)$", + "^VPMULH((U|RS)?)WZrmk(z?)$", + "^VPMULLWZrmk(z?)$")>; + +def SPRWriteResGroup488 : SchedWriteRes<[SPRPort00]> { + let Latency = 7; +} +def : InstRW<[SPRWriteResGroup488], (instregex "^VPMADDUBSWZrrk(z?)$", + "^VPMULH((U|RS)?)WZrrk(z?)$", + "^VPMULLWZrrk(z?)$")>; + +def SPRWriteResGroup489 : SchedWriteRes<[SPRPort01_05, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 12; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup489], (instregex "^VPMOV((US)?)DBZ(128|256)mr$", + "^VPMOV((S|US)?)(D|Q)WZ(128|256)mr$", + "^VPMOV(Q|W|SD|SW)BZ256mr$", + "^VPMOV(W|SD)BZ128mr$", + "^VPMOV(U?)SQBZ256mr$", + "^VPMOV(U?)SQDZ(128|256)mr$", + "^VPMOV(U?)SWBZ128mr$")>; +def : InstRW<[SPRWriteResGroup489], (instrs VPMOVUSWBZ256mr)>; + +def SPRWriteResGroup490 : SchedWriteRes<[SPRPort01_05, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 13; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup490], (instregex "^VPMOV(D|Q|W|SQ|SW)BZ128mrk$", + "^VPMOV((S|US)?)(D|Q)WZ128mrk$", + "^VPMOV(U?)S(DB|QD)Z128mrk$", + "^VPMOVUS(Q|W)BZ128mrk$")>; + +def SPRWriteResGroup491 : SchedWriteRes<[SPRPort01_05, SPRPort05]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup491], (instregex "^VPMOV(D|Q|W|SQ|SW)BZ128rr$", + "^VPMOV((S|US)?)(D|Q)WZ128rr$", + "^VPMOV(U?)S(DB|QD)Z128rr$", + "^VPMOV(U?)SQDZ128rrk(z?)$", + "^VPMOVUS(Q|W)BZ128rr$")>; + +def SPRWriteResGroup492 : SchedWriteRes<[SPRPort01_05, SPRPort05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup492], (instregex "^VPMOV(D|Q|W|SQ|SW)BZ128rrk(z?)$", + "^VPMOV(D|Q|W|SQ|SW)BZ256rr$", + "^VPMOV((S|US)?)(D|Q)WZ128rrk(z?)$", + "^VPMOV((S|US)?)(D|Q)WZ256rr$", + "^VPMOV(U?)SDBZ128rrk(z?)$", + "^VPMOV(U?)S(DB|QD)Z256rr$", + "^VPMOV(U?)SQDZ256rrk(z?)$", + "^VPMOVUS(Q|W)BZ128rrk(z?)$", + "^VPMOVUS(Q|W)BZ256rr$")>; + +def SPRWriteResGroup493 : SchedWriteRes<[SPRPort01_05, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 15; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup493], (instregex "^VPMOV(D|Q|W|SQ|SW)BZ256mrk$", + "^VPMOV((S|US)?)(D|Q)WZ256mrk$", + "^VPMOV(U?)S(DB|QD)Z256mrk$", + "^VPMOVUS(Q|W)BZ256mrk$")>; + +def SPRWriteResGroup494 : SchedWriteRes<[SPRPort01_05, SPRPort05]> { + let Latency = 6; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup494], (instregex "^VPMOV(D|Q|W|SQ|SW)BZ256rrk(z?)$", + "^VPMOV((S|US)?)(D|Q)WZ256rrk(z?)$", + "^VPMOV(U?)SDBZ256rrk(z?)$", + "^VPMOVUS(Q|W)BZ256rrk(z?)$")>; + +def SPRWriteResGroup495 : SchedWriteRes<[SPRPort01_05, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 20; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup495], (instregex "^VPMOV((S|US)?)QBZ128mr$")>; + +def SPRWriteResGroup496 : SchedWriteRes<[SPRPort04_09, SPRPort05, SPRPort07_08]> { + let Latency = 14; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup496], (instregex "^VPMOVQDZ((256)?)mrk$")>; + +def SPRWriteResGroup497 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 23; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup497, ReadAfterVecXLd], (instregex "^VPMULLQZ128rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup497, ReadAfterVecXLd], (instrs VPMULLQZ128rmbkz)>; +def : InstRW<[SPRWriteResGroup497, ReadAfterVecYLd], (instregex "^VPMULLQZ256rm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup497, ReadAfterVecYLd], (instrs VPMULLQZ256rmbkz)>; + +def SPRWriteResGroup498 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [3]; + let Latency = 15; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup498], (instregex "^VPMULLQZ(128|256)rr((k|kz)?)$")>; + +def SPRWriteResGroup499 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 23; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup499, ReadAfterVecYLd], (instregex "^VPMULLQZrm((b|k|bk|kz)?)$")>; +def : InstRW<[SPRWriteResGroup499, ReadAfterVecYLd], (instrs VPMULLQZrmbkz)>; + +def SPRWriteResGroup500 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [3]; + let Latency = 15; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup500], (instregex "^VPMULLQZrr((k|kz)?)$")>; + +def SPRWriteResGroup501 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 1, 1, 4, 4]; + let Latency = 12; + let NumMicroOps = 11; +} +def : InstRW<[SPRWriteResGroup501], (instregex "^VPSCATTER(D|Q)QZ256mr$", + "^VSCATTER(D|Q)PDZ256mr$")>; +def : InstRW<[SPRWriteResGroup501], (instrs VPSCATTERDDZ128mr, + VPSCATTERQDZ256mr, + VSCATTERDPSZ128mr, + VSCATTERQPSZ256mr)>; + +def SPRWriteResGroup502 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 1, 1, 8, 8]; + let Latency = 12; + let NumMicroOps = 19; +} +def : InstRW<[SPRWriteResGroup502], (instrs VPSCATTERDDZ256mr, + VSCATTERDPSZ256mr)>; + +def SPRWriteResGroup503 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 16, 16]; + let Latency = 19; + let NumMicroOps = 35; +} +def : InstRW<[SPRWriteResGroup503], (instrs VPSCATTERDDZmr, + VSCATTERDPSZmr)>; + +def SPRWriteResGroup504 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [1, 1, 1, 2, 2]; + let Latency = 12; + let NumMicroOps = 7; +} +def : InstRW<[SPRWriteResGroup504], (instregex "^VPSCATTER(D|Q)QZ128mr$", + "^VSCATTER(D|Q)PDZ128mr$")>; +def : InstRW<[SPRWriteResGroup504], (instrs VPSCATTERQDZ128mr, + VSCATTERQPSZ128mr)>; + +def SPRWriteResGroup505 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06_10, SPRPort04_09, SPRPort07_08]> { + let ResourceCycles = [2, 1, 8, 8]; + let Latency = 12; + let NumMicroOps = 19; +} +def : InstRW<[SPRWriteResGroup505], (instregex "^VPSCATTER(D|Q)QZmr$", + "^VSCATTER(D|Q)PDZmr$")>; +def : InstRW<[SPRWriteResGroup505], (instrs VPSCATTERQDZmr, + VSCATTERQPSZmr)>; + +def SPRWriteResGroup506 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup506, ReadAfterVecXLd], (instregex "^VPSH(L|R)D(D|Q)Z128rmbi$", + "^VPSH(L|R)D(D|Q|W)Z128rmi$", + "^VPSH(L|R)DV(D|Q|W)Z128m$", + "^VPSH(L|R)DV(D|Q)Z128m(b|k|kz)$", + "^VPSH(L|R)DV(D|Q)Z128mbk(z?)$")>; + +def SPRWriteResGroup507 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup507, ReadAfterVecXLd], (instregex "^VPSH(L|R)D(D|Q)Z128rm(b?)ik(z?)$")>; + +def SPRWriteResGroup508 : SchedWriteRes<[SPRPort00_01]>; +def : InstRW<[SPRWriteResGroup508], (instregex "^VPSH(L|R)D(D|Q|W)Z(128|256)rri$", + "^VPSH(L|R)DV(D|Q|W)Z(128|256)r$", + "^VPSH(L|R)DV(D|Q)Z(128|256)rk(z?)$")>; + +def SPRWriteResGroup509 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup509], (instregex "^VPSH(L|R)D(D|Q)Z(128|256)rrik(z?)$")>; + +def SPRWriteResGroup510 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup510, ReadAfterVecYLd], (instregex "^VPSH(L|R)D(D|Q)Z256rmbi$", + "^VPSH(L|R)D(D|Q|W)Z256rmi$", + "^VPSH(L|R)DV(D|Q|W)Z256m$", + "^VPSH(L|R)DV(D|Q)Z256m(b|k|kz)$", + "^VPSH(L|R)DV(D|Q)Z256mbk(z?)$")>; + +def SPRWriteResGroup511 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup511, ReadAfterVecYLd], (instregex "^VPSH(L|R)D(D|Q)Z256rm(b?)ik(z?)$")>; + +def SPRWriteResGroup512 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 9; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup512, ReadAfterVecYLd], (instregex "^VPSH(L|R)D(D|Q)Zrmbi$", + "^VPSH(L|R)D(D|Q|W)Zrmi$", + "^VPSH(L|R)DV(D|Q|W)Zm$", + "^VPSH(L|R)DV(D|Q)Zm(b|k|kz)$", + "^VPSH(L|R)DV(D|Q)Zmbk(z?)$")>; + +def SPRWriteResGroup513 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let Latency = 10; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup513, ReadAfterVecYLd], (instregex "^VPSH(L|R)D(D|Q)Zrm(b?)ik(z?)$")>; + +def SPRWriteResGroup514 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup514], (instregex "^VPSH(L|R)D(D|Q)Zrrik(z?)$")>; + +def SPRWriteResGroup515 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 11; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup515, ReadAfterVecXLd], (instregex "^VPSH(L|R)DWZ128rmik(z?)$")>; + +def SPRWriteResGroup516 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup516], (instregex "^VPSH(L|R)DWZ(128|256)rrik(z?)$")>; + +def SPRWriteResGroup517 : SchedWriteRes<[SPRPort00_01, SPRPort00_01_05, SPRPort02_03_11]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup517, ReadAfterVecYLd], (instregex "^VPSH(L|R)DWZ256rmik(z?)$")>; + +def SPRWriteResGroup518 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup518, ReadAfterVecYLd], (instregex "^VPSH(L|R)DWZrmik(z?)$")>; + +def SPRWriteResGroup519 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup519], (instregex "^VPSH(L|R)DWZrrik(z?)$")>; + +def SPRWriteResGroup520 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 6; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup520, ReadAfterVecXLd], (instrs VPSHUFBITQMBZ128rm)>; +def : InstRW<[SPRWriteResGroup520, ReadAfterVecYLd], (instregex "^VPSHUFBITQMBZ((256)?)rm$")>; + +def SPRWriteResGroup521 : SchedWriteRes<[SPRPort00, SPRPort02_03_11, SPRPort05]> { + let Latency = 8; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup521, ReadAfterVecXLd], (instrs VPSHUFBITQMBZ128rmk)>; +def : InstRW<[SPRWriteResGroup521, ReadAfterVecYLd], (instregex "^VPSHUFBITQMBZ((256)?)rmk$")>; + +def SPRWriteResGroup522 : SchedWriteRes<[SPRPort00_01, SPRPort01_05]> { + let Latency = 4; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup522], (instregex "^VPS(L|R)LWZ128rrk(z?)$", + "^VPSRAWZ128rrk(z?)$")>; + +def SPRWriteResGroup523 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 16; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup523, ReadAfterVecYLd], (instregex "^VR(CP|SQRT)PHZm(bk|kz)$", + "^VR(CP|SQRT)PHZm(k|bkz)$")>; + +def SPRWriteResGroup524 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let ResourceCycles = [2, 1]; + let Latency = 9; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup524], (instregex "^VRCPPHZrk(z?)$")>; + +def SPRWriteResGroup525 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 20; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup525, ReadAfterVecXLd], (instregex "^VREDUCEPHZ128rm(b?)i$")>; +def : InstRW<[SPRWriteResGroup525, ReadAfterVecXLd], (instrs VREDUCESHZrmi)>; +def : InstRW<[SPRWriteResGroup525, ReadAfterVecYLd], (instregex "^VREDUCEPHZ256rm(b?)i$")>; + +def SPRWriteResGroup526 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 22; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup526, ReadAfterVecXLd], (instregex "^VREDUCEPHZ128rm(b?)ik(z?)$", + "^VREDUCESHZrmik(z?)$")>; +def : InstRW<[SPRWriteResGroup526, ReadAfterVecYLd], (instregex "^VREDUCEPHZ256rm(b?)ik(z?)$")>; + +def SPRWriteResGroup527 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [3]; + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup527], (instregex "^VREDUCEPHZ(128|256)rri$", + "^VREDUCESHZrri(b?)$")>; + +def SPRWriteResGroup528 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [3]; + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup528], (instregex "^VREDUCEPHZ(128|256)rrik(z?)$", + "^VREDUCESHZrri(bk|kz)$", + "^VREDUCESHZrri(k|bkz)$")>; + +def SPRWriteResGroup529 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 20; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup529, ReadAfterVecYLd], (instregex "^VREDUCEPHZrm(b?)i$")>; + +def SPRWriteResGroup530 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [3, 1]; + let Latency = 22; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup530, ReadAfterVecYLd], (instregex "^VREDUCEPHZrm(b?)ik(z?)$")>; + +def SPRWriteResGroup531 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [3]; + let Latency = 13; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup531], (instregex "^VREDUCEPHZrri(b?)$")>; + +def SPRWriteResGroup532 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [3]; + let Latency = 16; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup532], (instregex "^VREDUCEPHZrri(bk|kz)$", + "^VREDUCEPHZrri(k|bkz)$")>; + +def SPRWriteResGroup533 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [2]; + let Latency = 8; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup533], (instregex "^VRNDSCALEP(D|S)Zrri((b|k|bk|kz)?)$", + "^VRNDSCALEP(D|S)Zrribkz$")>; + +def SPRWriteResGroup534 : SchedWriteRes<[SPRPort00_01, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 17; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup534, ReadAfterVecXLd], (instregex "^VRNDSCALEPHZ128rm(b?)ik(z?)$", + "^VRNDSCALESHZm_Intk(z?)$", + "^VSCALEFPHZ128rm(bk|kz)$", + "^VSCALEFPHZ128rm(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup534, ReadAfterVecYLd], (instregex "^VRNDSCALEPHZ256rm(b?)ik(z?)$", + "^VSCALEFPHZ256rm(bk|kz)$", + "^VSCALEFPHZ256rm(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup534, ReadAfterVecLd], (instregex "^VSCALEFSHZrmk(z?)$")>; + +def SPRWriteResGroup535 : SchedWriteRes<[SPRPort00_01]> { + let ResourceCycles = [2]; + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup535], (instregex "^VRNDSCALEPHZ(128|256)rrik(z?)$", + "^VRNDSCALESHZr(b?)_Intk(z?)$", + "^VSCALEFPHZ(128|256)rrk(z?)$", + "^VSCALEFSHZrrb_Intk(z?)$", + "^VSCALEFSHZrrk(z?)$")>; + +def SPRWriteResGroup536 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 17; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup536, ReadAfterVecYLd], (instregex "^VRNDSCALEPHZrm(b?)ik(z?)$", + "^VSCALEFPHZrm(bk|kz)$", + "^VSCALEFPHZrm(k|bkz)$")>; + +def SPRWriteResGroup537 : SchedWriteRes<[SPRPort00]> { + let ResourceCycles = [2]; + let Latency = 11; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup537], (instregex "^VRNDSCALEPHZrri(bk|kz)$", + "^VRNDSCALEPHZrri(k|bkz)$", + "^VSCALEFPHZrr(bk|kz)$", + "^VSCALEFPHZrr(k|bkz)$")>; + +def SPRWriteResGroup538 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let ResourceCycles = [2, 1]; + let Latency = 6; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup538], (instregex "^VRSQRT14P(D|S)Zr$")>; +def : InstRW<[SPRWriteResGroup538], (instrs VRSQRT14PSZrk, + VRSQRTPHZr)>; + +def SPRWriteResGroup539 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 25; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup539], (instrs VSQRTPDYm)>; +def : InstRW<[SPRWriteResGroup539, ReadAfterVecYLd], (instregex "^VSQRTPDZ256m(b?)$")>; + +def SPRWriteResGroup540 : SchedWriteRes<[SPRPort00, SPRPort02_03_11]> { + let Latency = 20; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup540, ReadAfterVecXLd], (instregex "^VSQRTPDZ128m(bk|kz)$", + "^VSQRTPDZ128m(k|bkz)$")>; +def : InstRW<[SPRWriteResGroup540, ReadAfterVecLd], (instregex "^VSQRTSDZm_Intk(z?)$")>; + +def SPRWriteResGroup541 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 38; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup541, ReadAfterVecYLd], (instrs VSQRTPDZm)>; + +def SPRWriteResGroup542 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 39; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup542, ReadAfterVecYLd], (instrs VSQRTPDZmb)>; + +def SPRWriteResGroup543 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let ResourceCycles = [2, 1]; + let Latency = 31; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup543], (instrs VSQRTPDZr)>; + +def SPRWriteResGroup544 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 41; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup544, ReadAfterVecXLd], (instregex "^VSQRTPHZ128m(bk|kz)$", + "^VSQRTPHZ128m(k|bkz)$")>; + +def SPRWriteResGroup545 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let ResourceCycles = [2, 1]; + let Latency = 35; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup545], (instregex "^VSQRTPHZ(128|256)rk$")>; +def : InstRW<[SPRWriteResGroup545], (instrs VSQRTPHZ256rkz)>; + +def SPRWriteResGroup546 : SchedWriteRes<[SPRPort00, SPRPort00_01_05]> { + let ResourceCycles = [2, 1]; + let Latency = 12; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup546], (instrs VSQRTPHZ128rkz)>; + +def SPRWriteResGroup547 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 40; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup547, ReadAfterVecYLd], (instregex "^VSQRTPHZ256m(b?)$")>; + +def SPRWriteResGroup548 : SchedWriteRes<[SPRPort00, SPRPort00_01_05, SPRPort02_03_11]> { + let ResourceCycles = [2, 1, 1]; + let Latency = 42; + let NumMicroOps = 4; +} +def : InstRW<[SPRWriteResGroup548, ReadAfterVecYLd], (instregex "^VSQRTPHZ256m(bk|kz)$", + "^VSQRTPHZ256m(k|bkz)$")>; + +def SPRWriteResGroup549 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [4, 2, 1, 1, 1]; + let Latency = 53; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup549, ReadAfterVecYLd], (instregex "^VSQRTPHZm(b?)$")>; + +def SPRWriteResGroup550 : SchedWriteRes<[SPRPort00, SPRPort00_05, SPRPort00_06, SPRPort02_03_11, SPRPort05]> { + let ResourceCycles = [4, 2, 1, 1, 1]; + let Latency = 55; + let NumMicroOps = 9; +} +def : InstRW<[SPRWriteResGroup550, ReadAfterVecYLd], (instregex "^VSQRTPHZm(bk|kz)$", + "^VSQRTPHZm(k|bkz)$")>; + +def SPRWriteResGroup551 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [4, 1, 1]; + let Latency = 45; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup551], (instregex "^VSQRTPHZr(b?)$")>; + +def SPRWriteResGroup552 : SchedWriteRes<[SPRPort00, SPRPort00_06, SPRPort05]> { + let ResourceCycles = [4, 1, 1]; + let Latency = 47; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup552], (instregex "^VSQRTPHZr(bk|kz)$", + "^VSQRTPHZr(k|bkz)$")>; + +def SPRWriteResGroup553 : SchedWriteRes<[SPRPort00, SPRPort00_05]> { + let ResourceCycles = [2, 1]; + let Latency = 19; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup553], (instrs VSQRTPSZr)>; + +def SPRWriteResGroup554 : SchedWriteRes<[SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort01_05_10]> { + let ResourceCycles = [1, 2, 3, 3, 1]; + let Latency = 12; + let NumMicroOps = 10; +} +def : InstRW<[SPRWriteResGroup554], (instrs VZEROALL)>; + +def SPRWriteResGroup555 : SchedWriteRes<[SPRPort00_01_05_06]> { + let ResourceCycles = [2]; + let Latency = 2; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup555], (instrs WAIT)>; + +def SPRWriteResGroup556 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [8, 6, 19, 63, 21, 15, 1, 10, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 144; +} +def : InstRW<[SPRWriteResGroup556], (instrs WRMSR)>; + +def SPRWriteResGroup557 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06, SPRPort01, SPRPort05]> { + let ResourceCycles = [2, 1, 4, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 8; +} +def : InstRW<[SPRWriteResGroup557], (instrs WRPKRUr)>; + +def SPRWriteResGroup558 : SchedWriteRes<[SPRPort00_01_05_06_10]> { + let ResourceCycles = [2]; + let Latency = 12; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup558, WriteRMW], (instregex "^XADD(16|32|64)rm$")>; + +def SPRWriteResGroup559 : SchedWriteRes<[SPRPort00_01_05_06_10]> { + let ResourceCycles = [2]; + let Latency = 13; + let NumMicroOps = 2; +} +def : InstRW<[SPRWriteResGroup559, WriteRMW], (instrs XADD8rm)>; + +def SPRWriteResGroup560 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let ResourceCycles = [4, 1]; + let Latency = 39; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup560, WriteRMW], (instregex "^XCHG(16|32)rm$")>; + +def SPRWriteResGroup561 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let ResourceCycles = [5, 1]; + let Latency = 39; + let NumMicroOps = 6; +} +def : InstRW<[SPRWriteResGroup561, WriteRMW], (instrs XCHG64rm)>; + +def SPRWriteResGroup562 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let ResourceCycles = [4, 1]; + let Latency = 40; + let NumMicroOps = 5; +} +def : InstRW<[SPRWriteResGroup562, WriteRMW], (instrs XCHG8rm)>; + +def SPRWriteResGroup563 : SchedWriteRes<[SPRPort00, SPRPort00_01_05_06, SPRPort00_05, SPRPort01, SPRPort05, SPRPort06]> { + let ResourceCycles = [2, 4, 2, 1, 2, 4]; + let Latency = 17; + let NumMicroOps = 15; +} +def : InstRW<[SPRWriteResGroup563], (instrs XCH_F)>; + +def SPRWriteResGroup564 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01]> { + let ResourceCycles = [7, 3, 8, 5]; + let Latency = 4; + let NumMicroOps = 23; +} +def : InstRW<[SPRWriteResGroup564], (instrs XGETBV)>; + +def SPRWriteResGroup565 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort02_03_11]> { + let ResourceCycles = [2, 1]; + let Latency = 7; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup565], (instrs XLAT)>; + +def SPRWriteResGroup566 : SchedWriteRes<[SPRPort01, SPRPort02_03, SPRPort02_03_11, SPRPort06]> { + let ResourceCycles = [1, 21, 1, 8]; + let Latency = 37; + let NumMicroOps = 31; +} +def : InstRW<[SPRWriteResGroup566], (instregex "^XRSTOR((S|64)?)$")>; +def : InstRW<[SPRWriteResGroup566], (instrs XRSTORS64)>; + +def SPRWriteResGroup567 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [14, 25, 44, 21, 21, 4, 1, 9, 1]; + let Latency = 42; + let NumMicroOps = 140; +} +def : InstRW<[SPRWriteResGroup567], (instrs XSAVE)>; + +def SPRWriteResGroup568 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [14, 25, 44, 21, 21, 4, 1, 9, 1]; + let Latency = 41; + let NumMicroOps = 140; +} +def : InstRW<[SPRWriteResGroup568], (instrs XSAVE64)>; + +def SPRWriteResGroup569 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 19, 36, 52, 23, 4, 2, 12, 2]; + let Latency = 42; + let NumMicroOps = 151; +} +def : InstRW<[SPRWriteResGroup569], (instrs XSAVEC)>; + +def SPRWriteResGroup570 : SchedWriteRes<[SPRPort00, SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [1, 19, 36, 53, 23, 4, 2, 12, 2]; + let Latency = 42; + let NumMicroOps = 152; +} +def : InstRW<[SPRWriteResGroup570], (instrs XSAVEC64)>; + +def SPRWriteResGroup571 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [25, 35, 52, 27, 4, 1, 10, 1]; + let Latency = 42; + let NumMicroOps = 155; +} +def : InstRW<[SPRWriteResGroup571], (instrs XSAVEOPT)>; + +def SPRWriteResGroup572 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [25, 35, 53, 27, 4, 1, 10, 1]; + let Latency = 42; + let NumMicroOps = 156; +} +def : InstRW<[SPRWriteResGroup572], (instrs XSAVEOPT64)>; + +def SPRWriteResGroup573 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [23, 32, 53, 29, 30, 4, 2, 9, 2]; + let Latency = 42; + let NumMicroOps = 184; +} +def : InstRW<[SPRWriteResGroup573], (instrs XSAVES)>; + +def SPRWriteResGroup574 : SchedWriteRes<[SPRPort00_01, SPRPort00_05, SPRPort00_06, SPRPort01, SPRPort01_05, SPRPort02_03_11, SPRPort04_09, SPRPort05, SPRPort07_08]> { + let ResourceCycles = [23, 33, 53, 29, 32, 4, 2, 8, 2]; + let Latency = 42; + let NumMicroOps = 186; +} +def : InstRW<[SPRWriteResGroup574], (instrs XSAVES64)>; + +def SPRWriteResGroup575 : SchedWriteRes<[SPRPort00_01_05, SPRPort00_01_05_06_10, SPRPort00_05_06, SPRPort00_06, SPRPort01, SPRPort01_05_10, SPRPort05]> { + let ResourceCycles = [4, 23, 2, 14, 8, 1, 2]; + let Latency = 5; + let NumMicroOps = 54; +} +def : InstRW<[SPRWriteResGroup575], (instrs XSETBV)>; + +def SPRWriteResGroup576 : SchedWriteRes<[SPRPort00_01_05_06_10, SPRPort00_06]> { + let ResourceCycles = [2, 1]; + let Latency = SapphireRapidsModel.MaxLatency; + let NumMicroOps = 3; +} +def : InstRW<[SPRWriteResGroup576], (instrs XTEST)>; + +} diff --git a/llvm/test/CodeGen/X86/avxvnni-combine.ll b/llvm/test/CodeGen/X86/avxvnni-combine.ll --- a/llvm/test/CodeGen/X86/avxvnni-combine.ll +++ b/llvm/test/CodeGen/X86/avxvnni-combine.ll @@ -42,99 +42,52 @@ declare <4 x i32> @llvm.x86.avx512.vpdpwssd.128(<4 x i32>, <4 x i32>, <4 x i32>) #1 define <2 x i64> @foo_128(i32 %0, <2 x i64> %1, <2 x i64> %2, ptr %3) { -; ADL-LABEL: foo_128: -; ADL: # %bb.0: -; ADL-NEXT: testl %edi, %edi -; ADL-NEXT: jle .LBB1_6 -; ADL-NEXT: # %bb.1: -; ADL-NEXT: movl %edi, %edx -; ADL-NEXT: movl %edx, %eax -; ADL-NEXT: andl $3, %eax -; ADL-NEXT: cmpl $4, %edi -; ADL-NEXT: jae .LBB1_7 -; ADL-NEXT: # %bb.2: -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: jmp .LBB1_3 -; ADL-NEXT: .LBB1_7: -; ADL-NEXT: andl $-4, %edx -; ADL-NEXT: leaq 48(%rsi), %rdi -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB1_8: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0 -; ADL-NEXT: vpmaddwd -32(%rdi), %xmm1, %xmm2 -; ADL-NEXT: vpmaddwd -16(%rdi), %xmm1, %xmm3 -; ADL-NEXT: vpaddd %xmm2, %xmm0, %xmm0 -; ADL-NEXT: vpaddd %xmm3, %xmm0, %xmm0 -; ADL-NEXT: vpmaddwd (%rdi), %xmm1, %xmm2 -; ADL-NEXT: vpaddd %xmm2, %xmm0, %xmm0 -; ADL-NEXT: addq $4, %rcx -; ADL-NEXT: addq $64, %rdi -; ADL-NEXT: cmpq %rcx, %rdx -; ADL-NEXT: jne .LBB1_8 -; ADL-NEXT: .LBB1_3: -; ADL-NEXT: testq %rax, %rax -; ADL-NEXT: je .LBB1_6 -; ADL-NEXT: # %bb.4: # %.preheader -; ADL-NEXT: shlq $4, %rcx -; ADL-NEXT: addq %rcx, %rsi -; ADL-NEXT: shlq $4, %rax -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB1_5: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0 -; ADL-NEXT: addq $16, %rcx -; ADL-NEXT: cmpq %rcx, %rax -; ADL-NEXT: jne .LBB1_5 -; ADL-NEXT: .LBB1_6: -; ADL-NEXT: retq -; -; SPR-LABEL: foo_128: -; SPR: # %bb.0: -; SPR-NEXT: testl %edi, %edi -; SPR-NEXT: jle .LBB1_6 -; SPR-NEXT: # %bb.1: -; SPR-NEXT: movl %edi, %edx -; SPR-NEXT: movl %edx, %eax -; SPR-NEXT: andl $3, %eax -; SPR-NEXT: cmpl $4, %edi -; SPR-NEXT: jae .LBB1_7 -; SPR-NEXT: # %bb.2: -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: jmp .LBB1_3 -; SPR-NEXT: .LBB1_7: -; SPR-NEXT: andl $-4, %edx -; SPR-NEXT: leaq 48(%rsi), %rdi -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB1_8: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0 -; SPR-NEXT: vpmaddwd -32(%rdi), %xmm1, %xmm2 -; SPR-NEXT: vpaddd %xmm2, %xmm0, %xmm0 -; SPR-NEXT: vpmaddwd -16(%rdi), %xmm1, %xmm2 -; SPR-NEXT: vpaddd %xmm2, %xmm0, %xmm0 -; SPR-NEXT: vpmaddwd (%rdi), %xmm1, %xmm2 -; SPR-NEXT: vpaddd %xmm2, %xmm0, %xmm0 -; SPR-NEXT: addq $4, %rcx -; SPR-NEXT: addq $64, %rdi -; SPR-NEXT: cmpq %rcx, %rdx -; SPR-NEXT: jne .LBB1_8 -; SPR-NEXT: .LBB1_3: -; SPR-NEXT: testq %rax, %rax -; SPR-NEXT: je .LBB1_6 -; SPR-NEXT: # %bb.4: # %.preheader -; SPR-NEXT: shlq $4, %rcx -; SPR-NEXT: addq %rcx, %rsi -; SPR-NEXT: shlq $4, %rax -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB1_5: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0 -; SPR-NEXT: addq $16, %rcx -; SPR-NEXT: cmpq %rcx, %rax -; SPR-NEXT: jne .LBB1_5 -; SPR-NEXT: .LBB1_6: -; SPR-NEXT: retq +; AVX-LABEL: foo_128: +; AVX: # %bb.0: +; AVX-NEXT: testl %edi, %edi +; AVX-NEXT: jle .LBB1_6 +; AVX-NEXT: # %bb.1: +; AVX-NEXT: movl %edi, %edx +; AVX-NEXT: movl %edx, %eax +; AVX-NEXT: andl $3, %eax +; AVX-NEXT: cmpl $4, %edi +; AVX-NEXT: jae .LBB1_7 +; AVX-NEXT: # %bb.2: +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: jmp .LBB1_3 +; AVX-NEXT: .LBB1_7: +; AVX-NEXT: andl $-4, %edx +; AVX-NEXT: leaq 48(%rsi), %rdi +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB1_8: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: {vex} vpdpwssd -48(%rdi), %xmm1, %xmm0 +; AVX-NEXT: vpmaddwd -32(%rdi), %xmm1, %xmm2 +; AVX-NEXT: vpmaddwd -16(%rdi), %xmm1, %xmm3 +; AVX-NEXT: vpaddd %xmm2, %xmm0, %xmm0 +; AVX-NEXT: vpaddd %xmm3, %xmm0, %xmm0 +; AVX-NEXT: vpmaddwd (%rdi), %xmm1, %xmm2 +; AVX-NEXT: vpaddd %xmm2, %xmm0, %xmm0 +; AVX-NEXT: addq $4, %rcx +; AVX-NEXT: addq $64, %rdi +; AVX-NEXT: cmpq %rcx, %rdx +; AVX-NEXT: jne .LBB1_8 +; AVX-NEXT: .LBB1_3: +; AVX-NEXT: testq %rax, %rax +; AVX-NEXT: je .LBB1_6 +; AVX-NEXT: # %bb.4: # %.preheader +; AVX-NEXT: shlq $4, %rcx +; AVX-NEXT: addq %rcx, %rsi +; AVX-NEXT: shlq $4, %rax +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB1_5: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: {vex} vpdpwssd (%rsi,%rcx), %xmm1, %xmm0 +; AVX-NEXT: addq $16, %rcx +; AVX-NEXT: cmpq %rcx, %rax +; AVX-NEXT: jne .LBB1_5 +; AVX-NEXT: .LBB1_6: +; AVX-NEXT: retq ; ; AVX512-LABEL: foo_128: ; AVX512: # %bb.0: @@ -256,85 +209,45 @@ } define void @bar_128(i32 %0, ptr %1, <2 x i64> %2, ptr %3) { -; ADL-LABEL: bar_128: -; ADL: # %bb.0: -; ADL-NEXT: testl %edi, %edi -; ADL-NEXT: jle .LBB2_5 -; ADL-NEXT: # %bb.1: -; ADL-NEXT: movl %edi, %eax -; ADL-NEXT: cmpl $1, %edi -; ADL-NEXT: jne .LBB2_6 -; ADL-NEXT: # %bb.2: -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: jmp .LBB2_3 -; ADL-NEXT: .LBB2_6: -; ADL-NEXT: movl %eax, %edi -; ADL-NEXT: andl $-2, %edi -; ADL-NEXT: movl $16, %r8d -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB2_7: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: vmovdqa (%rsi,%r8), %xmm1 -; ADL-NEXT: vpmaddwd -16(%rdx,%r8), %xmm0, %xmm2 -; ADL-NEXT: vpaddd -16(%rsi,%r8), %xmm2, %xmm2 -; ADL-NEXT: vmovdqa %xmm2, -16(%rsi,%r8) -; ADL-NEXT: vpmaddwd (%rdx,%r8), %xmm0, %xmm2 -; ADL-NEXT: vpaddd %xmm2, %xmm1, %xmm1 -; ADL-NEXT: vmovdqa %xmm1, (%rsi,%r8) -; ADL-NEXT: addq $2, %rcx -; ADL-NEXT: addq $32, %r8 -; ADL-NEXT: cmpq %rcx, %rdi -; ADL-NEXT: jne .LBB2_7 -; ADL-NEXT: .LBB2_3: -; ADL-NEXT: testb $1, %al -; ADL-NEXT: je .LBB2_5 -; ADL-NEXT: # %bb.4: -; ADL-NEXT: shlq $4, %rcx -; ADL-NEXT: vmovdqa (%rsi,%rcx), %xmm1 -; ADL-NEXT: {vex} vpdpwssd (%rdx,%rcx), %xmm0, %xmm1 -; ADL-NEXT: vmovdqa %xmm1, (%rsi,%rcx) -; ADL-NEXT: .LBB2_5: -; ADL-NEXT: retq -; -; SPR-LABEL: bar_128: -; SPR: # %bb.0: -; SPR-NEXT: testl %edi, %edi -; SPR-NEXT: jle .LBB2_5 -; SPR-NEXT: # %bb.1: -; SPR-NEXT: movl %edi, %eax -; SPR-NEXT: cmpl $1, %edi -; SPR-NEXT: jne .LBB2_6 -; SPR-NEXT: # %bb.2: -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: jmp .LBB2_3 -; SPR-NEXT: .LBB2_6: -; SPR-NEXT: movl %eax, %edi -; SPR-NEXT: andl $-2, %edi -; SPR-NEXT: movl $16, %r8d -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB2_7: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: vmovdqa (%rsi,%r8), %xmm1 -; SPR-NEXT: vpmaddwd -16(%rdx,%r8), %xmm0, %xmm2 -; SPR-NEXT: vpaddd -16(%rsi,%r8), %xmm2, %xmm2 -; SPR-NEXT: vmovdqa %xmm2, -16(%rsi,%r8) -; SPR-NEXT: vpmaddwd (%rdx,%r8), %xmm0, %xmm2 -; SPR-NEXT: vpaddd %xmm2, %xmm1, %xmm1 -; SPR-NEXT: vmovdqa %xmm1, (%rsi,%r8) -; SPR-NEXT: addq $2, %rcx -; SPR-NEXT: addq $32, %r8 -; SPR-NEXT: cmpq %rcx, %rdi -; SPR-NEXT: jne .LBB2_7 -; SPR-NEXT: .LBB2_3: -; SPR-NEXT: testb $1, %al -; SPR-NEXT: je .LBB2_5 -; SPR-NEXT: # %bb.4: -; SPR-NEXT: shlq $4, %rcx -; SPR-NEXT: vpmaddwd (%rdx,%rcx), %xmm0, %xmm0 -; SPR-NEXT: vpaddd (%rsi,%rcx), %xmm0, %xmm0 -; SPR-NEXT: vmovdqa %xmm0, (%rsi,%rcx) -; SPR-NEXT: .LBB2_5: -; SPR-NEXT: retq +; AVX-LABEL: bar_128: +; AVX: # %bb.0: +; AVX-NEXT: testl %edi, %edi +; AVX-NEXT: jle .LBB2_5 +; AVX-NEXT: # %bb.1: +; AVX-NEXT: movl %edi, %eax +; AVX-NEXT: cmpl $1, %edi +; AVX-NEXT: jne .LBB2_6 +; AVX-NEXT: # %bb.2: +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: jmp .LBB2_3 +; AVX-NEXT: .LBB2_6: +; AVX-NEXT: movl %eax, %edi +; AVX-NEXT: andl $-2, %edi +; AVX-NEXT: movl $16, %r8d +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB2_7: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: vmovdqa (%rsi,%r8), %xmm1 +; AVX-NEXT: vpmaddwd -16(%rdx,%r8), %xmm0, %xmm2 +; AVX-NEXT: vpaddd -16(%rsi,%r8), %xmm2, %xmm2 +; AVX-NEXT: vmovdqa %xmm2, -16(%rsi,%r8) +; AVX-NEXT: vpmaddwd (%rdx,%r8), %xmm0, %xmm2 +; AVX-NEXT: vpaddd %xmm2, %xmm1, %xmm1 +; AVX-NEXT: vmovdqa %xmm1, (%rsi,%r8) +; AVX-NEXT: addq $2, %rcx +; AVX-NEXT: addq $32, %r8 +; AVX-NEXT: cmpq %rcx, %rdi +; AVX-NEXT: jne .LBB2_7 +; AVX-NEXT: .LBB2_3: +; AVX-NEXT: testb $1, %al +; AVX-NEXT: je .LBB2_5 +; AVX-NEXT: # %bb.4: +; AVX-NEXT: shlq $4, %rcx +; AVX-NEXT: vmovdqa (%rsi,%rcx), %xmm1 +; AVX-NEXT: {vex} vpdpwssd (%rdx,%rcx), %xmm0, %xmm1 +; AVX-NEXT: vmovdqa %xmm1, (%rsi,%rcx) +; AVX-NEXT: .LBB2_5: +; AVX-NEXT: retq ; ; AVX512-LABEL: bar_128: ; AVX512: # %bb.0: @@ -476,99 +389,52 @@ ; } define <4 x i64> @foo_256(i32 %0, <4 x i64> %1, <4 x i64> %2, ptr %3) { -; ADL-LABEL: foo_256: -; ADL: # %bb.0: -; ADL-NEXT: testl %edi, %edi -; ADL-NEXT: jle .LBB4_6 -; ADL-NEXT: # %bb.1: -; ADL-NEXT: movl %edi, %edx -; ADL-NEXT: movl %edx, %eax -; ADL-NEXT: andl $3, %eax -; ADL-NEXT: cmpl $4, %edi -; ADL-NEXT: jae .LBB4_7 -; ADL-NEXT: # %bb.2: -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: jmp .LBB4_3 -; ADL-NEXT: .LBB4_7: -; ADL-NEXT: andl $-4, %edx -; ADL-NEXT: leaq 96(%rsi), %rdi -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB4_8: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0 -; ADL-NEXT: vpmaddwd -64(%rdi), %ymm1, %ymm2 -; ADL-NEXT: vpmaddwd -32(%rdi), %ymm1, %ymm3 -; ADL-NEXT: vpaddd %ymm2, %ymm0, %ymm0 -; ADL-NEXT: vpaddd %ymm3, %ymm0, %ymm0 -; ADL-NEXT: vpmaddwd (%rdi), %ymm1, %ymm2 -; ADL-NEXT: vpaddd %ymm2, %ymm0, %ymm0 -; ADL-NEXT: addq $4, %rcx -; ADL-NEXT: subq $-128, %rdi -; ADL-NEXT: cmpq %rcx, %rdx -; ADL-NEXT: jne .LBB4_8 -; ADL-NEXT: .LBB4_3: -; ADL-NEXT: testq %rax, %rax -; ADL-NEXT: je .LBB4_6 -; ADL-NEXT: # %bb.4: # %.preheader -; ADL-NEXT: shlq $5, %rcx -; ADL-NEXT: addq %rcx, %rsi -; ADL-NEXT: shlq $5, %rax -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB4_5: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0 -; ADL-NEXT: addq $32, %rcx -; ADL-NEXT: cmpq %rcx, %rax -; ADL-NEXT: jne .LBB4_5 -; ADL-NEXT: .LBB4_6: -; ADL-NEXT: retq -; -; SPR-LABEL: foo_256: -; SPR: # %bb.0: -; SPR-NEXT: testl %edi, %edi -; SPR-NEXT: jle .LBB4_6 -; SPR-NEXT: # %bb.1: -; SPR-NEXT: movl %edi, %edx -; SPR-NEXT: movl %edx, %eax -; SPR-NEXT: andl $3, %eax -; SPR-NEXT: cmpl $4, %edi -; SPR-NEXT: jae .LBB4_7 -; SPR-NEXT: # %bb.2: -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: jmp .LBB4_3 -; SPR-NEXT: .LBB4_7: -; SPR-NEXT: andl $-4, %edx -; SPR-NEXT: leaq 96(%rsi), %rdi -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB4_8: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0 -; SPR-NEXT: vpmaddwd -64(%rdi), %ymm1, %ymm2 -; SPR-NEXT: vpaddd %ymm2, %ymm0, %ymm0 -; SPR-NEXT: vpmaddwd -32(%rdi), %ymm1, %ymm2 -; SPR-NEXT: vpaddd %ymm2, %ymm0, %ymm0 -; SPR-NEXT: vpmaddwd (%rdi), %ymm1, %ymm2 -; SPR-NEXT: vpaddd %ymm2, %ymm0, %ymm0 -; SPR-NEXT: addq $4, %rcx -; SPR-NEXT: subq $-128, %rdi -; SPR-NEXT: cmpq %rcx, %rdx -; SPR-NEXT: jne .LBB4_8 -; SPR-NEXT: .LBB4_3: -; SPR-NEXT: testq %rax, %rax -; SPR-NEXT: je .LBB4_6 -; SPR-NEXT: # %bb.4: # %.preheader -; SPR-NEXT: shlq $5, %rcx -; SPR-NEXT: addq %rcx, %rsi -; SPR-NEXT: shlq $5, %rax -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB4_5: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0 -; SPR-NEXT: addq $32, %rcx -; SPR-NEXT: cmpq %rcx, %rax -; SPR-NEXT: jne .LBB4_5 -; SPR-NEXT: .LBB4_6: -; SPR-NEXT: retq +; AVX-LABEL: foo_256: +; AVX: # %bb.0: +; AVX-NEXT: testl %edi, %edi +; AVX-NEXT: jle .LBB4_6 +; AVX-NEXT: # %bb.1: +; AVX-NEXT: movl %edi, %edx +; AVX-NEXT: movl %edx, %eax +; AVX-NEXT: andl $3, %eax +; AVX-NEXT: cmpl $4, %edi +; AVX-NEXT: jae .LBB4_7 +; AVX-NEXT: # %bb.2: +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: jmp .LBB4_3 +; AVX-NEXT: .LBB4_7: +; AVX-NEXT: andl $-4, %edx +; AVX-NEXT: leaq 96(%rsi), %rdi +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB4_8: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: {vex} vpdpwssd -96(%rdi), %ymm1, %ymm0 +; AVX-NEXT: vpmaddwd -64(%rdi), %ymm1, %ymm2 +; AVX-NEXT: vpmaddwd -32(%rdi), %ymm1, %ymm3 +; AVX-NEXT: vpaddd %ymm2, %ymm0, %ymm0 +; AVX-NEXT: vpaddd %ymm3, %ymm0, %ymm0 +; AVX-NEXT: vpmaddwd (%rdi), %ymm1, %ymm2 +; AVX-NEXT: vpaddd %ymm2, %ymm0, %ymm0 +; AVX-NEXT: addq $4, %rcx +; AVX-NEXT: subq $-128, %rdi +; AVX-NEXT: cmpq %rcx, %rdx +; AVX-NEXT: jne .LBB4_8 +; AVX-NEXT: .LBB4_3: +; AVX-NEXT: testq %rax, %rax +; AVX-NEXT: je .LBB4_6 +; AVX-NEXT: # %bb.4: # %.preheader +; AVX-NEXT: shlq $5, %rcx +; AVX-NEXT: addq %rcx, %rsi +; AVX-NEXT: shlq $5, %rax +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB4_5: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: {vex} vpdpwssd (%rsi,%rcx), %ymm1, %ymm0 +; AVX-NEXT: addq $32, %rcx +; AVX-NEXT: cmpq %rcx, %rax +; AVX-NEXT: jne .LBB4_5 +; AVX-NEXT: .LBB4_6: +; AVX-NEXT: retq ; ; AVX512-LABEL: foo_256: ; AVX512: # %bb.0: @@ -697,87 +563,46 @@ ; } ; } define void @bar_256(i32 %0, ptr %1, <4 x i64> %2, ptr %3) { -; ADL-LABEL: bar_256: -; ADL: # %bb.0: -; ADL-NEXT: testl %edi, %edi -; ADL-NEXT: jle .LBB5_5 -; ADL-NEXT: # %bb.1: -; ADL-NEXT: movl %edi, %eax -; ADL-NEXT: cmpl $1, %edi -; ADL-NEXT: jne .LBB5_6 -; ADL-NEXT: # %bb.2: -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: jmp .LBB5_3 -; ADL-NEXT: .LBB5_6: -; ADL-NEXT: movl %eax, %edi -; ADL-NEXT: andl $-2, %edi -; ADL-NEXT: movl $32, %r8d -; ADL-NEXT: xorl %ecx, %ecx -; ADL-NEXT: .p2align 4, 0x90 -; ADL-NEXT: .LBB5_7: # =>This Inner Loop Header: Depth=1 -; ADL-NEXT: vmovdqa (%rsi,%r8), %ymm1 -; ADL-NEXT: vpmaddwd -32(%rdx,%r8), %ymm0, %ymm2 -; ADL-NEXT: vpaddd -32(%rsi,%r8), %ymm2, %ymm2 -; ADL-NEXT: vmovdqa %ymm2, -32(%rsi,%r8) -; ADL-NEXT: vpmaddwd (%rdx,%r8), %ymm0, %ymm2 -; ADL-NEXT: vpaddd %ymm2, %ymm1, %ymm1 -; ADL-NEXT: vmovdqa %ymm1, (%rsi,%r8) -; ADL-NEXT: addq $2, %rcx -; ADL-NEXT: addq $64, %r8 -; ADL-NEXT: cmpq %rcx, %rdi -; ADL-NEXT: jne .LBB5_7 -; ADL-NEXT: .LBB5_3: -; ADL-NEXT: testb $1, %al -; ADL-NEXT: je .LBB5_5 -; ADL-NEXT: # %bb.4: -; ADL-NEXT: shlq $5, %rcx -; ADL-NEXT: vmovdqa (%rsi,%rcx), %ymm1 -; ADL-NEXT: {vex} vpdpwssd (%rdx,%rcx), %ymm0, %ymm1 -; ADL-NEXT: vmovdqa %ymm1, (%rsi,%rcx) -; ADL-NEXT: .LBB5_5: -; ADL-NEXT: vzeroupper -; ADL-NEXT: retq -; -; SPR-LABEL: bar_256: -; SPR: # %bb.0: -; SPR-NEXT: testl %edi, %edi -; SPR-NEXT: jle .LBB5_5 -; SPR-NEXT: # %bb.1: -; SPR-NEXT: movl %edi, %eax -; SPR-NEXT: cmpl $1, %edi -; SPR-NEXT: jne .LBB5_6 -; SPR-NEXT: # %bb.2: -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: jmp .LBB5_3 -; SPR-NEXT: .LBB5_6: -; SPR-NEXT: movl %eax, %edi -; SPR-NEXT: andl $-2, %edi -; SPR-NEXT: movl $32, %r8d -; SPR-NEXT: xorl %ecx, %ecx -; SPR-NEXT: .p2align 4, 0x90 -; SPR-NEXT: .LBB5_7: # =>This Inner Loop Header: Depth=1 -; SPR-NEXT: vmovdqa (%rsi,%r8), %ymm1 -; SPR-NEXT: vpmaddwd -32(%rdx,%r8), %ymm0, %ymm2 -; SPR-NEXT: vpaddd -32(%rsi,%r8), %ymm2, %ymm2 -; SPR-NEXT: vmovdqa %ymm2, -32(%rsi,%r8) -; SPR-NEXT: vpmaddwd (%rdx,%r8), %ymm0, %ymm2 -; SPR-NEXT: vpaddd %ymm2, %ymm1, %ymm1 -; SPR-NEXT: vmovdqa %ymm1, (%rsi,%r8) -; SPR-NEXT: addq $2, %rcx -; SPR-NEXT: addq $64, %r8 -; SPR-NEXT: cmpq %rcx, %rdi -; SPR-NEXT: jne .LBB5_7 -; SPR-NEXT: .LBB5_3: -; SPR-NEXT: testb $1, %al -; SPR-NEXT: je .LBB5_5 -; SPR-NEXT: # %bb.4: -; SPR-NEXT: shlq $5, %rcx -; SPR-NEXT: vpmaddwd (%rdx,%rcx), %ymm0, %ymm0 -; SPR-NEXT: vpaddd (%rsi,%rcx), %ymm0, %ymm0 -; SPR-NEXT: vmovdqa %ymm0, (%rsi,%rcx) -; SPR-NEXT: .LBB5_5: -; SPR-NEXT: vzeroupper -; SPR-NEXT: retq +; AVX-LABEL: bar_256: +; AVX: # %bb.0: +; AVX-NEXT: testl %edi, %edi +; AVX-NEXT: jle .LBB5_5 +; AVX-NEXT: # %bb.1: +; AVX-NEXT: movl %edi, %eax +; AVX-NEXT: cmpl $1, %edi +; AVX-NEXT: jne .LBB5_6 +; AVX-NEXT: # %bb.2: +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: jmp .LBB5_3 +; AVX-NEXT: .LBB5_6: +; AVX-NEXT: movl %eax, %edi +; AVX-NEXT: andl $-2, %edi +; AVX-NEXT: movl $32, %r8d +; AVX-NEXT: xorl %ecx, %ecx +; AVX-NEXT: .p2align 4, 0x90 +; AVX-NEXT: .LBB5_7: # =>This Inner Loop Header: Depth=1 +; AVX-NEXT: vmovdqa (%rsi,%r8), %ymm1 +; AVX-NEXT: vpmaddwd -32(%rdx,%r8), %ymm0, %ymm2 +; AVX-NEXT: vpaddd -32(%rsi,%r8), %ymm2, %ymm2 +; AVX-NEXT: vmovdqa %ymm2, -32(%rsi,%r8) +; AVX-NEXT: vpmaddwd (%rdx,%r8), %ymm0, %ymm2 +; AVX-NEXT: vpaddd %ymm2, %ymm1, %ymm1 +; AVX-NEXT: vmovdqa %ymm1, (%rsi,%r8) +; AVX-NEXT: addq $2, %rcx +; AVX-NEXT: addq $64, %r8 +; AVX-NEXT: cmpq %rcx, %rdi +; AVX-NEXT: jne .LBB5_7 +; AVX-NEXT: .LBB5_3: +; AVX-NEXT: testb $1, %al +; AVX-NEXT: je .LBB5_5 +; AVX-NEXT: # %bb.4: +; AVX-NEXT: shlq $5, %rcx +; AVX-NEXT: vmovdqa (%rsi,%rcx), %ymm1 +; AVX-NEXT: {vex} vpdpwssd (%rdx,%rcx), %ymm0, %ymm1 +; AVX-NEXT: vmovdqa %ymm1, (%rsi,%rcx) +; AVX-NEXT: .LBB5_5: +; AVX-NEXT: vzeroupper +; AVX-NEXT: retq ; ; AVX512-LABEL: bar_256: ; AVX512: # %bb.0: @@ -872,3 +697,6 @@ br i1 %39, label %13, label %23 } declare <8 x i32> @llvm.x86.avx512.vpdpwssd.256(<8 x i32>, <8 x i32>, <8 x i32>) +;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: +; ADL: {{.*}} +; SPR: {{.*}} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/independent-load-stores.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/independent-load-stores.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/independent-load-stores.s @@ -0,0 +1,142 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -timeline -timeline-max-iterations=1 < %s | FileCheck %s -check-prefixes=ALL,NOALIAS +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -timeline -timeline-max-iterations=1 -noalias=false < %s | FileCheck %s -check-prefixes=ALL,YESALIAS + + addq $44, 64(%r14) + addq $44, 128(%r14) + addq $44, 192(%r14) + addq $44, 256(%r14) + addq $44, 320(%r14) + addq $44, 384(%r14) + addq $44, 448(%r14) + addq $44, 512(%r14) + addq $44, 576(%r14) + addq $44, 640(%r14) + +# ALL: Iterations: 100 +# ALL-NEXT: Instructions: 1000 + +# NOALIAS-NEXT: Total Cycles: 1014 +# YESALIAS-NEXT: Total Cycles: 12003 + +# ALL-NEXT: Total uOps: 4000 + +# ALL: Dispatch Width: 6 + +# NOALIAS-NEXT: uOps Per Cycle: 3.94 +# NOALIAS-NEXT: IPC: 0.99 + +# YESALIAS-NEXT: uOps Per Cycle: 0.33 +# YESALIAS-NEXT: IPC: 0.08 + +# ALL-NEXT: Block RThroughput: 6.7 + +# ALL: Instruction Info: +# ALL-NEXT: [1]: #uOps +# ALL-NEXT: [2]: Latency +# ALL-NEXT: [3]: RThroughput +# ALL-NEXT: [4]: MayLoad +# ALL-NEXT: [5]: MayStore +# ALL-NEXT: [6]: HasSideEffects (U) + +# ALL: [1] [2] [3] [4] [5] [6] Instructions: +# ALL-NEXT: 4 12 0.50 * * addq $44, 64(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 128(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 192(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 256(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 320(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 384(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 448(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 512(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 576(%r14) +# ALL-NEXT: 4 12 0.50 * * addq $44, 640(%r14) + +# ALL: Resources: +# ALL-NEXT: [0] - SPRPort00 +# ALL-NEXT: [1] - SPRPort01 +# ALL-NEXT: [2] - SPRPort02 +# ALL-NEXT: [3] - SPRPort03 +# ALL-NEXT: [4] - SPRPort04 +# ALL-NEXT: [5] - SPRPort05 +# ALL-NEXT: [6] - SPRPort06 +# ALL-NEXT: [7] - SPRPort07 +# ALL-NEXT: [8] - SPRPort08 +# ALL-NEXT: [9] - SPRPort09 +# ALL-NEXT: [10] - SPRPort10 +# ALL-NEXT: [11] - SPRPort11 +# ALL-NEXT: [12] - SPRPortInvalid + +# ALL: Resource pressure per iteration: +# ALL-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# ALL-NEXT: 2.00 2.00 3.33 3.33 5.00 2.00 2.00 5.00 5.00 5.00 2.00 3.34 - + +# ALL: Resource pressure by instruction: +# ALL-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# ALL-NEXT: - - 0.33 0.33 - - - - 1.00 1.00 1.00 0.34 - addq $44, 64(%r14) +# ALL-NEXT: - - 0.33 0.34 1.00 - 1.00 1.00 - - - 0.33 - addq $44, 128(%r14) +# ALL-NEXT: - - 0.34 0.33 - 1.00 - - 1.00 1.00 - 0.33 - addq $44, 192(%r14) +# ALL-NEXT: - 1.00 0.33 0.33 1.00 - - 1.00 - - - 0.34 - addq $44, 256(%r14) +# ALL-NEXT: 1.00 - 0.33 0.34 - - - - 1.00 1.00 - 0.33 - addq $44, 320(%r14) +# ALL-NEXT: - - 0.34 0.33 1.00 - - 1.00 - - 1.00 0.33 - addq $44, 384(%r14) +# ALL-NEXT: - - 0.33 0.33 - - 1.00 - 1.00 1.00 - 0.34 - addq $44, 448(%r14) +# ALL-NEXT: - - 0.33 0.34 1.00 1.00 - 1.00 - - - 0.33 - addq $44, 512(%r14) +# ALL-NEXT: - 1.00 0.34 0.33 - - - - 1.00 1.00 - 0.33 - addq $44, 576(%r14) +# ALL-NEXT: 1.00 - 0.33 0.33 1.00 - - 1.00 - - - 0.34 - addq $44, 640(%r14) + +# ALL: Timeline view: + +# NOALIAS-NEXT: 0123456789 +# NOALIAS-NEXT: Index 0123456789 0123 + +# YESALIAS-NEXT: 0123456789 0123456789 0123456789 01234 +# YESALIAS-NEXT: Index 0123456789 0123456789 0123456789 0123456789 + +# NOALIAS: [0,0] DeeeeeeeeeeeeER. . . addq $44, 64(%r14) +# NOALIAS-NEXT: [0,1] .DeeeeeeeeeeeeER . . addq $44, 128(%r14) +# NOALIAS-NEXT: [0,2] . DeeeeeeeeeeeeER . . addq $44, 192(%r14) +# NOALIAS-NEXT: [0,3] . DeeeeeeeeeeeeER . . addq $44, 256(%r14) +# NOALIAS-NEXT: [0,4] . DeeeeeeeeeeeeER . . addq $44, 320(%r14) +# NOALIAS-NEXT: [0,5] . DeeeeeeeeeeeeER. . addq $44, 384(%r14) +# NOALIAS-NEXT: [0,6] . .DeeeeeeeeeeeeER . addq $44, 448(%r14) +# NOALIAS-NEXT: [0,7] . . DeeeeeeeeeeeeER . addq $44, 512(%r14) +# NOALIAS-NEXT: [0,8] . . DeeeeeeeeeeeeER. addq $44, 576(%r14) +# NOALIAS-NEXT: [0,9] . . DeeeeeeeeeeeeER addq $44, 640(%r14) + +# YESALIAS: [0,0] DeeeeeeeeeeeeER. . . . . . . . . . . . . addq $44, 64(%r14) +# YESALIAS-NEXT: [0,1] .D===========eeeeeeeeeeeeER . . . . . . . . . . addq $44, 128(%r14) +# YESALIAS-NEXT: [0,2] . D======================eeeeeeeeeeeeER . . . . . . . . addq $44, 192(%r14) +# YESALIAS-NEXT: [0,3] . D=================================eeeeeeeeeeeeER . . . . . addq $44, 256(%r14) +# YESALIAS-NEXT: [0,4] . D============================================eeeeeeeeeeeeER . . . addq $44, 320(%r14) +# YESALIAS-NEXT: [0,5] . D=======================================================eeeeeeeeeeeeER addq $44, 384(%r14) +# YESALIAS-NEXT: Truncated display due to cycle limit + +# ALL: Average Wait times (based on the timeline view): +# ALL-NEXT: [0]: Executions +# ALL-NEXT: [1]: Average time spent waiting in a scheduler's queue +# ALL-NEXT: [2]: Average time spent waiting in a scheduler's queue while ready +# ALL-NEXT: [3]: Average time elapsed from WB until retire stage + +# ALL: [0] [1] [2] [3] +# ALL-NEXT: 0. 1 1.0 1.0 0.0 addq $44, 64(%r14) + +# NOALIAS-NEXT: 1. 1 1.0 1.0 0.0 addq $44, 128(%r14) +# NOALIAS-NEXT: 2. 1 1.0 1.0 0.0 addq $44, 192(%r14) +# NOALIAS-NEXT: 3. 1 1.0 1.0 0.0 addq $44, 256(%r14) +# NOALIAS-NEXT: 4. 1 1.0 1.0 0.0 addq $44, 320(%r14) +# NOALIAS-NEXT: 5. 1 1.0 1.0 0.0 addq $44, 384(%r14) +# NOALIAS-NEXT: 6. 1 1.0 1.0 0.0 addq $44, 448(%r14) +# NOALIAS-NEXT: 7. 1 1.0 1.0 0.0 addq $44, 512(%r14) +# NOALIAS-NEXT: 8. 1 1.0 1.0 0.0 addq $44, 576(%r14) +# NOALIAS-NEXT: 9. 1 1.0 1.0 0.0 addq $44, 640(%r14) +# NOALIAS-NEXT: 1 1.0 1.0 0.0 + +# YESALIAS-NEXT: 1. 1 12.0 0.0 0.0 addq $44, 128(%r14) +# YESALIAS-NEXT: 2. 1 23.0 0.0 0.0 addq $44, 192(%r14) +# YESALIAS-NEXT: 3. 1 34.0 0.0 0.0 addq $44, 256(%r14) +# YESALIAS-NEXT: 4. 1 45.0 0.0 0.0 addq $44, 320(%r14) +# YESALIAS-NEXT: 5. 1 56.0 0.0 0.0 addq $44, 384(%r14) +# YESALIAS-NEXT: 6. 1 67.0 0.0 0.0 addq $44, 448(%r14) +# YESALIAS-NEXT: 7. 1 78.0 0.0 0.0 addq $44, 512(%r14) +# YESALIAS-NEXT: 8. 1 89.0 0.0 0.0 addq $44, 576(%r14) +# YESALIAS-NEXT: 9. 1 100.0 0.0 0.0 addq $44, 640(%r14) +# YESALIAS-NEXT: 1 50.5 0.1 0.0 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-adx.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-adx.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-adx.s @@ -0,0 +1,60 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +adcx %ebx, %ecx +adcx (%rbx), %ecx +adcx %rbx, %rcx +adcx (%rbx), %rcx + +adox %ebx, %ecx +adox (%rbx), %ecx +adox %rbx, %rcx +adox (%rbx), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.50 adcxl %ebx, %ecx +# CHECK-NEXT: 2 6 0.50 * adcxl (%rbx), %ecx +# CHECK-NEXT: 1 1 0.50 adcxq %rbx, %rcx +# CHECK-NEXT: 2 6 0.50 * adcxq (%rbx), %rcx +# CHECK-NEXT: 1 1 0.50 adoxl %ebx, %ecx +# CHECK-NEXT: 2 6 0.50 * adoxl (%rbx), %ecx +# CHECK-NEXT: 1 1 0.50 adoxq %rbx, %rcx +# CHECK-NEXT: 2 6 0.50 * adoxq (%rbx), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 4.00 - 1.33 1.33 - - 4.00 - - - - 1.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcxl %ebx, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcxl (%rbx), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcxq %rbx, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcxq (%rbx), %rcx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adoxl %ebx, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adoxl (%rbx), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adoxq %rbx, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adoxq (%rbx), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-aes.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-aes.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-aes.s @@ -0,0 +1,76 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +aesdec %xmm0, %xmm2 +aesdec (%rax), %xmm2 + +aesdeclast %xmm0, %xmm2 +aesdeclast (%rax), %xmm2 + +aesenc %xmm0, %xmm2 +aesenc (%rax), %xmm2 + +aesenclast %xmm0, %xmm2 +aesenclast (%rax), %xmm2 + +aesimc %xmm0, %xmm2 +aesimc (%rax), %xmm2 + +aeskeygenassist $22, %xmm0, %xmm2 +aeskeygenassist $22, (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 aesdec %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * aesdec (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 aesdeclast %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * aesdeclast (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 aesenc %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * aesenc (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 aesenclast %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * aesenclast (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 aesimc %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * aesimc (%rax), %xmm2 +# CHECK-NEXT: 14 7 4.00 aeskeygenassist $22, %xmm0, %xmm2 +# CHECK-NEXT: 14 12 4.00 * aeskeygenassist $22, (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 17.33 10.33 2.00 2.00 - 9.33 2.00 - - - - 2.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - aesdec %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - aesdec (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - aesdeclast %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - aesdeclast (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - aesenc %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - aesenc (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - aesenclast %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - aesenclast (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - aesimc %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - aesimc (%rax), %xmm2 +# CHECK-NEXT: 5.83 2.33 - - - 4.83 1.00 - - - - - - aeskeygenassist $22, %xmm0, %xmm2 +# CHECK-NEXT: 5.50 2.00 0.33 0.33 - 4.50 1.00 - - - - 0.33 - aeskeygenassist $22, (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx1.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx1.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx1.s @@ -0,0 +1,2436 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vaddpd %xmm0, %xmm1, %xmm2 +vaddpd (%rax), %xmm1, %xmm2 + +vaddpd %ymm0, %ymm1, %ymm2 +vaddpd (%rax), %ymm1, %ymm2 + +vaddps %xmm0, %xmm1, %xmm2 +vaddps (%rax), %xmm1, %xmm2 + +vaddps %ymm0, %ymm1, %ymm2 +vaddps (%rax), %ymm1, %ymm2 + +vaddsd %xmm0, %xmm1, %xmm2 +vaddsd (%rax), %xmm1, %xmm2 + +vaddss %xmm0, %xmm1, %xmm2 +vaddss (%rax), %xmm1, %xmm2 + +vaddsubpd %xmm0, %xmm1, %xmm2 +vaddsubpd (%rax), %xmm1, %xmm2 + +vaddsubpd %ymm0, %ymm1, %ymm2 +vaddsubpd (%rax), %ymm1, %ymm2 + +vaddsubps %xmm0, %xmm1, %xmm2 +vaddsubps (%rax), %xmm1, %xmm2 + +vaddsubps %ymm0, %ymm1, %ymm2 +vaddsubps (%rax), %ymm1, %ymm2 + +vaesdec %xmm0, %xmm1, %xmm2 +vaesdec (%rax), %xmm1, %xmm2 + +vaesdeclast %xmm0, %xmm1, %xmm2 +vaesdeclast (%rax), %xmm1, %xmm2 + +vaesenc %xmm0, %xmm1, %xmm2 +vaesenc (%rax), %xmm1, %xmm2 + +vaesenclast %xmm0, %xmm1, %xmm2 +vaesenclast (%rax), %xmm1, %xmm2 + +vaesimc %xmm0, %xmm2 +vaesimc (%rax), %xmm2 + +vaeskeygenassist $22, %xmm0, %xmm2 +vaeskeygenassist $22, (%rax), %xmm2 + +vandnpd %xmm0, %xmm1, %xmm2 +vandnpd (%rax), %xmm1, %xmm2 + +vandnpd %ymm0, %ymm1, %ymm2 +vandnpd (%rax), %ymm1, %ymm2 + +vandnps %xmm0, %xmm1, %xmm2 +vandnps (%rax), %xmm1, %xmm2 + +vandnps %ymm0, %ymm1, %ymm2 +vandnps (%rax), %ymm1, %ymm2 + +vandpd %xmm0, %xmm1, %xmm2 +vandpd (%rax), %xmm1, %xmm2 + +vandpd %ymm0, %ymm1, %ymm2 +vandpd (%rax), %ymm1, %ymm2 + +vandps %xmm0, %xmm1, %xmm2 +vandps (%rax), %xmm1, %xmm2 + +vandps %ymm0, %ymm1, %ymm2 +vandps (%rax), %ymm1, %ymm2 + +vblendpd $11, %xmm0, %xmm1, %xmm2 +vblendpd $11, (%rax), %xmm1, %xmm2 + +vblendpd $11, %ymm0, %ymm1, %ymm2 +vblendpd $11, (%rax), %ymm1, %ymm2 + +vblendps $11, %xmm0, %xmm1, %xmm2 +vblendps $11, (%rax), %xmm1, %xmm2 + +vblendps $11, %ymm0, %ymm1, %ymm2 +vblendps $11, (%rax), %ymm1, %ymm2 + +vblendvpd %xmm3, %xmm0, %xmm1, %xmm2 +vblendvpd %xmm3, (%rax), %xmm1, %xmm2 + +vblendvpd %ymm3, %ymm0, %ymm1, %ymm2 +vblendvpd %ymm3, (%rax), %ymm1, %ymm2 + +vblendvps %xmm3, %xmm0, %xmm1, %xmm2 +vblendvps %xmm3, (%rax), %xmm1, %xmm2 + +vblendvps %ymm3, %ymm0, %ymm1, %ymm2 +vblendvps %ymm3, (%rax), %ymm1, %ymm2 + +vbroadcastf128 (%rax), %ymm2 + +vbroadcastsd (%rax), %ymm2 + +vbroadcastss (%rax), %xmm2 +vbroadcastss (%rax), %ymm2 + +vcmppd $0, %xmm0, %xmm1, %xmm2 +vcmppd $0, (%rax), %xmm1, %xmm2 + +vcmppd $0, %ymm0, %ymm1, %ymm2 +vcmppd $0, (%rax), %ymm1, %ymm2 + +vcmpps $0, %xmm0, %xmm1, %xmm2 +vcmpps $0, (%rax), %xmm1, %xmm2 + +vcmpps $0, %ymm0, %ymm1, %ymm2 +vcmpps $0, (%rax), %ymm1, %ymm2 + +vcmpsd $0, %xmm0, %xmm1, %xmm2 +vcmpsd $0, (%rax), %xmm1, %xmm2 + +vcmpss $0, %xmm0, %xmm1, %xmm2 +vcmpss $0, (%rax), %xmm1, %xmm2 + +vcomisd %xmm0, %xmm1 +vcomisd (%rax), %xmm1 + +vcomiss %xmm0, %xmm1 +vcomiss (%rax), %xmm1 + +vcvtdq2pd %xmm0, %xmm2 +vcvtdq2pd (%rax), %xmm2 + +vcvtdq2pd %xmm0, %ymm2 +vcvtdq2pd (%rax), %ymm2 + +vcvtdq2ps %xmm0, %xmm2 +vcvtdq2ps (%rax), %xmm2 + +vcvtdq2ps %ymm0, %ymm2 +vcvtdq2ps (%rax), %ymm2 + +vcvtpd2dqx %xmm0, %xmm2 +vcvtpd2dqx (%rax), %xmm2 + +vcvtpd2dqy %ymm0, %xmm2 +vcvtpd2dqy (%rax), %xmm2 + +vcvtpd2psx %xmm0, %xmm2 +vcvtpd2psx (%rax), %xmm2 + +vcvtpd2psy %ymm0, %xmm2 +vcvtpd2psy (%rax), %xmm2 + +vcvtps2dq %xmm0, %xmm2 +vcvtps2dq (%rax), %xmm2 + +vcvtps2dq %ymm0, %ymm2 +vcvtps2dq (%rax), %ymm2 + +vcvtps2pd %xmm0, %xmm2 +vcvtps2pd (%rax), %xmm2 + +vcvtps2pd %xmm0, %ymm2 +vcvtps2pd (%rax), %ymm2 + +vcvtsd2si %xmm0, %ecx +vcvtsd2si %xmm0, %rcx +vcvtsd2si (%rax), %ecx +vcvtsd2si (%rax), %rcx + +vcvtsd2ss %xmm0, %xmm1, %xmm2 +vcvtsd2ss (%rax), %xmm1, %xmm2 + +vcvtsi2sdl %ecx, %xmm0, %xmm2 +vcvtsi2sdq %rcx, %xmm0, %xmm2 +vcvtsi2sdl (%rax), %xmm0, %xmm2 +vcvtsi2sdq (%rax), %xmm0, %xmm2 + +vcvtsi2ssl %ecx, %xmm0, %xmm2 +vcvtsi2ssq %rcx, %xmm0, %xmm2 +vcvtsi2ssl (%rax), %xmm0, %xmm2 +vcvtsi2ssq (%rax), %xmm0, %xmm2 + +vcvtss2sd %xmm0, %xmm1, %xmm2 +vcvtss2sd (%rax), %xmm1, %xmm2 + +vcvtss2si %xmm0, %ecx +vcvtss2si %xmm0, %rcx +vcvtss2si (%rax), %ecx +vcvtss2si (%rax), %rcx + +vcvttpd2dqx %xmm0, %xmm2 +vcvttpd2dqx (%rax), %xmm2 + +vcvttpd2dqy %ymm0, %xmm2 +vcvttpd2dqy (%rax), %xmm2 + +vcvttps2dq %xmm0, %xmm2 +vcvttps2dq (%rax), %xmm2 + +vcvttps2dq %ymm0, %ymm2 +vcvttps2dq (%rax), %ymm2 + +vcvttsd2si %xmm0, %ecx +vcvttsd2si %xmm0, %rcx +vcvttsd2si (%rax), %ecx +vcvttsd2si (%rax), %rcx + +vcvttss2si %xmm0, %ecx +vcvttss2si %xmm0, %rcx +vcvttss2si (%rax), %ecx +vcvttss2si (%rax), %rcx + +vdivpd %xmm0, %xmm1, %xmm2 +vdivpd (%rax), %xmm1, %xmm2 + +vdivpd %ymm0, %ymm1, %ymm2 +vdivpd (%rax), %ymm1, %ymm2 + +vdivps %xmm0, %xmm1, %xmm2 +vdivps (%rax), %xmm1, %xmm2 + +vdivps %ymm0, %ymm1, %ymm2 +vdivps (%rax), %ymm1, %ymm2 + +vdivsd %xmm0, %xmm1, %xmm2 +vdivsd (%rax), %xmm1, %xmm2 + +vdivss %xmm0, %xmm1, %xmm2 +vdivss (%rax), %xmm1, %xmm2 + +vdppd $22, %xmm0, %xmm1, %xmm2 +vdppd $22, (%rax), %xmm1, %xmm2 + +vdpps $22, %xmm0, %xmm1, %xmm2 +vdpps $22, (%rax), %xmm1, %xmm2 + +vdpps $22, %ymm0, %ymm1, %ymm2 +vdpps $22, (%rax), %ymm1, %ymm2 + +vextractf128 $1, %ymm0, %xmm2 +vextractf128 $1, %ymm0, (%rax) + +vextractps $1, %xmm0, %rcx +vextractps $1, %xmm0, (%rax) + +vhaddpd %xmm0, %xmm1, %xmm2 +vhaddpd (%rax), %xmm1, %xmm2 + +vhaddpd %ymm0, %ymm1, %ymm2 +vhaddpd (%rax), %ymm1, %ymm2 + +vhaddps %xmm0, %xmm1, %xmm2 +vhaddps (%rax), %xmm1, %xmm2 + +vhaddps %ymm0, %ymm1, %ymm2 +vhaddps (%rax), %ymm1, %ymm2 + +vhsubpd %xmm0, %xmm1, %xmm2 +vhsubpd (%rax), %xmm1, %xmm2 + +vhsubpd %ymm0, %ymm1, %ymm2 +vhsubpd (%rax), %ymm1, %ymm2 + +vhsubps %xmm0, %xmm1, %xmm2 +vhsubps (%rax), %xmm1, %xmm2 + +vhsubps %ymm0, %ymm1, %ymm2 +vhsubps (%rax), %ymm1, %ymm2 + +vinsertf128 $1, %xmm0, %ymm1, %ymm2 +vinsertf128 $1, (%rax), %ymm1, %ymm2 + +vinsertps $1, %xmm0, %xmm1, %xmm2 +vinsertps $1, (%rax), %xmm1, %xmm2 + +vlddqu (%rax), %xmm2 +vlddqu (%rax), %ymm2 + +vldmxcsr (%rax) + +vmaskmovdqu %xmm0, %xmm1 + +vmaskmovpd (%rax), %xmm0, %xmm2 +vmaskmovpd (%rax), %ymm0, %ymm2 + +vmaskmovpd %xmm0, %xmm1, (%rax) +vmaskmovpd %ymm0, %ymm1, (%rax) + +vmaskmovps (%rax), %xmm0, %xmm2 +vmaskmovps (%rax), %ymm0, %ymm2 + +vmaskmovps %xmm0, %xmm1, (%rax) +vmaskmovps %ymm0, %ymm1, (%rax) + +vmaxpd %xmm0, %xmm1, %xmm2 +vmaxpd (%rax), %xmm1, %xmm2 + +vmaxpd %ymm0, %ymm1, %ymm2 +vmaxpd (%rax), %ymm1, %ymm2 + +vmaxps %xmm0, %xmm1, %xmm2 +vmaxps (%rax), %xmm1, %xmm2 + +vmaxps %ymm0, %ymm1, %ymm2 +vmaxps (%rax), %ymm1, %ymm2 + +vmaxsd %xmm0, %xmm1, %xmm2 +vmaxsd (%rax), %xmm1, %xmm2 + +vmaxss %xmm0, %xmm1, %xmm2 +vmaxss (%rax), %xmm1, %xmm2 + +vminpd %xmm0, %xmm1, %xmm2 +vminpd (%rax), %xmm1, %xmm2 + +vminpd %ymm0, %ymm1, %ymm2 +vminpd (%rax), %ymm1, %ymm2 + +vminps %xmm0, %xmm1, %xmm2 +vminps (%rax), %xmm1, %xmm2 + +vminps %ymm0, %ymm1, %ymm2 +vminps (%rax), %ymm1, %ymm2 + +vminsd %xmm0, %xmm1, %xmm2 +vminsd (%rax), %xmm1, %xmm2 + +vminss %xmm0, %xmm1, %xmm2 +vminss (%rax), %xmm1, %xmm2 + +vmovapd %xmm0, %xmm2 +vmovapd %xmm0, (%rax) +vmovapd (%rax), %xmm2 + +vmovapd %ymm0, %ymm2 +vmovapd %ymm0, (%rax) +vmovapd (%rax), %ymm2 + +vmovaps %xmm0, %xmm2 +vmovaps %xmm0, (%rax) +vmovaps (%rax), %xmm2 + +vmovaps %ymm0, %ymm2 +vmovaps %ymm0, (%rax) +vmovaps (%rax), %ymm2 + +vmovd %eax, %xmm2 +vmovd (%rax), %xmm2 + +vmovd %xmm0, %ecx +vmovd %xmm0, (%rax) + +vmovddup %xmm0, %xmm2 +vmovddup (%rax), %xmm2 + +vmovddup %ymm0, %ymm2 +vmovddup (%rax), %ymm2 + +vmovdqa %xmm0, %xmm2 +vmovdqa %xmm0, (%rax) +vmovdqa (%rax), %xmm2 + +vmovdqa %ymm0, %ymm2 +vmovdqa %ymm0, (%rax) +vmovdqa (%rax), %ymm2 + +vmovdqu %xmm0, %xmm2 +vmovdqu %xmm0, (%rax) +vmovdqu (%rax), %xmm2 + +vmovdqu %ymm0, %ymm2 +vmovdqu %ymm0, (%rax) +vmovdqu (%rax), %ymm2 + +vmovhlps %xmm0, %xmm1, %xmm2 +vmovlhps %xmm0, %xmm1, %xmm2 + +vmovhpd %xmm0, (%rax) +vmovhpd (%rax), %xmm1, %xmm2 + +vmovhps %xmm0, (%rax) +vmovhps (%rax), %xmm1, %xmm2 + +vmovlpd %xmm0, (%rax) +vmovlpd (%rax), %xmm1, %xmm2 + +vmovlps %xmm0, (%rax) +vmovlps (%rax), %xmm1, %xmm2 + +vmovmskpd %xmm0, %rcx +vmovmskpd %ymm0, %rcx + +vmovmskps %xmm0, %rcx +vmovmskps %ymm0, %rcx + +vmovntdq %xmm0, (%rax) +vmovntdq %ymm0, (%rax) + +vmovntdqa (%rax), %xmm2 +vmovntdqa (%rax), %ymm2 + +vmovntpd %xmm0, (%rax) +vmovntpd %ymm0, (%rax) + +vmovntps %xmm0, (%rax) +vmovntps %ymm0, (%rax) + +vmovq %xmm0, %xmm2 + +vmovq %rax, %xmm2 +vmovq (%rax), %xmm2 + +vmovq %xmm0, %rcx +vmovq %xmm0, (%rax) + +vmovsd %xmm0, %xmm1, %xmm2 +vmovsd %xmm0, (%rax) +vmovsd (%rax), %xmm2 + +vmovshdup %xmm0, %xmm2 +vmovshdup (%rax), %xmm2 + +vmovshdup %ymm0, %ymm2 +vmovshdup (%rax), %ymm2 + +vmovsldup %xmm0, %xmm2 +vmovsldup (%rax), %xmm2 + +vmovsldup %ymm0, %ymm2 +vmovsldup (%rax), %ymm2 + +vmovss %xmm0, %xmm1, %xmm2 +vmovss %xmm0, (%rax) +vmovss (%rax), %xmm2 + +vmovupd %xmm0, %xmm2 +vmovupd %xmm0, (%rax) +vmovupd (%rax), %xmm2 + +vmovupd %ymm0, %ymm2 +vmovupd %ymm0, (%rax) +vmovupd (%rax), %ymm2 + +vmovups %xmm0, %xmm2 +vmovups %xmm0, (%rax) +vmovups (%rax), %xmm2 + +vmovups %ymm0, %ymm2 +vmovups %ymm0, (%rax) +vmovups (%rax), %ymm2 + +vmpsadbw $1, %xmm0, %xmm1, %xmm2 +vmpsadbw $1, (%rax), %xmm1, %xmm2 + +vmulpd %xmm0, %xmm1, %xmm2 +vmulpd (%rax), %xmm1, %xmm2 + +vmulpd %ymm0, %ymm1, %ymm2 +vmulpd (%rax), %ymm1, %ymm2 + +vmulps %xmm0, %xmm1, %xmm2 +vmulps (%rax), %xmm1, %xmm2 + +vmulps %ymm0, %ymm1, %ymm2 +vmulps (%rax), %ymm1, %ymm2 + +vmulsd %xmm0, %xmm1, %xmm2 +vmulsd (%rax), %xmm1, %xmm2 + +vmulss %xmm0, %xmm1, %xmm2 +vmulss (%rax), %xmm1, %xmm2 + +vorpd %xmm0, %xmm1, %xmm2 +vorpd (%rax), %xmm1, %xmm2 + +vorpd %ymm0, %ymm1, %ymm2 +vorpd (%rax), %ymm1, %ymm2 + +vorps %xmm0, %xmm1, %xmm2 +vorps (%rax), %xmm1, %xmm2 + +vorps %ymm0, %ymm1, %ymm2 +vorps (%rax), %ymm1, %ymm2 + +vpabsb %xmm0, %xmm2 +vpabsb (%rax), %xmm2 + +vpabsd %xmm0, %xmm2 +vpabsd (%rax), %xmm2 + +vpabsw %xmm0, %xmm2 +vpabsw (%rax), %xmm2 + +vpackssdw %xmm0, %xmm1, %xmm2 +vpackssdw (%rax), %xmm1, %xmm2 + +vpacksswb %xmm0, %xmm1, %xmm2 +vpacksswb (%rax), %xmm1, %xmm2 + +vpackusdw %xmm0, %xmm1, %xmm2 +vpackusdw (%rax), %xmm1, %xmm2 + +vpackuswb %xmm0, %xmm1, %xmm2 +vpackuswb (%rax), %xmm1, %xmm2 + +vpaddb %xmm0, %xmm1, %xmm2 +vpaddb (%rax), %xmm1, %xmm2 + +vpaddd %xmm0, %xmm1, %xmm2 +vpaddd (%rax), %xmm1, %xmm2 + +vpaddq %xmm0, %xmm1, %xmm2 +vpaddq (%rax), %xmm1, %xmm2 + +vpaddsb %xmm0, %xmm1, %xmm2 +vpaddsb (%rax), %xmm1, %xmm2 + +vpaddsw %xmm0, %xmm1, %xmm2 +vpaddsw (%rax), %xmm1, %xmm2 + +vpaddusb %xmm0, %xmm1, %xmm2 +vpaddusb (%rax), %xmm1, %xmm2 + +vpaddusw %xmm0, %xmm1, %xmm2 +vpaddusw (%rax), %xmm1, %xmm2 + +vpaddw %xmm0, %xmm1, %xmm2 +vpaddw (%rax), %xmm1, %xmm2 + +vpalignr $1, %xmm0, %xmm1, %xmm2 +vpalignr $1, (%rax), %xmm1, %xmm2 + +vpand %xmm0, %xmm1, %xmm2 +vpand (%rax), %xmm1, %xmm2 + +vpandn %xmm0, %xmm1, %xmm2 +vpandn (%rax), %xmm1, %xmm2 + +vpavgb %xmm0, %xmm1, %xmm2 +vpavgb (%rax), %xmm1, %xmm2 + +vpavgw %xmm0, %xmm1, %xmm2 +vpavgw (%rax), %xmm1, %xmm2 + +vpblendvb %xmm3, %xmm0, %xmm1, %xmm2 +vpblendvb %xmm3, (%rax), %xmm1, %xmm2 + +vpblendw $11, %xmm0, %xmm1, %xmm2 +vpblendw $11, (%rax), %xmm1, %xmm2 + +vpclmulqdq $11, %xmm0, %xmm1, %xmm2 +vpclmulqdq $11, (%rax), %xmm1, %xmm2 + +vpcmpeqb %xmm0, %xmm1, %xmm2 +vpcmpeqb (%rax), %xmm1, %xmm2 + +vpcmpeqd %xmm0, %xmm1, %xmm2 +vpcmpeqd (%rax), %xmm1, %xmm2 + +vpcmpeqq %xmm0, %xmm1, %xmm2 +vpcmpeqq (%rax), %xmm1, %xmm2 + +vpcmpeqw %xmm0, %xmm1, %xmm2 +vpcmpeqw (%rax), %xmm1, %xmm2 + +vpcmpestri $1, %xmm0, %xmm2 +vpcmpestri $1, (%rax), %xmm2 + +vpcmpestrm $1, %xmm0, %xmm2 +vpcmpestrm $1, (%rax), %xmm2 + +vpcmpgtb %xmm0, %xmm1, %xmm2 +vpcmpgtb (%rax), %xmm1, %xmm2 + +vpcmpgtd %xmm0, %xmm1, %xmm2 +vpcmpgtd (%rax), %xmm1, %xmm2 + +vpcmpgtq %xmm0, %xmm1, %xmm2 +vpcmpgtq (%rax), %xmm1, %xmm2 + +vpcmpgtw %xmm0, %xmm1, %xmm2 +vpcmpgtw (%rax), %xmm1, %xmm2 + +vpcmpistri $1, %xmm0, %xmm2 +vpcmpistri $1, (%rax), %xmm2 + +vpcmpistrm $1, %xmm0, %xmm2 +vpcmpistrm $1, (%rax), %xmm2 + +vperm2f128 $1, %ymm0, %ymm1, %ymm2 +vperm2f128 $1, (%rax), %ymm1, %ymm2 + +vpermilpd $1, %xmm0, %xmm2 +vpermilpd $1, (%rax), %xmm2 +vpermilpd %xmm0, %xmm1, %xmm2 +vpermilpd (%rax), %xmm1, %xmm2 + +vpermilpd $1, %ymm0, %ymm2 +vpermilpd $1, (%rax), %ymm2 +vpermilpd %ymm0, %ymm1, %ymm2 +vpermilpd (%rax), %ymm1, %ymm2 + +vpermilps $1, %xmm0, %xmm2 +vpermilps $1, (%rax), %xmm2 +vpermilps %xmm0, %xmm1, %xmm2 +vpermilps (%rax), %xmm1, %xmm2 + +vpermilps $1, %ymm0, %ymm2 +vpermilps $1, (%rax), %ymm2 +vpermilps %ymm0, %ymm1, %ymm2 +vpermilps (%rax), %ymm1, %ymm2 + +vpextrb $1, %xmm0, %ecx +vpextrb $1, %xmm0, (%rax) + +vpextrd $1, %xmm0, %ecx +vpextrd $1, %xmm0, (%rax) + +vpextrq $1, %xmm0, %rcx +vpextrq $1, %xmm0, (%rax) + +vpextrw $1, %xmm0, %ecx +vpextrw $1, %xmm0, (%rax) + +vphaddd %xmm0, %xmm1, %xmm2 +vphaddd (%rax), %xmm1, %xmm2 + +vphaddsw %xmm0, %xmm1, %xmm2 +vphaddsw (%rax), %xmm1, %xmm2 + +vphaddw %xmm0, %xmm1, %xmm2 +vphaddw (%rax), %xmm1, %xmm2 + +vphminposuw %xmm0, %xmm2 +vphminposuw (%rax), %xmm2 + +vphsubd %xmm0, %xmm1, %xmm2 +vphsubd (%rax), %xmm1, %xmm2 + +vphsubsw %xmm0, %xmm1, %xmm2 +vphsubsw (%rax), %xmm1, %xmm2 + +vphsubw %xmm0, %xmm1, %xmm2 +vphsubw (%rax), %xmm1, %xmm2 + +vpinsrb $1, %eax, %xmm1, %xmm2 +vpinsrb $1, (%rax), %xmm1, %xmm2 + +vpinsrd $1, %eax, %xmm1, %xmm2 +vpinsrd $1, (%rax), %xmm1, %xmm2 + +vpinsrq $1, %rax, %xmm1, %xmm2 +vpinsrq $1, (%rax), %xmm1, %xmm2 + +vpinsrw $1, %eax, %xmm1, %xmm2 +vpinsrw $1, (%rax), %xmm1, %xmm2 + +vpmaddubsw %xmm0, %xmm1, %xmm2 +vpmaddubsw (%rax), %xmm1, %xmm2 + +vpmaddwd %xmm0, %xmm1, %xmm2 +vpmaddwd (%rax), %xmm1, %xmm2 + +vpmaxsb %xmm0, %xmm1, %xmm2 +vpmaxsb (%rax), %xmm1, %xmm2 + +vpmaxsd %xmm0, %xmm1, %xmm2 +vpmaxsd (%rax), %xmm1, %xmm2 + +vpmaxsw %xmm0, %xmm1, %xmm2 +vpmaxsw (%rax), %xmm1, %xmm2 + +vpmaxub %xmm0, %xmm1, %xmm2 +vpmaxub (%rax), %xmm1, %xmm2 + +vpmaxud %xmm0, %xmm1, %xmm2 +vpmaxud (%rax), %xmm1, %xmm2 + +vpmaxuw %xmm0, %xmm1, %xmm2 +vpmaxuw (%rax), %xmm1, %xmm2 + +vpminsb %xmm0, %xmm1, %xmm2 +vpminsb (%rax), %xmm1, %xmm2 + +vpminsd %xmm0, %xmm1, %xmm2 +vpminsd (%rax), %xmm1, %xmm2 + +vpminsw %xmm0, %xmm1, %xmm2 +vpminsw (%rax), %xmm1, %xmm2 + +vpminub %xmm0, %xmm1, %xmm2 +vpminub (%rax), %xmm1, %xmm2 + +vpminud %xmm0, %xmm1, %xmm2 +vpminud (%rax), %xmm1, %xmm2 + +vpminuw %xmm0, %xmm1, %xmm2 +vpminuw (%rax), %xmm1, %xmm2 + +vpmovmskb %xmm0, %rcx + +vpmovsxbd %xmm0, %xmm2 +vpmovsxbd (%rax), %xmm2 + +vpmovsxbq %xmm0, %xmm2 +vpmovsxbq (%rax), %xmm2 + +vpmovsxbw %xmm0, %xmm2 +vpmovsxbw (%rax), %xmm2 + +vpmovsxdq %xmm0, %xmm2 +vpmovsxdq (%rax), %xmm2 + +vpmovsxwd %xmm0, %xmm2 +vpmovsxwd (%rax), %xmm2 + +vpmovsxwq %xmm0, %xmm2 +vpmovsxwq (%rax), %xmm2 + +vpmovzxbd %xmm0, %xmm2 +vpmovzxbd (%rax), %xmm2 + +vpmovzxbq %xmm0, %xmm2 +vpmovzxbq (%rax), %xmm2 + +vpmovzxbw %xmm0, %xmm2 +vpmovzxbw (%rax), %xmm2 + +vpmovzxdq %xmm0, %xmm2 +vpmovzxdq (%rax), %xmm2 + +vpmovzxwd %xmm0, %xmm2 +vpmovzxwd (%rax), %xmm2 + +vpmovzxwq %xmm0, %xmm2 +vpmovzxwq (%rax), %xmm2 + +vpmuldq %xmm0, %xmm1, %xmm2 +vpmuldq (%rax), %xmm1, %xmm2 + +vpmulhrsw %xmm0, %xmm1, %xmm2 +vpmulhrsw (%rax), %xmm1, %xmm2 + +vpmulhuw %xmm0, %xmm1, %xmm2 +vpmulhuw (%rax), %xmm1, %xmm2 + +vpmulhw %xmm0, %xmm1, %xmm2 +vpmulhw (%rax), %xmm1, %xmm2 + +vpmulld %xmm0, %xmm1, %xmm2 +vpmulld (%rax), %xmm1, %xmm2 + +vpmullw %xmm0, %xmm1, %xmm2 +vpmullw (%rax), %xmm1, %xmm2 + +vpmuludq %xmm0, %xmm1, %xmm2 +vpmuludq (%rax), %xmm1, %xmm2 + +vpor %xmm0, %xmm1, %xmm2 +vpor (%rax), %xmm1, %xmm2 + +vpsadbw %xmm0, %xmm1, %xmm2 +vpsadbw (%rax), %xmm1, %xmm2 + +vpshufb %xmm0, %xmm1, %xmm2 +vpshufb (%rax), %xmm1, %xmm2 + +vpshufd $1, %xmm0, %xmm2 +vpshufd $1, (%rax), %xmm2 + +vpshufhw $1, %xmm0, %xmm2 +vpshufhw $1, (%rax), %xmm2 + +vpshuflw $1, %xmm0, %xmm2 +vpshuflw $1, (%rax), %xmm2 + +vpsignb %xmm0, %xmm1, %xmm2 +vpsignb (%rax), %xmm1, %xmm2 + +vpsignd %xmm0, %xmm1, %xmm2 +vpsignd (%rax), %xmm1, %xmm2 + +vpsignw %xmm0, %xmm1, %xmm2 +vpsignw (%rax), %xmm1, %xmm2 + +vpslld $1, %xmm0, %xmm2 +vpslld %xmm0, %xmm1, %xmm2 +vpslld (%rax), %xmm1, %xmm2 + +vpslldq $1, %xmm1, %xmm2 + +vpsllq $1, %xmm0, %xmm2 +vpsllq %xmm0, %xmm1, %xmm2 +vpsllq (%rax), %xmm1, %xmm2 + +vpsllw $1, %xmm0, %xmm2 +vpsllw %xmm0, %xmm1, %xmm2 +vpsllw (%rax), %xmm1, %xmm2 + +vpsrad $1, %xmm0, %xmm2 +vpsrad %xmm0, %xmm1, %xmm2 +vpsrad (%rax), %xmm1, %xmm2 + +vpsraw $1, %xmm0, %xmm2 +vpsraw %xmm0, %xmm1, %xmm2 +vpsraw (%rax), %xmm1, %xmm2 + +vpsrld $1, %xmm0, %xmm2 +vpsrld %xmm0, %xmm1, %xmm2 +vpsrld (%rax), %xmm1, %xmm2 + +vpsrldq $1, %xmm1, %xmm2 + +vpsrlq $1, %xmm0, %xmm2 +vpsrlq %xmm0, %xmm1, %xmm2 +vpsrlq (%rax), %xmm1, %xmm2 + +vpsrlw $1, %xmm0, %xmm2 +vpsrlw %xmm0, %xmm1, %xmm2 +vpsrlw (%rax), %xmm1, %xmm2 + +vpsubb %xmm0, %xmm1, %xmm2 +vpsubb (%rax), %xmm1, %xmm2 + +vpsubd %xmm0, %xmm1, %xmm2 +vpsubd (%rax), %xmm1, %xmm2 + +vpsubq %xmm0, %xmm1, %xmm2 +vpsubq (%rax), %xmm1, %xmm2 + +vpsubsb %xmm0, %xmm1, %xmm2 +vpsubsb (%rax), %xmm1, %xmm2 + +vpsubsw %xmm0, %xmm1, %xmm2 +vpsubsw (%rax), %xmm1, %xmm2 + +vpsubusb %xmm0, %xmm1, %xmm2 +vpsubusb (%rax), %xmm1, %xmm2 + +vpsubusw %xmm0, %xmm1, %xmm2 +vpsubusw (%rax), %xmm1, %xmm2 + +vpsubw %xmm0, %xmm1, %xmm2 +vpsubw (%rax), %xmm1, %xmm2 + +vptest %xmm0, %xmm1 +vptest (%rax), %xmm1 + +vptest %ymm0, %ymm1 +vptest (%rax), %ymm1 + +vpunpckhbw %xmm0, %xmm1, %xmm2 +vpunpckhbw (%rax), %xmm1, %xmm2 + +vpunpckhdq %xmm0, %xmm1, %xmm2 +vpunpckhdq (%rax), %xmm1, %xmm2 + +vpunpckhqdq %xmm0, %xmm1, %xmm2 +vpunpckhqdq (%rax), %xmm1, %xmm2 + +vpunpckhwd %xmm0, %xmm1, %xmm2 +vpunpckhwd (%rax), %xmm1, %xmm2 + +vpunpcklbw %xmm0, %xmm1, %xmm2 +vpunpcklbw (%rax), %xmm1, %xmm2 + +vpunpckldq %xmm0, %xmm1, %xmm2 +vpunpckldq (%rax), %xmm1, %xmm2 + +vpunpcklqdq %xmm0, %xmm1, %xmm2 +vpunpcklqdq (%rax), %xmm1, %xmm2 + +vpunpcklwd %xmm0, %xmm1, %xmm2 +vpunpcklwd (%rax), %xmm1, %xmm2 + +vpxor %xmm0, %xmm1, %xmm2 +vpxor (%rax), %xmm1, %xmm2 + +vrcpps %xmm0, %xmm2 +vrcpps (%rax), %xmm2 + +vrcpps %ymm0, %ymm2 +vrcpps (%rax), %ymm2 + +vrcpss %xmm0, %xmm1, %xmm2 +vrcpss (%rax), %xmm1, %xmm2 + +vroundpd $1, %xmm0, %xmm2 +vroundpd $1, (%rax), %xmm2 + +vroundpd $1, %ymm0, %ymm2 +vroundpd $1, (%rax), %ymm2 + +vroundps $1, %xmm0, %xmm2 +vroundps $1, (%rax), %xmm2 + +vroundps $1, %ymm0, %ymm2 +vroundps $1, (%rax), %ymm2 + +vroundsd $1, %xmm0, %xmm1, %xmm2 +vroundsd $1, (%rax), %xmm1, %xmm2 + +vroundss $1, %xmm0, %xmm1, %xmm2 +vroundss $1, (%rax), %xmm1, %xmm2 + +vrsqrtps %xmm0, %xmm2 +vrsqrtps (%rax), %xmm2 + +vrsqrtps %ymm0, %ymm2 +vrsqrtps (%rax), %ymm2 + +vrsqrtss %xmm0, %xmm1, %xmm2 +vrsqrtss (%rax), %xmm1, %xmm2 + +vshufpd $1, %xmm0, %xmm1, %xmm2 +vshufpd $1, (%rax), %xmm1, %xmm2 + +vshufpd $1, %ymm0, %ymm1, %ymm2 +vshufpd $1, (%rax), %ymm1, %ymm2 + +vshufps $1, %xmm0, %xmm1, %xmm2 +vshufps $1, (%rax), %xmm1, %xmm2 + +vshufps $1, %ymm0, %ymm1, %ymm2 +vshufps $1, (%rax), %ymm1, %ymm2 + +vsqrtpd %xmm0, %xmm2 +vsqrtpd (%rax), %xmm2 + +vsqrtpd %ymm0, %ymm2 +vsqrtpd (%rax), %ymm2 + +vsqrtps %xmm0, %xmm2 +vsqrtps (%rax), %xmm2 + +vsqrtps %ymm0, %ymm2 +vsqrtps (%rax), %ymm2 + +vsqrtsd %xmm0, %xmm1, %xmm2 +vsqrtsd (%rax), %xmm1, %xmm2 + +vsqrtss %xmm0, %xmm1, %xmm2 +vsqrtss (%rax), %xmm1, %xmm2 + +vstmxcsr (%rax) + +vsubpd %xmm0, %xmm1, %xmm2 +vsubpd (%rax), %xmm1, %xmm2 + +vsubpd %ymm0, %ymm1, %ymm2 +vsubpd (%rax), %ymm1, %ymm2 + +vsubps %xmm0, %xmm1, %xmm2 +vsubps (%rax), %xmm1, %xmm2 + +vsubps %ymm0, %ymm1, %ymm2 +vsubps (%rax), %ymm1, %ymm2 + +vsubsd %xmm0, %xmm1, %xmm2 +vsubsd (%rax), %xmm1, %xmm2 + +vsubss %xmm0, %xmm1, %xmm2 +vsubss (%rax), %xmm1, %xmm2 + +vtestpd %xmm0, %xmm1 +vtestpd (%rax), %xmm1 + +vtestpd %ymm0, %ymm1 +vtestpd (%rax), %ymm1 + +vtestps %xmm0, %xmm1 +vtestps (%rax), %xmm1 + +vtestps %ymm0, %ymm1 +vtestps (%rax), %ymm1 + +vucomisd %xmm0, %xmm1 +vucomisd (%rax), %xmm1 + +vucomiss %xmm0, %xmm1 +vucomiss (%rax), %xmm1 + +vunpckhpd %xmm0, %xmm1, %xmm2 +vunpckhpd (%rax), %xmm1, %xmm2 + +vunpckhpd %ymm0, %ymm1, %ymm2 +vunpckhpd (%rax), %ymm1, %ymm2 + +vunpckhps %xmm0, %xmm1, %xmm2 +vunpckhps (%rax), %xmm1, %xmm2 + +vunpckhps %ymm0, %ymm1, %ymm2 +vunpckhps (%rax), %ymm1, %ymm2 + +vunpcklpd %xmm0, %xmm1, %xmm2 +vunpcklpd (%rax), %xmm1, %xmm2 + +vunpcklpd %ymm0, %ymm1, %ymm2 +vunpcklpd (%rax), %ymm1, %ymm2 + +vunpcklps %xmm0, %xmm1, %xmm2 +vunpcklps (%rax), %xmm1, %xmm2 + +vunpcklps %ymm0, %ymm1, %ymm2 +vunpcklps (%rax), %ymm1, %ymm2 + +vxorpd %xmm0, %xmm1, %xmm2 +vxorpd (%rax), %xmm1, %xmm2 + +vxorpd %ymm0, %ymm1, %ymm2 +vxorpd (%rax), %ymm1, %ymm2 + +vxorps %xmm0, %xmm1, %xmm2 +vxorps (%rax), %xmm1, %xmm2 + +vxorps %ymm0, %ymm1, %ymm2 +vxorps (%rax), %ymm1, %ymm2 + +vzeroall +vzeroupper + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 0.50 vaddpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 0.50 vaddps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 0.50 vaddsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vaddsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 0.50 vaddsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vaddsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vaddsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vaddsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vaesdec %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vaesdec (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vaesdeclast %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vaesdeclast (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vaesenc %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vaesenc (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vaesenclast %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vaesenclast (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 vaesimc %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vaesimc (%rax), %xmm2 +# CHECK-NEXT: 14 7 4.00 vaeskeygenassist $22, %xmm0, %xmm2 +# CHECK-NEXT: 14 12 4.00 * vaeskeygenassist $22, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vandnps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vandnps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vandpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vandpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vandps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vandps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vandps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vandps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vblendpd $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vblendpd $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vblendpd $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vblendpd $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vblendps $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vblendps $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vblendps $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vblendps $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 3 1.00 vblendvpd %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vblendvpd %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 3 1.00 vblendvpd %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vblendvpd %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 3 1.00 vblendvps %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vblendvps %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 3 1.00 vblendvps %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vblendvps %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 8 0.33 * vbroadcastf128 (%rax), %ymm2 +# CHECK-NEXT: 1 8 0.33 * vbroadcastsd (%rax), %ymm2 +# CHECK-NEXT: 1 7 0.33 * vbroadcastss (%rax), %xmm2 +# CHECK-NEXT: 1 8 0.33 * vbroadcastss (%rax), %ymm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcmpeqpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcmpeqpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcmpeqps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcmpeqps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcmpeqsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vcmpeqss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcmpeqss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vcomisd %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vcomisd (%rax), %xmm1 +# CHECK-NEXT: 1 3 1.00 vcomiss %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vcomiss (%rax), %xmm1 +# CHECK-NEXT: 2 5 1.00 vcvtdq2pd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %xmm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax), %ymm2 +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax), %ymm2 +# CHECK-NEXT: 2 5 1.00 vcvtpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dqx (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %ymm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dqy (%rax), %xmm2 +# CHECK-NEXT: 2 5 1.00 vcvtpd2ps %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2psx (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %ymm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2psy (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax), %ymm2 +# CHECK-NEXT: 2 5 1.00 vcvtps2pd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %xmm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax), %ymm2 +# CHECK-NEXT: 2 7 1.00 vcvtsd2si %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 vcvtsd2si %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * vcvtsd2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvtsd2si (%rax), %rcx +# CHECK-NEXT: 2 5 1.00 vcvtsd2ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvtsd2ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtsi2sd %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtsi2sd %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtsi2sdl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtsi2sdq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtsi2ss %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 3 8 2.00 vcvtsi2ss %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtsi2ssl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvtsi2ssq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 5 1.00 vcvtss2sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtss2sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtss2si %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 vcvtss2si %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * vcvtss2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvtss2si (%rax), %rcx +# CHECK-NEXT: 2 5 1.00 vcvttpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dqx (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %ymm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dqy (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax), %ymm2 +# CHECK-NEXT: 2 7 1.00 vcvttsd2si %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 vcvttsd2si %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * vcvttsd2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvttsd2si (%rax), %rcx +# CHECK-NEXT: 2 7 1.00 vcvttss2si %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 vcvttss2si %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * vcvttss2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvttss2si (%rax), %rcx +# CHECK-NEXT: 1 14 1.00 vdivpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 14 1.00 vdivpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 11 1.00 vdivps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 11 1.00 vdivps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 14 1.00 vdivsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 20 1.00 * vdivsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 11 1.00 vdivss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 18 1.00 * vdivss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 9 1.00 vdppd $22, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 16 1.00 * vdppd $22, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 6 14 1.67 vdpps $22, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 7 21 1.67 * vdpps $22, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 6 14 1.67 vdpps $22, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 7 22 1.67 * vdpps $22, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vextractf128 $1, %ymm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vextractf128 $1, %ymm0, (%rax) +# CHECK-NEXT: 2 4 1.00 vextractps $1, %xmm0, %ecx +# CHECK-NEXT: 3 12 1.00 * vextractps $1, %xmm0, (%rax) +# CHECK-NEXT: 3 5 2.00 vhaddpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 12 2.00 * vhaddpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 5 2.00 vhaddpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 13 2.00 * vhaddpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 5 2.00 vhaddps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 12 2.00 * vhaddps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 5 2.00 vhaddps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 13 2.00 * vhaddps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 5 2.00 vhsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 12 2.00 * vhsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 5 2.00 vhsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 13 2.00 * vhsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 5 2.00 vhsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 12 2.00 * vhsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 5 2.00 vhsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 13 2.00 * vhsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vinsertf128 $1, %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vinsertf128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vinsertps $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vinsertps $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vlddqu (%rax), %xmm2 +# CHECK-NEXT: 1 8 0.33 * vlddqu (%rax), %ymm2 +# CHECK-NEXT: 3 7 1.00 * * U vldmxcsr (%rax) +# CHECK-NEXT: 2 1 1.00 * * U vmaskmovdqu %xmm0, %xmm1 +# CHECK-NEXT: 2 8 0.33 * vmaskmovpd (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 9 0.33 * vmaskmovpd (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 3 14 1.00 * * vmaskmovpd %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 3 14 1.00 * * vmaskmovpd %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 2 8 0.33 * vmaskmovps (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 9 0.33 * vmaskmovps (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 3 14 1.00 * * vmaskmovps %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 3 14 1.00 * * vmaskmovps %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 1 4 0.50 vmaxpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmaxpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vmaxps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmaxps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vmaxsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmaxsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmaxss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmaxss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vminpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vminpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vminps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vminps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vminps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vminps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vminsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vminsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vminss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vminss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovapd %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovapd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovapd (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovapd %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovapd %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovapd (%rax), %ymm2 +# CHECK-NEXT: 0 1 0.00 vmovaps %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovaps %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovaps (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovaps %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovaps %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovaps (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vmovd %eax, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vmovd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 vmovd %xmm0, %ecx +# CHECK-NEXT: 2 12 0.50 * vmovd %xmm0, (%rax) +# CHECK-NEXT: 1 1 1.00 vmovddup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vmovddup (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 vmovddup %ymm0, %ymm2 +# CHECK-NEXT: 1 8 0.33 * vmovddup (%rax), %ymm2 +# CHECK-NEXT: 0 1 0.00 vmovdqa %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovdqa %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovdqa (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovdqa %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovdqa %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovdqa (%rax), %ymm2 +# CHECK-NEXT: 0 1 0.00 vmovdqu %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovdqu %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovdqu (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovdqu %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovdqu %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovdqu (%rax), %ymm2 +# CHECK-NEXT: 1 1 1.00 vmovhlps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vmovlhps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovhpd %xmm0, (%rax) +# CHECK-NEXT: 2 8 1.00 * vmovhpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovhps %xmm0, (%rax) +# CHECK-NEXT: 2 8 1.00 * vmovhps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovlpd %xmm0, (%rax) +# CHECK-NEXT: 2 8 0.50 * vmovlpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovlps %xmm0, (%rax) +# CHECK-NEXT: 2 8 0.50 * vmovlps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vmovmskpd %xmm0, %ecx +# CHECK-NEXT: 1 5 1.00 vmovmskpd %ymm0, %ecx +# CHECK-NEXT: 1 3 1.00 vmovmskps %xmm0, %ecx +# CHECK-NEXT: 1 5 1.00 vmovmskps %ymm0, %ecx +# CHECK-NEXT: 2 521 0.50 * vmovntdq %xmm0, (%rax) +# CHECK-NEXT: 2 507 0.50 * vmovntdq %ymm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovntdqa (%rax), %xmm2 +# CHECK-NEXT: 1 8 0.33 * vmovntdqa (%rax), %ymm2 +# CHECK-NEXT: 2 473 0.50 * vmovntpd %xmm0, (%rax) +# CHECK-NEXT: 2 542 0.50 * vmovntpd %ymm0, (%rax) +# CHECK-NEXT: 2 470 0.50 * vmovntps %xmm0, (%rax) +# CHECK-NEXT: 2 494 0.50 * vmovntps %ymm0, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovq %xmm0, %xmm2 +# CHECK-NEXT: 1 3 1.00 vmovq %rax, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vmovq (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 vmovq %xmm0, %rcx +# CHECK-NEXT: 2 12 0.50 * vmovq %xmm0, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovsd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vmovshdup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vmovshdup (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vmovshdup %ymm0, %ymm2 +# CHECK-NEXT: 1 8 0.33 * vmovshdup (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vmovsldup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * vmovsldup (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vmovsldup %ymm0, %ymm2 +# CHECK-NEXT: 1 8 0.33 * vmovsldup (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.33 vmovss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovss %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovss (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovupd %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovupd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovupd (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovupd %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovupd %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovupd (%rax), %ymm2 +# CHECK-NEXT: 0 1 0.00 vmovups %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vmovups %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * vmovups (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 vmovups %ymm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmovups %ymm0, (%rax) +# CHECK-NEXT: 1 8 0.33 * vmovups (%rax), %ymm2 +# CHECK-NEXT: 2 4 1.00 vmpsadbw $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 3 11 1.00 * vmpsadbw $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmulpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmulpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vmulps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmulps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vmulsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmulsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vmulss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vmulss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vorpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vorpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vorps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vorps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vorps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vorps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpabsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpabsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpabsd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpabsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpabsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpabsw (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 vpackssdw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpackssdw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpacksswb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpacksswb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpackusdw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpackusdw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpackuswb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpackuswb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpaddb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpaddb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpaddd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpaddq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpaddsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpaddsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpaddsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpaddsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpaddusb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpaddusb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpaddusw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpaddusw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpaddw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpaddw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vpalignr $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vpalignr $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpand %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpand (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpandn %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpandn (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpavgb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpavgb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpavgw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpavgw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 3 1.00 vpblendvb %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vpblendvb %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpblendw $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpblendw $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpclmulqdq $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpclmulqdq $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpeqb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpeqd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpeqq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpeqw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 8 16 3.00 vpcmpestri $1, %xmm0, %xmm2 +# CHECK-NEXT: 8 31 3.00 * vpcmpestri $1, (%rax), %xmm2 +# CHECK-NEXT: 9 16 3.00 vpcmpestrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 9 17 3.00 * vpcmpestrm $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpgtb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpgtd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpcmpgtq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpcmpgtw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 11 3.00 vpcmpistri $1, %xmm0, %xmm2 +# CHECK-NEXT: 4 31 3.00 * vpcmpistri $1, (%rax), %xmm2 +# CHECK-NEXT: 3 11 3.00 vpcmpistrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 4 16 3.00 * vpcmpistrm $1, (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 vperm2f128 $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vperm2f128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vpermilpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vpermilpd $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 vpermilpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vpermilpd $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vpermilpd $1, (%rax), %ymm2 +# CHECK-NEXT: 1 1 1.00 vpermilpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vpermilps $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vpermilps $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 vpermilps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vpermilps $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vpermilps $1, (%rax), %ymm2 +# CHECK-NEXT: 1 1 1.00 vpermilps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpextrb $1, %xmm0, %ecx +# CHECK-NEXT: 3 19 0.50 * vpextrb $1, %xmm0, (%rax) +# CHECK-NEXT: 2 4 1.00 vpextrd $1, %xmm0, %ecx +# CHECK-NEXT: 3 12 0.50 * vpextrd $1, %xmm0, (%rax) +# CHECK-NEXT: 2 4 1.00 vpextrq $1, %xmm0, %rcx +# CHECK-NEXT: 3 12 0.50 * vpextrq $1, %xmm0, (%rax) +# CHECK-NEXT: 2 4 1.00 vpextrw $1, %xmm0, %ecx +# CHECK-NEXT: 3 19 0.50 * vpextrw $1, %xmm0, (%rax) +# CHECK-NEXT: 3 2 1.00 vphaddd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphaddd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 2 1.00 vphaddsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphaddsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 2 1.00 vphaddw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphaddw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 1.00 vphminposuw %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * vphminposuw (%rax), %xmm2 +# CHECK-NEXT: 3 2 1.00 vphsubd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphsubd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 2 1.00 vphsubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphsubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3 2 1.00 vphsubw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 4 9 1.00 * vphsubw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 4 1.00 vpinsrb $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpinsrb $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 4 1.00 vpinsrd $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpinsrd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 4 1.00 vpinsrq $1, %rax, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpinsrq $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 4 1.00 vpinsrw $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpinsrw $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmaddubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmaddubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmaddwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxub %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxub (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxud %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxud (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmaxuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmaxuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminub %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminub (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminud %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminud (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpminuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpminuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpmovmskb %xmm0, %ecx +# CHECK-NEXT: 1 1 0.50 vpmovsxbd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovsxbq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovsxbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovsxdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovsxwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovsxwq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovsxwq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxbd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxbq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpmovzxwq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpmovzxwq (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmuldq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmuldq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmulhrsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhrsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmulhuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmulhw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 vpmulld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmullw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmullw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpmuludq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpmuludq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpor %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpor (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vpsadbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 1.00 * vpsadbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpshufb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpshufb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpshufd $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpshufd $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpshufhw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpshufhw $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpshuflw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpshuflw $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsignb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsignb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsignd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsignd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsignw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsignw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpslld $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpslld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpslld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpslldq $1, %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsllq $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsllq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsllq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsllw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsllw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsllw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrad $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsrad %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrad (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsraw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsraw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsraw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrld $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsrld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrldq $1, %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrlq $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsrlq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrlq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrlw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 2 0.67 vpsrlw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrlw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpsubb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsubsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsubsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsubusb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsubusb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsubusw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsubusw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpsubw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 4 1.00 vptest %xmm0, %xmm1 +# CHECK-NEXT: 3 9 1.00 * vptest (%rax), %xmm1 +# CHECK-NEXT: 2 6 1.00 vptest %ymm0, %ymm1 +# CHECK-NEXT: 3 12 1.00 * vptest (%rax), %ymm1 +# CHECK-NEXT: 1 1 0.50 vpunpckhbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpckhbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhqdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpckhqdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpckhwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpcklbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpckldq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklqdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpcklqdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpunpcklwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpxor %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpxor (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 1.00 vrcpps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * vrcpps (%rax), %xmm2 +# CHECK-NEXT: 1 4 1.00 vrcpps %ymm0, %ymm2 +# CHECK-NEXT: 2 12 1.00 * vrcpps (%rax), %ymm2 +# CHECK-NEXT: 1 4 1.00 vrcpss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 1.00 * vrcpss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 vroundpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vroundpd $1, (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 vroundpd $1, %ymm0, %ymm2 +# CHECK-NEXT: 3 16 1.00 * vroundpd $1, (%rax), %ymm2 +# CHECK-NEXT: 2 8 1.00 vroundps $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vroundps $1, (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 vroundps $1, %ymm0, %ymm2 +# CHECK-NEXT: 3 16 1.00 * vroundps $1, (%rax), %ymm2 +# CHECK-NEXT: 2 8 1.00 vroundsd $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vroundsd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 vroundss $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 3 15 1.00 * vroundss $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 1.00 vrsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * vrsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1 4 1.00 vrsqrtps %ymm0, %ymm2 +# CHECK-NEXT: 2 12 1.00 * vrsqrtps (%rax), %ymm2 +# CHECK-NEXT: 1 4 1.00 vrsqrtss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 1.00 * vrsqrtss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vshufpd $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vshufpd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vshufpd $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vshufpd $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vshufps $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vshufps $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vshufps $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vshufps $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 18 1.00 vsqrtpd %xmm0, %xmm2 +# CHECK-NEXT: 2 24 1.00 * vsqrtpd (%rax), %xmm2 +# CHECK-NEXT: 1 18 1.00 vsqrtpd %ymm0, %ymm2 +# CHECK-NEXT: 2 25 1.00 * vsqrtpd (%rax), %ymm2 +# CHECK-NEXT: 1 12 1.00 vsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1 12 1.00 vsqrtps %ymm0, %ymm2 +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax), %ymm2 +# CHECK-NEXT: 1 18 1.00 vsqrtsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 24 1.00 * vsqrtsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 12 1.00 vsqrtss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 19 1.00 * vsqrtss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 4 12 1.00 * U vstmxcsr (%rax) +# CHECK-NEXT: 1 3 0.50 vsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 0.50 vsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 0.50 vsubsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vsubsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 0.50 vsubss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 10 0.50 * vsubss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 3 1.00 vtestpd %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vtestpd (%rax), %xmm1 +# CHECK-NEXT: 1 5 1.00 vtestpd %ymm0, %ymm1 +# CHECK-NEXT: 2 11 1.00 * vtestpd (%rax), %ymm1 +# CHECK-NEXT: 1 3 1.00 vtestps %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vtestps (%rax), %xmm1 +# CHECK-NEXT: 1 5 1.00 vtestps %ymm0, %ymm1 +# CHECK-NEXT: 2 11 1.00 * vtestps (%rax), %ymm1 +# CHECK-NEXT: 1 3 1.00 vucomisd %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vucomisd (%rax), %xmm1 +# CHECK-NEXT: 1 3 1.00 vucomiss %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * vucomiss (%rax), %xmm1 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vunpckhps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vunpckhps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vunpcklpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vunpcklpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vunpcklps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 1.00 vunpcklps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vxorps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vxorps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 10 12 3.00 U vzeroall +# CHECK-NEXT: 0 0 0.00 U vzeroupper + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 310.90 275.73 107.00 107.00 20.00 277.73 8.90 18.50 18.50 19.00 0.73 107.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdec %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdec (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdeclast %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdeclast (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenc %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenc (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenclast %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenclast (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vaesimc %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vaesimc (%rax), %xmm2 +# CHECK-NEXT: 5.83 2.33 - - - 4.83 1.00 - - - - - - vaeskeygenassist $22, %xmm0, %xmm2 +# CHECK-NEXT: 5.50 2.00 0.33 0.33 - 4.50 1.00 - - - - 0.33 - vaeskeygenassist $22, (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vblendpd $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vblendpd $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vblendpd $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vblendpd $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vblendps $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vblendps $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vblendps $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vblendps $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vblendvpd %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vblendvpd %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vblendvpd %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vblendvpd %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vblendvps %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vblendvps %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vblendvps %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vblendvps %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf128 (%rax), %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastsd (%rax), %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastss (%rax), %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastss (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcmpeqss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcmpeqss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcomisd %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcomisd (%rax), %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcomiss %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcomiss (%rax), %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqx (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %ymm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqy (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psx (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %ymm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psy (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %ymm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtsd2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtsd2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsd2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsd2si (%rax), %rcx +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtsd2ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtsd2ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtsi2sd %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtsi2sd %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsi2sdl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsi2sdq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtsi2ss %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 2.00 - - - - - - - vcvtsi2ss %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsi2ssl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtsi2ssq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtss2sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtss2sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtss2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - vcvtss2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtss2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtss2si (%rax), %rcx +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqx (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %ymm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqy (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %ymm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttsd2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttsd2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttsd2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttsd2si (%rax), %rcx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttss2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - vcvttss2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttss2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttss2si (%rax), %rcx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.50 - - - 0.50 - - - - - - - vdppd $22, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.50 0.33 0.33 - 0.50 - - - - - 0.33 - vdppd $22, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.50 2.00 - - - 2.00 0.50 - - - - - - vdpps $22, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.50 2.00 0.33 0.33 - 2.00 0.50 - - - - 0.33 - vdpps $22, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.50 2.00 - - - 2.00 0.50 - - - - - - vdpps $22, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.50 2.00 0.33 0.33 - 2.00 0.50 - - - - 0.33 - vdpps $22, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf128 $1, %ymm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf128 $1, %ymm0, (%rax) +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vextractps $1, %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 1.00 - 0.50 0.50 0.50 - - - vextractps $1, %xmm0, (%rax) +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhaddpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhaddpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhaddpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhaddpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhaddps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhaddps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhaddps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhaddps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - vhsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - vhsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf128 $1, %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinsertf128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertps $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vinsertps $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vlddqu (%rax), %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vlddqu (%rax), %ymm2 +# CHECK-NEXT: 1.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - vldmxcsr (%rax) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - vmaskmovdqu %xmm0, %xmm1 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmaskmovpd (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmaskmovpd (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vmaskmovpd %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vmaskmovpd %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmaskmovps (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmaskmovps (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vmaskmovps %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vmaskmovps %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovapd %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovapd (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovapd %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovapd (%rax), %ymm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovaps %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovaps (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovaps %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovaps (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovd %eax, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovd %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovd %xmm0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovddup (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovddup (%rax), %ymm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa (%rax), %ymm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovhlps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovlhps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovhpd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vmovhpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovhps %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vmovhps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovlpd %xmm0, (%rax) +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vmovlpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovlps %xmm0, (%rax) +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vmovlps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovmskpd %xmm0, %ecx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovmskpd %ymm0, %ecx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovmskps %xmm0, %ecx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovmskps %ymm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntdq %xmm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntdq %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovntdqa (%rax), %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovntdqa (%rax), %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntpd %xmm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntpd %ymm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntps %xmm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovntps %ymm0, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovq %xmm0, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovq %rax, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovq (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmovq %xmm0, %rcx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovq %xmm0, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovsd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovshdup (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovshdup (%rax), %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsldup (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsldup (%rax), %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovss %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovss (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovupd %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovupd (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovupd %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovupd (%rax), %ymm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovups %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovups (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - vmovups %ymm0, %ymm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %ymm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovups (%rax), %ymm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vmpsadbw $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 1.50 - - - - - 0.33 - vmpsadbw $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpand %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpand (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpandn %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpandn (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vpblendvb %xmm3, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vpblendvb %xmm3, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpblendw $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendw $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpclmulqdq $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpclmulqdq $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 4.17 1.67 - - - 1.67 0.50 - - - - - - vpcmpestri $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.83 1.33 0.33 0.33 - 1.33 0.50 - - - - 0.33 - vpcmpestri $1, (%rax), %xmm2 +# CHECK-NEXT: 4.50 2.00 - - - 2.00 0.50 - - - - - - vpcmpestrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 4.17 1.67 0.33 0.33 - 1.67 0.50 - - - - 0.33 - vpcmpestrm $1, (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - vpcmpistri $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - vpcmpistri $1, (%rax), %xmm2 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - vpcmpistrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - vpcmpistrm $1, (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vperm2f128 $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vperm2f128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $1, %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $1, (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $1, %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $1, (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $1, %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $1, (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $1, %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $1, (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrb $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrb $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrd $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrd $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrq $1, %xmm0, %rcx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrq $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrw $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrw $1, %xmm0, (%rax) +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphaddd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphaddd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - vphaddsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - vphaddsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphaddw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphaddw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vphminposuw %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vphminposuw (%rax), %xmm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphsubd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphsubd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - vphsubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - vphsubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphsubw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphsubw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrb $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrb $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrd $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrq $1, %rax, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrq $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrw $1, %eax, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrw $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxud %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxud (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminud %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminud (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovmskb %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmuldq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmuldq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmuludq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmuludq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpor %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpor (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsadbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsadbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $1, (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $1, (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $1, (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpslld $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpslld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpslld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpslldq $1, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllq $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsllq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsllw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrad $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrad %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrad (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsraw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrld $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrld %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrld (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpsrldq $1, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlq $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrlq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $1, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrlw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vptest %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vptest (%rax), %xmm1 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vptest %ymm0, %ymm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vptest (%rax), %ymm1 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhqdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhqdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklqdq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklqdq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpxor %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpxor (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrcpps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrcpps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrcpps %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrcpps (%rax), %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrcpss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrcpss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundpd $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundpd $1, %ymm0, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundpd $1, (%rax), %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundps $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundps $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundps $1, %ymm0, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundps $1, (%rax), %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundsd $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundsd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vroundss $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vroundss $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrsqrtps %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrsqrtps (%rax), %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrsqrtss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrsqrtss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vshufpd $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vshufpd $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vshufpd $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vshufpd $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vshufps $1, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vshufps $1, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vshufps $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vshufps $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.50 - - - 0.50 - 0.50 0.50 0.50 0.50 - - - vstmxcsr (%rax) +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubsd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubsd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vtestpd %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vtestpd (%rax), %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vtestpd %ymm0, %ymm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vtestpd (%rax), %ymm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vtestps %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vtestps (%rax), %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vtestps %ymm0, %ymm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vtestps (%rax), %ymm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vucomisd %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vucomisd (%rax), %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vucomiss %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vucomiss (%rax), %xmm1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 2.23 4.07 - - - 1.07 1.90 - - - 0.73 - - vzeroall +# CHECK-NEXT: - - - - - - - - - - - - - vzeroupper diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx2.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx2.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx2.s @@ -0,0 +1,1086 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vbroadcasti128 (%rax), %ymm0 + +vbroadcastsd %xmm0, %ymm0 +vbroadcastss %xmm0, %ymm0 + +vextracti128 $1, %ymm0, %xmm2 +vextracti128 $1, %ymm0, (%rax) + +vgatherdpd %xmm0, (%rax,%xmm1,2), %xmm2 +vgatherdpd %ymm0, (%rax,%xmm1,2), %ymm2 + +vgatherdps %xmm0, (%rax,%xmm1,2), %xmm2 +vgatherdps %ymm0, (%rax,%ymm1,2), %ymm2 + +vgatherqpd %xmm0, (%rax,%xmm1,2), %xmm2 +vgatherqpd %ymm0, (%rax,%ymm1,2), %ymm2 + +vgatherqps %xmm0, (%rax,%xmm1,2), %xmm2 +vgatherqps %xmm0, (%rax,%ymm1,2), %xmm2 + +vinserti128 $1, %xmm0, %ymm1, %ymm2 +vinserti128 $1, (%rax), %ymm1, %ymm2 + +vmovntdqa (%rax), %ymm0 + +vmpsadbw $1, %ymm0, %ymm1, %ymm2 +vmpsadbw $1, (%rax), %ymm1, %ymm2 + +vpabsb %ymm0, %ymm2 +vpabsb (%rax), %ymm2 + +vpabsd %ymm0, %ymm2 +vpabsd (%rax), %ymm2 + +vpabsw %ymm0, %ymm2 +vpabsw (%rax), %ymm2 + +vpackssdw %ymm0, %ymm1, %ymm2 +vpackssdw (%rax), %ymm1, %ymm2 + +vpacksswb %ymm0, %ymm1, %ymm2 +vpacksswb (%rax), %ymm1, %ymm2 + +vpackusdw %ymm0, %ymm1, %ymm2 +vpackusdw (%rax), %ymm1, %ymm2 + +vpackuswb %ymm0, %ymm1, %ymm2 +vpackuswb (%rax), %ymm1, %ymm2 + +vpaddb %ymm0, %ymm1, %ymm2 +vpaddb (%rax), %ymm1, %ymm2 + +vpaddd %ymm0, %ymm1, %ymm2 +vpaddd (%rax), %ymm1, %ymm2 + +vpaddq %ymm0, %ymm1, %ymm2 +vpaddq (%rax), %ymm1, %ymm2 + +vpaddsb %ymm0, %ymm1, %ymm2 +vpaddsb (%rax), %ymm1, %ymm2 + +vpaddsw %ymm0, %ymm1, %ymm2 +vpaddsw (%rax), %ymm1, %ymm2 + +vpaddusb %ymm0, %ymm1, %ymm2 +vpaddusb (%rax), %ymm1, %ymm2 + +vpaddusw %ymm0, %ymm1, %ymm2 +vpaddusw (%rax), %ymm1, %ymm2 + +vpaddw %ymm0, %ymm1, %ymm2 +vpaddw (%rax), %ymm1, %ymm2 + +vpalignr $1, %ymm0, %ymm1, %ymm2 +vpalignr $1, (%rax), %ymm1, %ymm2 + +vpand %ymm0, %ymm1, %ymm2 +vpand (%rax), %ymm1, %ymm2 + +vpandn %ymm0, %ymm1, %ymm2 +vpandn (%rax), %ymm1, %ymm2 + +vpavgb %ymm0, %ymm1, %ymm2 +vpavgb (%rax), %ymm1, %ymm2 + +vpavgw %ymm0, %ymm1, %ymm2 +vpavgw (%rax), %ymm1, %ymm2 + +vpblendd $11, %xmm0, %xmm1, %xmm2 +vpblendd $11, (%rax), %xmm1, %xmm2 + +vpblendd $11, %ymm0, %ymm1, %ymm2 +vpblendd $11, (%rax), %ymm1, %ymm2 + +vpblendvb %ymm3, %ymm0, %ymm1, %ymm2 +vpblendvb %ymm3, (%rax), %ymm1, %ymm2 + +vpblendw $11, %ymm0, %ymm1, %ymm2 +vpblendw $11, (%rax), %ymm1, %ymm2 + +vpbroadcastb %xmm0, %xmm0 +vpbroadcastb (%rax), %xmm0 + +vpbroadcastb %xmm0, %ymm0 +vpbroadcastb (%rax), %ymm0 + +vpbroadcastd %xmm0, %xmm0 +vpbroadcastd (%rax), %xmm0 + +vpbroadcastd %xmm0, %ymm0 +vpbroadcastd (%rax), %ymm0 + +vpbroadcastq %xmm0, %xmm0 +vpbroadcastq (%rax), %xmm0 + +vpbroadcastq %xmm0, %ymm0 +vpbroadcastq (%rax), %ymm0 + +vpbroadcastw %xmm0, %xmm0 +vpbroadcastw (%rax), %xmm0 + +vpbroadcastw %xmm0, %ymm0 +vpbroadcastw (%rax), %ymm0 + +vpcmpeqb %ymm0, %ymm1, %ymm2 +vpcmpeqb (%rax), %ymm1, %ymm2 + +vpcmpeqd %ymm0, %ymm1, %ymm2 +vpcmpeqd (%rax), %ymm1, %ymm2 + +vpcmpeqq %ymm0, %ymm1, %ymm2 +vpcmpeqq (%rax), %ymm1, %ymm2 + +vpcmpeqw %ymm0, %ymm1, %ymm2 +vpcmpeqw (%rax), %ymm1, %ymm2 + +vpcmpgtb %ymm0, %ymm1, %ymm2 +vpcmpgtb (%rax), %ymm1, %ymm2 + +vpcmpgtd %ymm0, %ymm1, %ymm2 +vpcmpgtd (%rax), %ymm1, %ymm2 + +vpcmpgtq %ymm0, %ymm1, %ymm2 +vpcmpgtq (%rax), %ymm1, %ymm2 + +vpcmpgtw %ymm0, %ymm1, %ymm2 +vpcmpgtw (%rax), %ymm1, %ymm2 + +vperm2i128 $1, %ymm0, %ymm1, %ymm2 +vperm2i128 $1, (%rax), %ymm1, %ymm2 + +vpermd %ymm0, %ymm1, %ymm2 +vpermd (%rax), %ymm1, %ymm2 + +vpermpd $1, %ymm0, %ymm2 +vpermpd $1, (%rax), %ymm2 + +vpermps %ymm0, %ymm1, %ymm2 +vpermps (%rax), %ymm1, %ymm2 + +vpermq $1, %ymm0, %ymm2 +vpermq $1, (%rax), %ymm2 + +vpgatherdd %xmm0, (%rax,%xmm1,2), %xmm2 +vpgatherdd %ymm0, (%rax,%ymm1,2), %ymm2 + +vpgatherdq %xmm0, (%rax,%xmm1,2), %xmm2 +vpgatherdq %ymm0, (%rax,%xmm1,2), %ymm2 + +vpgatherqd %xmm0, (%rax,%xmm1,2), %xmm2 +vpgatherqd %xmm0, (%rax,%ymm1,2), %xmm2 + +vpgatherqq %xmm0, (%rax,%xmm1,2), %xmm2 +vpgatherqq %ymm0, (%rax,%ymm1,2), %ymm2 + +vphaddd %ymm0, %ymm1, %ymm2 +vphaddd (%rax), %ymm1, %ymm2 + +vphaddsw %ymm0, %ymm1, %ymm2 +vphaddsw (%rax), %ymm1, %ymm2 + +vphaddw %ymm0, %ymm1, %ymm2 +vphaddw (%rax), %ymm1, %ymm2 + +vphsubd %ymm0, %ymm1, %ymm2 +vphsubd (%rax), %ymm1, %ymm2 + +vphsubsw %ymm0, %ymm1, %ymm2 +vphsubsw (%rax), %ymm1, %ymm2 + +vphsubw %ymm0, %ymm1, %ymm2 +vphsubw (%rax), %ymm1, %ymm2 + +vpmaddubsw %ymm0, %ymm1, %ymm2 +vpmaddubsw (%rax), %ymm1, %ymm2 + +vpmaddwd %ymm0, %ymm1, %ymm2 +vpmaddwd (%rax), %ymm1, %ymm2 + +vpmaskmovd (%rax), %xmm0, %xmm2 +vpmaskmovd (%rax), %ymm0, %ymm2 + +vpmaskmovd %xmm0, %xmm1, (%rax) +vpmaskmovd %ymm0, %ymm1, (%rax) + +vpmaskmovq (%rax), %xmm0, %xmm2 +vpmaskmovq (%rax), %ymm0, %ymm2 + +vpmaskmovq %xmm0, %xmm1, (%rax) +vpmaskmovq %ymm0, %ymm1, (%rax) + +vpmaxsb %ymm0, %ymm1, %ymm2 +vpmaxsb (%rax), %ymm1, %ymm2 + +vpmaxsd %ymm0, %ymm1, %ymm2 +vpmaxsd (%rax), %ymm1, %ymm2 + +vpmaxsw %ymm0, %ymm1, %ymm2 +vpmaxsw (%rax), %ymm1, %ymm2 + +vpmaxub %ymm0, %ymm1, %ymm2 +vpmaxub (%rax), %ymm1, %ymm2 + +vpmaxud %ymm0, %ymm1, %ymm2 +vpmaxud (%rax), %ymm1, %ymm2 + +vpmaxuw %ymm0, %ymm1, %ymm2 +vpmaxuw (%rax), %ymm1, %ymm2 + +vpminsb %ymm0, %ymm1, %ymm2 +vpminsb (%rax), %ymm1, %ymm2 + +vpminsd %ymm0, %ymm1, %ymm2 +vpminsd (%rax), %ymm1, %ymm2 + +vpminsw %ymm0, %ymm1, %ymm2 +vpminsw (%rax), %ymm1, %ymm2 + +vpminub %ymm0, %ymm1, %ymm2 +vpminub (%rax), %ymm1, %ymm2 + +vpminud %ymm0, %ymm1, %ymm2 +vpminud (%rax), %ymm1, %ymm2 + +vpminuw %ymm0, %ymm1, %ymm2 +vpminuw (%rax), %ymm1, %ymm2 + +vpmovmskb %ymm0, %rcx + +vpmovsxbd %xmm0, %ymm2 +vpmovsxbd (%rax), %ymm2 + +vpmovsxbq %xmm0, %ymm2 +vpmovsxbq (%rax), %ymm2 + +vpmovsxbw %xmm0, %ymm2 +vpmovsxbw (%rax), %ymm2 + +vpmovsxdq %xmm0, %ymm2 +vpmovsxdq (%rax), %ymm2 + +vpmovsxwd %xmm0, %ymm2 +vpmovsxwd (%rax), %ymm2 + +vpmovsxwq %xmm0, %ymm2 +vpmovsxwq (%rax), %ymm2 + +vpmovzxbd %xmm0, %ymm2 +vpmovzxbd (%rax), %ymm2 + +vpmovzxbq %xmm0, %ymm2 +vpmovzxbq (%rax), %ymm2 + +vpmovzxbw %xmm0, %ymm2 +vpmovzxbw (%rax), %ymm2 + +vpmovzxdq %xmm0, %ymm2 +vpmovzxdq (%rax), %ymm2 + +vpmovzxwd %xmm0, %ymm2 +vpmovzxwd (%rax), %ymm2 + +vpmovzxwq %xmm0, %ymm2 +vpmovzxwq (%rax), %ymm2 + +vpmuldq %ymm0, %ymm1, %ymm2 +vpmuldq (%rax), %ymm1, %ymm2 + +vpmulhrsw %ymm0, %ymm1, %ymm2 +vpmulhrsw (%rax), %ymm1, %ymm2 + +vpmulhuw %ymm0, %ymm1, %ymm2 +vpmulhuw (%rax), %ymm1, %ymm2 + +vpmulhw %ymm0, %ymm1, %ymm2 +vpmulhw (%rax), %ymm1, %ymm2 + +vpmulld %ymm0, %ymm1, %ymm2 +vpmulld (%rax), %ymm1, %ymm2 + +vpmullw %ymm0, %ymm1, %ymm2 +vpmullw (%rax), %ymm1, %ymm2 + +vpmuludq %ymm0, %ymm1, %ymm2 +vpmuludq (%rax), %ymm1, %ymm2 + +vpor %ymm0, %ymm1, %ymm2 +vpor (%rax), %ymm1, %ymm2 + +vpsadbw %ymm0, %ymm1, %ymm2 +vpsadbw (%rax), %ymm1, %ymm2 + +vpshufb %ymm0, %ymm1, %ymm2 +vpshufb (%rax), %ymm1, %ymm2 + +vpshufd $1, %ymm0, %ymm2 +vpshufd $1, (%rax), %ymm2 + +vpshufhw $1, %ymm0, %ymm2 +vpshufhw $1, (%rax), %ymm2 + +vpshuflw $1, %ymm0, %ymm2 +vpshuflw $1, (%rax), %ymm2 + +vpsignb %ymm0, %ymm1, %ymm2 +vpsignb (%rax), %ymm1, %ymm2 + +vpsignd %ymm0, %ymm1, %ymm2 +vpsignd (%rax), %ymm1, %ymm2 + +vpsignw %ymm0, %ymm1, %ymm2 +vpsignw (%rax), %ymm1, %ymm2 + +vpslld $1, %ymm0, %ymm2 +vpslld %xmm0, %ymm1, %ymm2 +vpslld (%rax), %ymm1, %ymm2 + +vpslldq $1, %ymm1, %ymm2 + +vpsllq $1, %ymm0, %ymm2 +vpsllq %xmm0, %ymm1, %ymm2 +vpsllq (%rax), %ymm1, %ymm2 + +vpsllvd %xmm0, %xmm1, %xmm2 +vpsllvd (%rax), %xmm1, %xmm2 + +vpsllvd %ymm0, %ymm1, %ymm2 +vpsllvd (%rax), %ymm1, %ymm2 + +vpsllvq %xmm0, %xmm1, %xmm2 +vpsllvq (%rax), %xmm1, %xmm2 + +vpsllvq %ymm0, %ymm1, %ymm2 +vpsllvq (%rax), %ymm1, %ymm2 + +vpsllw $1, %ymm0, %ymm2 +vpsllw %xmm0, %ymm1, %ymm2 +vpsllw (%rax), %ymm1, %ymm2 + +vpsrad $1, %ymm0, %ymm2 +vpsrad %xmm0, %ymm1, %ymm2 +vpsrad (%rax), %ymm1, %ymm2 + +vpsravd %xmm0, %xmm1, %xmm2 +vpsravd (%rax), %xmm1, %xmm2 + +vpsravd %ymm0, %ymm1, %ymm2 +vpsravd (%rax), %ymm1, %ymm2 + +vpsraw $1, %ymm0, %ymm2 +vpsraw %xmm0, %ymm1, %ymm2 +vpsraw (%rax), %ymm1, %ymm2 + +vpsrld $1, %ymm0, %ymm2 +vpsrld %xmm0, %ymm1, %ymm2 +vpsrld (%rax), %ymm1, %ymm2 + +vpsrldq $1, %ymm1, %ymm2 + +vpsrlq $1, %ymm0, %ymm2 +vpsrlq %xmm0, %ymm1, %ymm2 +vpsrlq (%rax), %ymm1, %ymm2 + +vpsrlvd %xmm0, %xmm1, %xmm2 +vpsrlvd (%rax), %xmm1, %xmm2 + +vpsrlvd %ymm0, %ymm1, %ymm2 +vpsrlvd (%rax), %ymm1, %ymm2 + +vpsrlvq %xmm0, %xmm1, %xmm2 +vpsrlvq (%rax), %xmm1, %xmm2 + +vpsrlvq %ymm0, %ymm1, %ymm2 +vpsrlvq (%rax), %ymm1, %ymm2 + +vpsrlw $1, %ymm0, %ymm2 +vpsrlw %xmm0, %ymm1, %ymm2 +vpsrlw (%rax), %ymm1, %ymm2 + +vpsubb %ymm0, %ymm1, %ymm2 +vpsubb (%rax), %ymm1, %ymm2 + +vpsubd %ymm0, %ymm1, %ymm2 +vpsubd (%rax), %ymm1, %ymm2 + +vpsubq %ymm0, %ymm1, %ymm2 +vpsubq (%rax), %ymm1, %ymm2 + +vpsubsb %ymm0, %ymm1, %ymm2 +vpsubsb (%rax), %ymm1, %ymm2 + +vpsubsw %ymm0, %ymm1, %ymm2 +vpsubsw (%rax), %ymm1, %ymm2 + +vpsubusb %ymm0, %ymm1, %ymm2 +vpsubusb (%rax), %ymm1, %ymm2 + +vpsubusw %ymm0, %ymm1, %ymm2 +vpsubusw (%rax), %ymm1, %ymm2 + +vpsubw %ymm0, %ymm1, %ymm2 +vpsubw (%rax), %ymm1, %ymm2 + +vpunpckhbw %ymm0, %ymm1, %ymm2 +vpunpckhbw (%rax), %ymm1, %ymm2 + +vpunpckhdq %ymm0, %ymm1, %ymm2 +vpunpckhdq (%rax), %ymm1, %ymm2 + +vpunpckhqdq %ymm0, %ymm1, %ymm2 +vpunpckhqdq (%rax), %ymm1, %ymm2 + +vpunpckhwd %ymm0, %ymm1, %ymm2 +vpunpckhwd (%rax), %ymm1, %ymm2 + +vpunpcklbw %ymm0, %ymm1, %ymm2 +vpunpcklbw (%rax), %ymm1, %ymm2 + +vpunpckldq %ymm0, %ymm1, %ymm2 +vpunpckldq (%rax), %ymm1, %ymm2 + +vpunpcklqdq %ymm0, %ymm1, %ymm2 +vpunpcklqdq (%rax), %ymm1, %ymm2 + +vpunpcklwd %ymm0, %ymm1, %ymm2 +vpunpcklwd (%rax), %ymm1, %ymm2 + +vpxor %ymm0, %ymm1, %ymm2 +vpxor (%rax), %ymm1, %ymm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 8 0.33 * vbroadcasti128 (%rax), %ymm0 +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm0, %ymm0 +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm0, %ymm0 +# CHECK-NEXT: 1 3 1.00 vextracti128 $1, %ymm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vextracti128 $1, %ymm0, (%rax) +# CHECK-NEXT: 5 20 1.00 * vgatherdpd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vgatherdpd %ymm0, (%rax,%xmm1,2), %ymm2 +# CHECK-NEXT: 8 28 1.33 * vgatherdps %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 12 30 2.67 * vgatherdps %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 5 20 1.00 * vgatherqpd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vgatherqpd %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 5 20 1.00 * vgatherqps %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vgatherqps %xmm0, (%rax,%ymm1,2), %xmm2 +# CHECK-NEXT: 1 3 1.00 vinserti128 $1, %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vinserti128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 8 0.33 * vmovntdqa (%rax), %ymm0 +# CHECK-NEXT: 2 4 1.00 vmpsadbw $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 3 12 1.00 * vmpsadbw $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpabsb %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpabsb (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vpabsd %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpabsd (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vpabsw %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpabsw (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpackssdw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpackssdw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpacksswb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpacksswb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpackusdw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpackusdw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpackuswb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpackuswb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpaddb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpaddb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpaddd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpaddq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpaddsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpaddsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpaddsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpaddsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpaddusb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpaddusb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpaddusw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpaddusw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpaddw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpaddw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vpalignr $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 1.00 * vpalignr $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpand %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpand (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpandn %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpandn (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpavgb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpavgb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpavgw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpavgw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpblendd $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.33 * vpblendd $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpblendd $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpblendd $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 3 1.00 vpblendvb %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vpblendvb %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpblendw $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpblendw $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 1.00 vpbroadcastb %xmm0, %xmm0 +# CHECK-NEXT: 2 8 1.00 * vpbroadcastb (%rax), %xmm0 +# CHECK-NEXT: 1 3 1.00 vpbroadcastb %xmm0, %ymm0 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastb (%rax), %ymm0 +# CHECK-NEXT: 1 1 1.00 vpbroadcastd %xmm0, %xmm0 +# CHECK-NEXT: 1 7 0.33 * vpbroadcastd (%rax), %xmm0 +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm0, %ymm0 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastd (%rax), %ymm0 +# CHECK-NEXT: 1 1 1.00 vpbroadcastq %xmm0, %xmm0 +# CHECK-NEXT: 1 7 0.33 * vpbroadcastq (%rax), %xmm0 +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm0, %ymm0 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastq (%rax), %ymm0 +# CHECK-NEXT: 1 1 1.00 vpbroadcastw %xmm0, %xmm0 +# CHECK-NEXT: 2 8 1.00 * vpbroadcastw (%rax), %xmm0 +# CHECK-NEXT: 1 3 1.00 vpbroadcastw %xmm0, %ymm0 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastw (%rax), %ymm0 +# CHECK-NEXT: 1 1 0.50 vpcmpeqb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpeqb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpeqd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpeqq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpeqw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpeqw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpgtb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpgtd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpcmpgtq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpcmpgtw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vperm2i128 $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vperm2i128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpermd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpermpd $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpermpd $1, (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpermps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpermq $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpermq $1, (%rax), %ymm2 +# CHECK-NEXT: 8 28 1.33 * vpgatherdd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 12 30 2.67 * vpgatherdd %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 5 20 1.00 * vpgatherdq %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vpgatherdq %ymm0, (%rax,%xmm1,2), %ymm2 +# CHECK-NEXT: 5 20 1.00 * vpgatherqd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vpgatherqd %xmm0, (%rax,%ymm1,2), %xmm2 +# CHECK-NEXT: 5 20 1.00 * vpgatherqq %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 8 29 1.33 * vpgatherqq %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 3 2 1.00 vphaddd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphaddd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 2 1.00 vphaddsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphaddsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 2 1.00 vphaddw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphaddw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 2 1.00 vphsubd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphsubd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 2 1.00 vphsubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphsubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 3 2 1.00 vphsubw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 4 10 1.00 * vphsubw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmaddubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmaddubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmaddwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 2 8 0.33 * vpmaskmovd (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 9 0.33 * vpmaskmovd (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 3 14 1.00 * * vpmaskmovd %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 3 14 1.00 * * vpmaskmovd %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 2 8 0.33 * vpmaskmovq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 9 0.33 * vpmaskmovq (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 3 14 1.00 * * vpmaskmovq %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 3 14 1.00 * * vpmaskmovq %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 1 1 0.50 vpmaxsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpmaxsd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxsd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpmaxsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpmaxub %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxub (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpmaxud %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxud (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpmaxuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpmaxuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminsd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminsd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminub %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminub (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminud %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminud (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpminuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpminuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 1.00 vpmovmskb %ymm0, %ecx +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovsxbw %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbw (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxbw %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbw (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %ymm2 +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm0, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmuldq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmuldq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmulhrsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhrsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmulhuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmulhw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmulhw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 2 10 1.00 vpmulld %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmullw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmullw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpmuludq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpmuludq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpor %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpor (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 3 1.00 vpsadbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 11 1.00 * vpsadbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpshufb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpshufb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpshufd $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpshufd $1, (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vpshufhw $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpshufhw $1, (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vpshuflw $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpshuflw $1, (%rax), %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsignb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsignb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsignd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsignd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsignw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsignw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpslld $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpslld %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpslld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpslldq $1, %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsllq $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsllq %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsllq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsllvd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsllvd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsllvd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsllvd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsllvq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsllvq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsllvq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsllvq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsllw $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsllw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsllw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrad $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsrad %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrad (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsravd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsravd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsravd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsravd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsraw $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsraw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsraw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrld $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsrld %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrldq $1, %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrlq $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsrlq %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrlq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrlvd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrlvd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrlvd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrlvd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrlvq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 8 0.50 * vpsrlvq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpsrlvq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrlvq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsrlw $1, %ymm0, %ymm2 +# CHECK-NEXT: 2 4 1.00 vpsrlw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsrlw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpsubb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsubsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsubsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsubusb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsubusb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpsubusw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpsubusw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpsubw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpckhbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhqdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpckhqdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpckhwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpckhwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpcklbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpckldq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklqdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpcklqdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.50 vpunpcklwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.50 * vpunpcklwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 1 0.33 vpxor %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 9 0.33 * vpxor (%rax), %ymm1, %ymm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 111.00 130.00 65.33 65.33 2.50 135.00 - 2.50 2.50 2.50 - 65.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti128 (%rax), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm0, %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm0, %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti128 $1, %ymm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti128 $1, %ymm0, (%rax) +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vgatherdpd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vgatherdpd %ymm0, (%rax,%xmm1,2), %ymm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vgatherdps %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 2.67 2.67 - 1.33 - - - - - 2.67 - vgatherdps %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vgatherqpd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vgatherqpd %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vgatherqps %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vgatherqps %xmm0, (%rax,%ymm1,2), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti128 $1, %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinserti128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovntdqa (%rax), %ymm0 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vmpsadbw $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 1.50 - - - - - 0.33 - vmpsadbw $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsd %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpand %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpand (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpandn %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpandn (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendd $11, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendd $11, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendd $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendd $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - 1.00 - - - - - - - vpblendvb %ymm3, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - vpblendvb %ymm3, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpblendw $11, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendw $11, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm0, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm0, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm0, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastd (%rax), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm0, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastd (%rax), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm0, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastq (%rax), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm0, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastq (%rax), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm0, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm0, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %ymm0 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpeqw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpeqw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpcmpgtw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpcmpgtw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vperm2i128 $1, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vperm2i128 $1, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $1, %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $1, (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $1, %ymm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $1, (%rax), %ymm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vpgatherdd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 2.67 2.67 - 1.33 - - - - - 2.67 - vpgatherdd %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vpgatherdq %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vpgatherdq %ymm0, (%rax,%xmm1,2), %ymm2 +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vpgatherqd %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vpgatherqd %xmm0, (%rax,%ymm1,2), %xmm2 +# CHECK-NEXT: 1.33 0.83 0.67 0.67 - 0.83 - - - - - 0.67 - vpgatherqq %xmm0, (%rax,%xmm1,2), %xmm2 +# CHECK-NEXT: 1.33 1.33 1.33 1.33 - 1.33 - - - - - 1.33 - vpgatherqq %ymm0, (%rax,%ymm1,2), %ymm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphaddd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphaddd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - vphaddsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - vphaddsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphaddw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphaddw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphsubd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphsubd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - vphsubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - vphsubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - vphsubw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - vphsubw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpmaskmovd (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpmaskmovd (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vpmaskmovd %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vpmaskmovd %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpmaskmovq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpmaskmovq (%rax), %ymm0, %ymm2 +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vpmaskmovq %xmm0, %xmm1, (%rax) +# CHECK-NEXT: 1.00 - - - 0.50 - - 0.50 0.50 0.50 - - - vpmaskmovq %ymm0, %ymm1, (%rax) +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxud %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxud (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminud %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminud (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovmskb %ymm0, %ecx +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm0, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmuldq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmuldq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmuludq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmuludq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpor %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpor (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsadbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsadbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $1, %ymm0, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $1, (%rax), %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $1, %ymm0, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $1, (%rax), %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $1, %ymm0, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $1, (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsignw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsignw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpslld $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpslld %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpslld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpslldq $1, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllq $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsllq %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsllw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrad $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrad %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrad (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsraw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrld $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrld %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrld (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpsrldq $1, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlq $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrlq %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvq %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvq (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $1, %ymm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrlw %xmm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhqdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhqdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklqdq %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklqdq (%rax), %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpxor %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpxor (%rax), %ymm1, %ymm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512.s @@ -0,0 +1,2809 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +kandw %k0, %k1, %k2 +kandnw %k0, %k1, %k2 +knotw %k0, %k2 +korw %k0, %k1, %k2 +kxnorw %k0, %k1, %k2 +kxorw %k0, %k1, %k2 +kshiftlw $2, %k1, %k2 +kshiftrw $2, %k1, %k2 +kunpckbw %k0, %k1, %k2 + +vaddpd %zmm16, %zmm17, %zmm19 +vaddpd (%rax), %zmm17, %zmm19 +vaddpd (%rax){1to8}, %zmm17, %zmm19 +vaddpd %zmm16, %zmm17, %zmm19 {k1} +vaddpd (%rax), %zmm17, %zmm19 {k1} +vaddpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vaddpd %zmm16, %zmm17, %zmm19 {z}{k1} +vaddpd (%rax), %zmm17, %zmm19 {z}{k1} +vaddpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vaddps %zmm16, %zmm17, %zmm19 +vaddps (%rax), %zmm17, %zmm19 +vaddps (%rax){1to16}, %zmm17, %zmm19 +vaddps %zmm16, %zmm17, %zmm19 {k1} +vaddps (%rax), %zmm17, %zmm19 {k1} +vaddps (%rax){1to16}, %zmm17, %zmm19 {k1} +vaddps %zmm16, %zmm17, %zmm19 {z}{k1} +vaddps (%rax), %zmm17, %zmm19 {z}{k1} +vaddps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +valignd $1, %zmm16, %zmm17, %zmm19 +valignd $1, (%rax), %zmm17, %zmm19 +valignd $1, (%rax){1to16}, %zmm17, %zmm19 +valignd $1, %zmm16, %zmm17, %zmm19 {k1} +valignd $1, (%rax), %zmm17, %zmm19 {k1} +valignd $1, (%rax){1to16}, %zmm17, %zmm19 {k1} +valignd $1, %zmm16, %zmm17, %zmm19 {z}{k1} +valignd $1, (%rax), %zmm17, %zmm19 {z}{k1} +valignd $1, (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +valignq $1, %zmm16, %zmm17, %zmm19 +valignq $1, (%rax), %zmm17, %zmm19 +valignq $1, (%rax){1to8}, %zmm17, %zmm19 +valignq $1, %zmm16, %zmm17, %zmm19 {k1} +valignq $1, (%rax), %zmm17, %zmm19 {k1} +valignq $1, (%rax){1to8}, %zmm17, %zmm19 {k1} +valignq $1, %zmm16, %zmm17, %zmm19 {z}{k1} +valignq $1, (%rax), %zmm17, %zmm19 {z}{k1} +valignq $1, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vbroadcastf32x4 (%rax), %zmm19 +vbroadcastf32x4 (%rax), %zmm19 {k1} +vbroadcastf32x4 (%rax), %zmm19 {z}{k1} + +vbroadcastf64x4 (%rax), %zmm19 +vbroadcastf64x4 (%rax), %zmm19 {k1} +vbroadcastf64x4 (%rax), %zmm19 {z}{k1} + +vbroadcasti32x4 (%rax), %zmm19 +vbroadcasti32x4 (%rax), %zmm19 {k1} +vbroadcasti32x4 (%rax), %zmm19 {z}{k1} + +vbroadcasti64x4 (%rax), %zmm19 +vbroadcasti64x4 (%rax), %zmm19 {k1} +vbroadcasti64x4 (%rax), %zmm19 {z}{k1} + +vbroadcastsd %xmm16, %zmm19 +vbroadcastsd (%rax), %zmm19 +vbroadcastsd %xmm16, %zmm19 {k1} +vbroadcastsd (%rax), %zmm19 {k1} +vbroadcastsd %xmm16, %zmm19 {z}{k1} +vbroadcastsd (%rax), %zmm19 {z}{k1} + +vbroadcastss %xmm16, %zmm19 +vbroadcastss (%rax), %zmm19 +vbroadcastss %xmm16, %zmm19 {k1} +vbroadcastss (%rax), %zmm19 {k1} +vbroadcastss %xmm16, %zmm19 {z}{k1} +vbroadcastss (%rax), %zmm19 {z}{k1} + +vcmppd $0, %zmm0, %zmm1, %k2 +vcmppd $0, (%rax), %zmm1, %k2 +vcmppd $0, (%rax){1to8}, %zmm1, %k2 +vcmppd $0, %zmm0, %zmm1, %k2 {k3} +vcmppd $0, (%rax), %zmm1, %k2 {k3} +vcmppd $0, (%rax){1to8}, %zmm1, %k2 {k3} + +vcmpps $0, %zmm0, %zmm1, %k2 +vcmpps $0, (%rax), %zmm1, %k2 +vcmpps $0, (%rax){1to16}, %zmm1, %k2 +vcmpps $0, %zmm0, %zmm1, %k2 {k3} +vcmpps $0, (%rax), %zmm1, %k2 {k3} +vcmpps $0, (%rax){1to16}, %zmm1, %k2 {k3} + +vcmpsd $0, %xmm0, %xmm1, %k2 +vcmpsd $0, (%rax), %xmm1, %k2 +vcmpsd $0, %xmm0, %xmm1, %k2 {k3} +vcmpsd $0, (%rax), %xmm1, %k2 {k3} + +vcmpss $0, %xmm0, %xmm1, %k2 +vcmpss $0, (%rax), %xmm1, %k2 +vcmpss $0, %xmm0, %xmm1, %k2 {k3} +vcmpss $0, (%rax), %xmm1, %k2 {k3} + +vcomiss %xmm16, %xmm17 +vcomiss (%rax), %xmm17 + +vcvtdq2pd %ymm16, %zmm19 +vcvtdq2pd (%rax), %zmm19 +vcvtdq2pd (%rax){1to8}, %zmm19 +vcvtdq2pd %ymm16, %zmm19 {k1} +vcvtdq2pd (%rax), %zmm19 {k1} +vcvtdq2pd (%rax){1to8}, %zmm19 {k1} +vcvtdq2pd %ymm16, %zmm19 {z}{k1} +vcvtdq2pd (%rax), %zmm19 {z}{k1} +vcvtdq2pd (%rax){1to8}, %zmm19 {z}{k1} + +vcvtdq2ps %zmm16, %zmm19 +vcvtdq2ps (%rax), %zmm19 +vcvtdq2ps (%rax){1to16}, %zmm19 +vcvtdq2ps %zmm16, %zmm19 {k1} +vcvtdq2ps (%rax), %zmm19 {k1} +vcvtdq2ps (%rax){1to16}, %zmm19 {k1} +vcvtdq2ps %zmm16, %zmm19 {z}{k1} +vcvtdq2ps (%rax), %zmm19 {z}{k1} +vcvtdq2ps (%rax){1to16}, %zmm19 {z}{k1} + +vcvtpd2dq %zmm16, %ymm19 +vcvtpd2dq (%rax), %ymm19 +vcvtpd2dq (%rax){1to8}, %ymm19 +vcvtpd2dq %zmm16, %ymm19 {k1} +vcvtpd2dq (%rax), %ymm19 {k1} +vcvtpd2dq (%rax){1to8}, %ymm19 {k1} +vcvtpd2dq %zmm16, %ymm19 {z}{k1} +vcvtpd2dq (%rax), %ymm19 {z}{k1} +vcvtpd2dq (%rax){1to8}, %ymm19 {z}{k1} + +vcvtpd2udq %zmm16, %ymm19 +vcvtpd2udq (%rax), %ymm19 +vcvtpd2udq (%rax){1to8}, %ymm19 +vcvtpd2udq %zmm16, %ymm19 {k1} +vcvtpd2udq (%rax), %ymm19 {k1} +vcvtpd2udq (%rax){1to8}, %ymm19 {k1} +vcvtpd2udq %zmm16, %ymm19 {z}{k1} +vcvtpd2udq (%rax), %ymm19 {z}{k1} +vcvtpd2udq (%rax){1to8}, %ymm19 {z}{k1} + +vcvttpd2dq %zmm16, %ymm19 +vcvttpd2dq (%rax), %ymm19 +vcvttpd2dq (%rax){1to8}, %ymm19 +vcvttpd2dq %zmm16, %ymm19 {k1} +vcvttpd2dq (%rax), %ymm19 {k1} +vcvttpd2dq (%rax){1to8}, %ymm19 {k1} +vcvttpd2dq %zmm16, %ymm19 {z}{k1} +vcvttpd2dq (%rax), %ymm19 {z}{k1} +vcvttpd2dq (%rax){1to8}, %ymm19 {z}{k1} + +vcvttpd2udq %zmm16, %ymm19 +vcvttpd2udq (%rax), %ymm19 +vcvttpd2udq (%rax){1to8}, %ymm19 +vcvttpd2udq %zmm16, %ymm19 {k1} +vcvttpd2udq (%rax), %ymm19 {k1} +vcvttpd2udq (%rax){1to8}, %ymm19 {k1} +vcvttpd2udq %zmm16, %ymm19 {z}{k1} +vcvttpd2udq (%rax), %ymm19 {z}{k1} +vcvttpd2udq (%rax){1to8}, %ymm19 {z}{k1} + +vcvtpd2ps %zmm16, %ymm19 +vcvtpd2ps (%rax), %ymm19 +vcvtpd2ps (%rax){1to8}, %ymm19 +vcvtpd2ps %zmm16, %ymm19 {k1} +vcvtpd2ps (%rax), %ymm19 {k1} +vcvtpd2ps (%rax){1to8}, %ymm19 {k1} +vcvtpd2ps %zmm16, %ymm19 {z}{k1} +vcvtpd2ps (%rax), %ymm19 {z}{k1} +vcvtpd2ps (%rax){1to8}, %ymm19 {z}{k1} + +vcvtps2dq %zmm16, %zmm19 +vcvtps2dq (%rax), %zmm19 +vcvtps2dq (%rax){1to16}, %zmm19 +vcvtps2dq %zmm16, %zmm19 {k1} +vcvtps2dq (%rax), %zmm19 {k1} +vcvtps2dq (%rax){1to16}, %zmm19 {k1} +vcvtps2dq %zmm16, %zmm19 {z}{k1} +vcvtps2dq (%rax), %zmm19 {z}{k1} +vcvtps2dq (%rax){1to16}, %zmm19 {z}{k1} + +vcvttps2dq %zmm16, %zmm19 +vcvttps2dq (%rax), %zmm19 +vcvttps2dq (%rax){1to16}, %zmm19 +vcvttps2dq %zmm16, %zmm19 {k1} +vcvttps2dq (%rax), %zmm19 {k1} +vcvttps2dq (%rax){1to16}, %zmm19 {k1} +vcvttps2dq %zmm16, %zmm19 {z}{k1} +vcvttps2dq (%rax), %zmm19 {z}{k1} +vcvttps2dq (%rax){1to16}, %zmm19 {z}{k1} + +vcvtps2pd %ymm16, %zmm19 +vcvtps2pd (%rax), %zmm19 +vcvtps2pd (%rax){1to8}, %zmm19 +vcvtps2pd %ymm16, %zmm19 {k1} +vcvtps2pd (%rax), %zmm19 {k1} +vcvtps2pd (%rax){1to8}, %zmm19 {k1} +vcvtps2pd %ymm16, %zmm19 {z}{k1} +vcvtps2pd (%rax), %zmm19 {z}{k1} +vcvtps2pd (%rax){1to8}, %zmm19 {z}{k1} + +vcvtsd2usi %xmm0, %ecx +vcvtsd2usi %xmm0, %rcx +vcvtsd2usi (%rax), %ecx +vcvtsd2usi (%rax), %rcx + +vcvtss2usi %xmm0, %ecx +vcvtss2usi %xmm0, %rcx +vcvtss2usi (%rax), %ecx +vcvtss2usi (%rax), %rcx + +vcvtps2udq %zmm16, %zmm19 +vcvtps2udq (%rax), %zmm19 +vcvtps2udq (%rax){1to16}, %zmm19 +vcvtps2udq %zmm16, %zmm19 {k1} +vcvtps2udq (%rax), %zmm19 {k1} +vcvtps2udq (%rax){1to16}, %zmm19 {k1} +vcvtps2udq %zmm16, %zmm19 {z}{k1} +vcvtps2udq (%rax), %zmm19 {z}{k1} +vcvtps2udq (%rax){1to16}, %zmm19 {z}{k1} + +vcvttps2udq %zmm16, %zmm19 +vcvttps2udq (%rax), %zmm19 +vcvttps2udq (%rax){1to16}, %zmm19 +vcvttps2udq %zmm16, %zmm19 {k1} +vcvttps2udq (%rax), %zmm19 {k1} +vcvttps2udq (%rax){1to16}, %zmm19 {k1} +vcvttps2udq %zmm16, %zmm19 {z}{k1} +vcvttps2udq (%rax), %zmm19 {z}{k1} +vcvttps2udq (%rax){1to16}, %zmm19 {z}{k1} + +vcvttsd2usi %xmm0, %ecx +vcvttsd2usi %xmm0, %rcx +vcvttsd2usi (%rax), %ecx +vcvttsd2usi (%rax), %rcx + +vcvttss2usi %xmm0, %ecx +vcvttss2usi %xmm0, %rcx +vcvttss2usi (%rax), %ecx +vcvttss2usi (%rax), %rcx + +vcvtudq2pd %ymm16, %zmm19 +vcvtudq2pd (%rax), %zmm19 +vcvtudq2pd (%rax){1to8}, %zmm19 +vcvtudq2pd %ymm16, %zmm19 {k1} +vcvtudq2pd (%rax), %zmm19 {k1} +vcvtudq2pd (%rax){1to8}, %zmm19 {k1} +vcvtudq2pd %ymm16, %zmm19 {z}{k1} +vcvtudq2pd (%rax), %zmm19 {z}{k1} +vcvtudq2pd (%rax){1to8}, %zmm19 {z}{k1} + +vcvtudq2ps %zmm16, %zmm19 +vcvtudq2ps (%rax), %zmm19 +vcvtudq2ps (%rax){1to16}, %zmm19 +vcvtudq2ps %zmm16, %zmm19 {k1} +vcvtudq2ps (%rax), %zmm19 {k1} +vcvtudq2ps (%rax){1to16}, %zmm19 {k1} +vcvtudq2ps %zmm16, %zmm19 {z}{k1} +vcvtudq2ps (%rax), %zmm19 {z}{k1} +vcvtudq2ps (%rax){1to16}, %zmm19 {z}{k1} + +vcvtusi2sdl %ecx, %xmm0, %xmm2 +vcvtusi2sdq %rcx, %xmm0, %xmm2 +vcvtusi2sdl (%rax), %xmm0, %xmm2 +vcvtusi2sdq (%rax), %xmm0, %xmm2 + +vcvtusi2ssl %ecx, %xmm0, %xmm2 +vcvtusi2ssq %rcx, %xmm0, %xmm2 +vcvtusi2ssl (%rax), %xmm0, %xmm2 +vcvtusi2ssq (%rax), %xmm0, %xmm2 + +vdivpd %zmm16, %zmm17, %zmm19 +vdivpd (%rax), %zmm17, %zmm19 +vdivpd (%rax){1to8}, %zmm17, %zmm19 +vdivpd %zmm16, %zmm17, %zmm19 {k1} +vdivpd (%rax), %zmm17, %zmm19 {k1} +vdivpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vdivpd %zmm16, %zmm17, %zmm19 {z}{k1} +vdivpd (%rax), %zmm17, %zmm19 {z}{k1} +vdivpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vdivps %zmm16, %zmm17, %zmm19 +vdivps (%rax), %zmm17, %zmm19 +vdivps (%rax){1to16}, %zmm17, %zmm19 +vdivps %zmm16, %zmm17, %zmm19 {k1} +vdivps (%rax), %zmm17, %zmm19 {k1} +vdivps (%rax){1to16}, %zmm17, %zmm19 {k1} +vdivps %zmm16, %zmm17, %zmm19 {z}{k1} +vdivps (%rax), %zmm17, %zmm19 {z}{k1} +vdivps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vgatherdpd (%rax,%ymm1,2), %zmm2 {k1} +vgatherdps (%rax,%zmm1,2), %zmm2 {k1} +vgatherqpd (%rax,%zmm1,2), %zmm2 {k1} +vgatherqps (%rax,%zmm1,2), %ymm2 {k1} + +vmaxpd %zmm16, %zmm17, %zmm19 +vmaxpd (%rax), %zmm17, %zmm19 +vmaxpd (%rax){1to8}, %zmm17, %zmm19 +vmaxpd %zmm16, %zmm17, %zmm19 {k1} +vmaxpd (%rax), %zmm17, %zmm19 {k1} +vmaxpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vmaxpd %zmm16, %zmm17, %zmm19 {z}{k1} +vmaxpd (%rax), %zmm17, %zmm19 {z}{k1} +vmaxpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vmaxps %zmm16, %zmm17, %zmm19 +vmaxps (%rax), %zmm17, %zmm19 +vmaxps (%rax){1to16}, %zmm17, %zmm19 +vmaxps %zmm16, %zmm17, %zmm19 {k1} +vmaxps (%rax), %zmm17, %zmm19 {k1} +vmaxps (%rax){1to16}, %zmm17, %zmm19 {k1} +vmaxps %zmm16, %zmm17, %zmm19 {z}{k1} +vmaxps (%rax), %zmm17, %zmm19 {z}{k1} +vmaxps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vminpd %zmm16, %zmm17, %zmm19 +vminpd (%rax), %zmm17, %zmm19 +vminpd (%rax){1to8}, %zmm17, %zmm19 +vminpd %zmm16, %zmm17, %zmm19 {k1} +vminpd (%rax), %zmm17, %zmm19 {k1} +vminpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vminpd %zmm16, %zmm17, %zmm19 {z}{k1} +vminpd (%rax), %zmm17, %zmm19 {z}{k1} +vminpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vminps %zmm16, %zmm17, %zmm19 +vminps (%rax), %zmm17, %zmm19 +vminps (%rax){1to16}, %zmm17, %zmm19 +vminps %zmm16, %zmm17, %zmm19 {k1} +vminps (%rax), %zmm17, %zmm19 {k1} +vminps (%rax){1to16}, %zmm17, %zmm19 {k1} +vminps %zmm16, %zmm17, %zmm19 {z}{k1} +vminps (%rax), %zmm17, %zmm19 {z}{k1} +vminps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vmovapd %zmm16, %zmm19 +vmovapd (%rax), %zmm19 +vmovapd %zmm16, (%rax) +vmovapd %zmm16, %zmm19 {k1} +vmovapd (%rax), %zmm19 {k1} +vmovapd %zmm16, (%rax) {k1} +vmovapd %zmm16, %zmm19 {z}{k1} +vmovapd (%rax), %zmm19 {z}{k1} + +vmovaps %zmm16, %zmm19 +vmovaps (%rax), %zmm19 +vmovaps %zmm16, (%rax) +vmovaps %zmm16, %zmm19 {k1} +vmovaps (%rax), %zmm19 {k1} +vmovaps %zmm16, (%rax) {k1} +vmovaps %zmm16, %zmm19 {z}{k1} +vmovaps (%rax), %zmm19 {z}{k1} + +vmovddup %zmm16, %zmm19 +vmovddup (%rax), %zmm19 +vmovddup %zmm16, %zmm19 {k1} +vmovddup (%rax), %zmm19 {k1} +vmovddup %zmm16, %zmm19 {z}{k1} +vmovddup (%rax), %zmm19 {z}{k1} + +vmovdqa32 %zmm16, %zmm19 +vmovdqa32 (%rax), %zmm19 +vmovdqa32 %zmm16, (%rax) +vmovdqa32 %zmm16, %zmm19 {k1} +vmovdqa32 (%rax), %zmm19 {k1} +vmovdqa32 %zmm16, (%rax) {k1} +vmovdqa32 %zmm16, %zmm19 {z}{k1} +vmovdqa32 (%rax), %zmm19 {z}{k1} + +vmovdqa64 %zmm16, %zmm19 +vmovdqa64 (%rax), %zmm19 +vmovdqa64 %zmm16, (%rax) +vmovdqa64 %zmm16, %zmm19 {k1} +vmovdqa64 (%rax), %zmm19 {k1} +vmovdqa64 %zmm16, (%rax) {k1} +vmovdqa64 %zmm16, %zmm19 {z}{k1} +vmovdqa64 (%rax), %zmm19 {z}{k1} + +vmovdqu32 %zmm16, %zmm19 +vmovdqu32 (%rax), %zmm19 +vmovdqu32 %zmm16, (%rax) +vmovdqu32 %zmm16, %zmm19 {k1} +vmovdqu32 (%rax), %zmm19 {k1} +vmovdqu32 %zmm16, (%rax) {k1} +vmovdqu32 %zmm16, %zmm19 {z}{k1} +vmovdqu32 (%rax), %zmm19 {z}{k1} + +vmovdqu64 %zmm16, %zmm19 +vmovdqu64 (%rax), %zmm19 +vmovdqu64 %zmm16, (%rax) +vmovdqu64 %zmm16, %zmm19 {k1} +vmovdqu64 (%rax), %zmm19 {k1} +vmovdqu64 %zmm16, (%rax) {k1} +vmovdqu64 %zmm16, %zmm19 {z}{k1} +vmovdqu64 (%rax), %zmm19 {z}{k1} + +vmovshdup %zmm16, %zmm19 +vmovshdup (%rax), %zmm19 +vmovshdup %zmm16, %zmm19 {k1} +vmovshdup (%rax), %zmm19 {k1} +vmovshdup %zmm16, %zmm19 {z}{k1} +vmovshdup (%rax), %zmm19 {z}{k1} + +vmovsldup %zmm16, %zmm19 +vmovsldup (%rax), %zmm19 +vmovsldup %zmm16, %zmm19 {k1} +vmovsldup (%rax), %zmm19 {k1} +vmovsldup %zmm16, %zmm19 {z}{k1} +vmovsldup (%rax), %zmm19 {z}{k1} + +vmovupd %zmm16, %zmm19 +vmovupd (%rax), %zmm19 +vmovupd %zmm16, (%rax) +vmovupd %zmm16, %zmm19 {k1} +vmovupd (%rax), %zmm19 {k1} +vmovupd %zmm16, (%rax) {k1} +vmovupd %zmm16, %zmm19 {z}{k1} +vmovupd (%rax), %zmm19 {z}{k1} + +vmovups %zmm16, %zmm19 +vmovups (%rax), %zmm19 +vmovups %zmm16, (%rax) +vmovups %zmm16, %zmm19 {k1} +vmovups (%rax), %zmm19 {k1} +vmovups %zmm16, (%rax) {k1} +vmovups %zmm16, %zmm19 {z}{k1} +vmovups (%rax), %zmm19 {z}{k1} + +vmulpd %zmm16, %zmm17, %zmm19 +vmulpd (%rax), %zmm17, %zmm19 +vmulpd (%rax){1to8}, %zmm17, %zmm19 +vmulpd %zmm16, %zmm17, %zmm19 {k1} +vmulpd (%rax), %zmm17, %zmm19 {k1} +vmulpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vmulpd %zmm16, %zmm17, %zmm19 {z}{k1} +vmulpd (%rax), %zmm17, %zmm19 {z}{k1} +vmulpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vmulps %zmm16, %zmm17, %zmm19 +vmulps (%rax), %zmm17, %zmm19 +vmulps (%rax){1to16}, %zmm17, %zmm19 +vmulps %zmm16, %zmm17, %zmm19 {k1} +vmulps (%rax), %zmm17, %zmm19 {k1} +vmulps (%rax){1to16}, %zmm17, %zmm19 {k1} +vmulps %zmm16, %zmm17, %zmm19 {z}{k1} +vmulps (%rax), %zmm17, %zmm19 {z}{k1} +vmulps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpabsd %zmm16, %zmm19 +vpabsd (%rax), %zmm19 +vpabsd (%rax){1to16}, %zmm19 +vpabsd %zmm16, %zmm19 {k1} +vpabsd (%rax), %zmm19 {k1} +vpabsd (%rax){1to16}, %zmm19 {k1} +vpabsd %zmm16, %zmm19 {z}{k1} +vpabsd (%rax), %zmm19 {z}{k1} +vpabsd (%rax){1to16}, %zmm19 {z}{k1} + +vpabsq %zmm16, %zmm19 +vpabsq (%rax), %zmm19 +vpabsq (%rax){1to8}, %zmm19 +vpabsq %zmm16, %zmm19 {k1} +vpabsq (%rax), %zmm19 {k1} +vpabsq (%rax){1to8}, %zmm19 {k1} +vpabsq %zmm16, %zmm19 {z}{k1} +vpabsq (%rax), %zmm19 {z}{k1} +vpabsq (%rax){1to8}, %zmm19 {z}{k1} + +vpaddd %zmm16, %zmm17, %zmm19 +vpaddd (%rax), %zmm17, %zmm19 +vpaddd (%rax){1to16}, %zmm17, %zmm19 +vpaddd %zmm16, %zmm17, %zmm19 {k1} +vpaddd (%rax), %zmm17, %zmm19 {k1} +vpaddd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpaddd %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddd (%rax), %zmm17, %zmm19 {z}{k1} +vpaddd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpaddq %zmm16, %zmm17, %zmm19 +vpaddq (%rax), %zmm17, %zmm19 +vpaddq (%rax){1to8}, %zmm17, %zmm19 +vpaddq %zmm16, %zmm17, %zmm19 {k1} +vpaddq (%rax), %zmm17, %zmm19 {k1} +vpaddq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpaddq %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddq (%rax), %zmm17, %zmm19 {z}{k1} +vpaddq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpbroadcastd %xmm16, %zmm19 +vpbroadcastd (%rax), %zmm19 +vpbroadcastd %xmm16, %zmm19 {k1} +vpbroadcastd (%rax), %zmm19 {k1} +vpbroadcastd %xmm16, %zmm19 {z}{k1} +vpbroadcastd (%rax), %zmm19 {z}{k1} + +vpbroadcastq %xmm16, %zmm19 +vpbroadcastq (%rax), %zmm19 +vpbroadcastq %xmm16, %zmm19 {k1} +vpbroadcastq (%rax), %zmm19 {k1} +vpbroadcastq %xmm16, %zmm19 {z}{k1} +vpbroadcastq (%rax), %zmm19 {z}{k1} + +vpcmpd $0, %zmm0, %zmm1, %k2 +vpcmpd $0, (%rax), %zmm1, %k2 +vpcmpd $0, (%rax){1to16}, %zmm1, %k2 +vpcmpd $0, %zmm0, %zmm1, %k2 {k3} +vpcmpd $0, (%rax), %zmm1, %k2 {k3} +vpcmpd $0, (%rax){1to16}, %zmm1, %k2 {k3} + +vpcmpeqd %zmm0, %zmm1, %k2 +vpcmpeqd (%rax), %zmm1, %k2 +vpcmpeqd (%rax){1to16}, %zmm1, %k2 +vpcmpeqd %zmm0, %zmm1, %k2 {k3} +vpcmpeqd (%rax), %zmm1, %k2 {k3} +vpcmpeqd (%rax){1to16}, %zmm1, %k2 {k3} + +vpcmpeqq %zmm0, %zmm1, %k2 +vpcmpeqq (%rax), %zmm1, %k2 +vpcmpeqq (%rax){1to8}, %zmm1, %k2 +vpcmpeqq %zmm0, %zmm1, %k2 {k3} +vpcmpeqq (%rax), %zmm1, %k2 {k3} +vpcmpeqq (%rax){1to8}, %zmm1, %k2 {k3} + +vpcmpgtd %zmm0, %zmm1, %k2 +vpcmpgtd (%rax), %zmm1, %k2 +vpcmpgtd (%rax){1to16}, %zmm1, %k2 +vpcmpgtd %zmm0, %zmm1, %k2 {k3} +vpcmpgtd (%rax), %zmm1, %k2 {k3} +vpcmpgtd (%rax){1to16}, %zmm1, %k2 {k3} + +vpcmpgtq %zmm0, %zmm1, %k2 +vpcmpgtq (%rax), %zmm1, %k2 +vpcmpgtq (%rax){1to8}, %zmm1, %k2 +vpcmpgtq %zmm0, %zmm1, %k2 {k3} +vpcmpgtq (%rax), %zmm1, %k2 {k3} +vpcmpgtq (%rax){1to8}, %zmm1, %k2 {k3} + +vpcmpq $0, %zmm0, %zmm1, %k2 +vpcmpq $0, (%rax), %zmm1, %k2 +vpcmpq $0, (%rax){1to8}, %zmm1, %k2 +vpcmpq $0, %zmm0, %zmm1, %k2 {k3} +vpcmpq $0, (%rax), %zmm1, %k2 {k3} +vpcmpq $0, (%rax){1to8}, %zmm1, %k2 {k3} + +vpcmpud $0, %zmm0, %zmm1, %k2 +vpcmpud $0, (%rax), %zmm1, %k2 +vpcmpud $0, (%rax){1to16}, %zmm1, %k2 +vpcmpud $0, %zmm0, %zmm1, %k2 {k3} +vpcmpud $0, (%rax), %zmm1, %k2 {k3} +vpcmpud $0, (%rax){1to16}, %zmm1, %k2 {k3} + +vpcmpuq $0, %zmm0, %zmm1, %k2 +vpcmpuq $0, (%rax), %zmm1, %k2 +vpcmpuq $0, (%rax){1to8}, %zmm1, %k2 +vpcmpuq $0, %zmm0, %zmm1, %k2 {k3} +vpcmpuq $0, (%rax), %zmm1, %k2 {k3} +vpcmpuq $0, (%rax){1to8}, %zmm1, %k2 {k3} + +vpgatherdq (%rax,%ymm1,2), %zmm2 {k1} +vpgatherdd (%rax,%zmm1,2), %zmm2 {k1} +vpgatherqq (%rax,%zmm1,2), %zmm2 {k1} +vpgatherqd (%rax,%zmm1,2), %ymm2 {k1} + +vpmovsxbd %xmm16, %zmm19 +vpmovsxbd (%rax), %zmm19 +vpmovsxbd %xmm16, %zmm19 {k1} +vpmovsxbd (%rax), %zmm19 {k1} +vpmovsxbd %xmm16, %zmm19 {z}{k1} +vpmovsxbd (%rax), %zmm19 {z}{k1} + +vpmovsxbq %xmm16, %zmm19 +vpmovsxbq (%rax), %zmm19 +vpmovsxbq %xmm16, %zmm19 {k1} +vpmovsxbq (%rax), %zmm19 {k1} +vpmovsxbq %xmm16, %zmm19 {z}{k1} +vpmovsxbq (%rax), %zmm19 {z}{k1} + +vpmovsxdq %ymm16, %zmm19 +vpmovsxdq (%rax), %zmm19 +vpmovsxdq %ymm16, %zmm19 {k1} +vpmovsxdq (%rax), %zmm19 {k1} +vpmovsxdq %ymm16, %zmm19 {z}{k1} +vpmovsxdq (%rax), %zmm19 {z}{k1} + +vpmovsxwd %ymm16, %zmm19 +vpmovsxwd (%rax), %zmm19 +vpmovsxwd %ymm16, %zmm19 {k1} +vpmovsxwd (%rax), %zmm19 {k1} +vpmovsxwd %ymm16, %zmm19 {z}{k1} +vpmovsxwd (%rax), %zmm19 {z}{k1} + +vpmovsxwq %xmm16, %zmm19 +vpmovsxwq (%rax), %zmm19 +vpmovsxwq %xmm16, %zmm19 {k1} +vpmovsxwq (%rax), %zmm19 {k1} +vpmovsxwq %xmm16, %zmm19 {z}{k1} +vpmovsxwq (%rax), %zmm19 {z}{k1} + +vpmovzxbd %xmm16, %zmm19 +vpmovzxbd (%rax), %zmm19 +vpmovzxbd %xmm16, %zmm19 {k1} +vpmovzxbd (%rax), %zmm19 {k1} +vpmovzxbd %xmm16, %zmm19 {z}{k1} +vpmovzxbd (%rax), %zmm19 {z}{k1} + +vpmovzxbq %xmm16, %zmm19 +vpmovzxbq (%rax), %zmm19 +vpmovzxbq %xmm16, %zmm19 {k1} +vpmovzxbq (%rax), %zmm19 {k1} +vpmovzxbq %xmm16, %zmm19 {z}{k1} +vpmovzxbq (%rax), %zmm19 {z}{k1} + +vpmovzxdq %ymm16, %zmm19 +vpmovzxdq (%rax), %zmm19 +vpmovzxdq %ymm16, %zmm19 {k1} +vpmovzxdq (%rax), %zmm19 {k1} +vpmovzxdq %ymm16, %zmm19 {z}{k1} +vpmovzxdq (%rax), %zmm19 {z}{k1} + +vpmovzxwd %ymm16, %zmm19 +vpmovzxwd (%rax), %zmm19 +vpmovzxwd %ymm16, %zmm19 {k1} +vpmovzxwd (%rax), %zmm19 {k1} +vpmovzxwd %ymm16, %zmm19 {z}{k1} +vpmovzxwd (%rax), %zmm19 {z}{k1} + +vpmovzxwq %xmm16, %zmm19 +vpmovzxwq (%rax), %zmm19 +vpmovzxwq %xmm16, %zmm19 {k1} +vpmovzxwq (%rax), %zmm19 {k1} +vpmovzxwq %xmm16, %zmm19 {z}{k1} +vpmovzxwq (%rax), %zmm19 {z}{k1} + +vpmulld %zmm16, %zmm17, %zmm19 +vpmulld (%rax), %zmm17, %zmm19 +vpmulld (%rax){1to16}, %zmm17, %zmm19 +vpmulld %zmm16, %zmm17, %zmm19 {k1} +vpmulld (%rax), %zmm17, %zmm19 {k1} +vpmulld (%rax){1to16}, %zmm17, %zmm19 {k1} +vpmulld %zmm16, %zmm17, %zmm19 {z}{k1} +vpmulld (%rax), %zmm17, %zmm19 {z}{k1} +vpmulld (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpermd %zmm16, %zmm17, %zmm19 +vpermd (%rax), %zmm17, %zmm19 +vpermd (%rax){1to16}, %zmm17, %zmm19 +vpermd %zmm16, %zmm17, %zmm19 {k1} +vpermd (%rax), %zmm17, %zmm19 {k1} +vpermd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpermd %zmm16, %zmm17, %zmm19 {z}{k1} +vpermd (%rax), %zmm17, %zmm19 {z}{k1} +vpermd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpermilpd $0, %zmm16, %zmm19 +vpermilpd $0, (%rax), %zmm19 +vpermilpd $0, (%rax){1to8}, %zmm19 +vpermilpd $0, %zmm16, %zmm19 {k1} +vpermilpd $0, (%rax), %zmm19 {k1} +vpermilpd $0, (%rax){1to8}, %zmm19 {k1} +vpermilpd $0, %zmm16, %zmm19 {z}{k1} +vpermilpd $0, (%rax), %zmm19 {z}{k1} +vpermilpd $0, (%rax){1to8}, %zmm19 {z}{k1} + +vpermilpd %zmm16, %zmm17, %zmm19 +vpermilpd (%rax), %zmm17, %zmm19 +vpermilpd (%rax){1to8}, %zmm17, %zmm19 +vpermilpd %zmm16, %zmm17, %zmm19 {k1} +vpermilpd (%rax), %zmm17, %zmm19 {k1} +vpermilpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vpermilpd %zmm16, %zmm17, %zmm19 {z}{k1} +vpermilpd (%rax), %zmm17, %zmm19 {z}{k1} +vpermilpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpermilps $0, %zmm16, %zmm19 +vpermilps $0, (%rax), %zmm19 +vpermilps $0, (%rax){1to16}, %zmm19 +vpermilps $0, %zmm16, %zmm19 {k1} +vpermilps $0, (%rax), %zmm19 {k1} +vpermilps $0, (%rax){1to16}, %zmm19 {k1} +vpermilps $0, %zmm16, %zmm19 {z}{k1} +vpermilps $0, (%rax), %zmm19 {z}{k1} +vpermilps $0, (%rax){1to16}, %zmm19 {z}{k1} + +vpermilps %zmm16, %zmm17, %zmm19 +vpermilps (%rax), %zmm17, %zmm19 +vpermilps (%rax){1to16}, %zmm17, %zmm19 +vpermilps %zmm16, %zmm17, %zmm19 {k1} +vpermilps (%rax), %zmm17, %zmm19 {k1} +vpermilps (%rax){1to16}, %zmm17, %zmm19 {k1} +vpermilps %zmm16, %zmm17, %zmm19 {z}{k1} +vpermilps (%rax), %zmm17, %zmm19 {z}{k1} +vpermilps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpermpd $0, %zmm16, %zmm19 +vpermpd $0, (%rax), %zmm19 +vpermpd $0, (%rax){1to8}, %zmm19 +vpermpd $0, %zmm16, %zmm19 {k1} +vpermpd $0, (%rax), %zmm19 {k1} +vpermpd $0, (%rax){1to8}, %zmm19 {k1} +vpermpd $0, %zmm16, %zmm19 {z}{k1} +vpermpd $0, (%rax), %zmm19 {z}{k1} +vpermpd $0, (%rax){1to8}, %zmm19 {z}{k1} + +vpermpd %zmm16, %zmm17, %zmm19 +vpermpd (%rax), %zmm17, %zmm19 +vpermpd (%rax){1to8}, %zmm17, %zmm19 +vpermpd %zmm16, %zmm17, %zmm19 {k1} +vpermpd (%rax), %zmm17, %zmm19 {k1} +vpermpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vpermpd %zmm16, %zmm17, %zmm19 {z}{k1} +vpermpd (%rax), %zmm17, %zmm19 {z}{k1} +vpermpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpermps %zmm16, %zmm17, %zmm19 +vpermps (%rax), %zmm17, %zmm19 +vpermps (%rax){1to16}, %zmm17, %zmm19 +vpermps %zmm16, %zmm17, %zmm19 {k1} +vpermps (%rax), %zmm17, %zmm19 {k1} +vpermps (%rax){1to16}, %zmm17, %zmm19 {k1} +vpermps %zmm16, %zmm17, %zmm19 {z}{k1} +vpermps (%rax), %zmm17, %zmm19 {z}{k1} +vpermps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpermq $0, %zmm16, %zmm19 +vpermq $0, (%rax), %zmm19 +vpermq $0, (%rax){1to8}, %zmm19 +vpermq $0, %zmm16, %zmm19 {k1} +vpermq $0, (%rax), %zmm19 {k1} +vpermq $0, (%rax){1to8}, %zmm19 {k1} +vpermq $0, %zmm16, %zmm19 {z}{k1} +vpermq $0, (%rax), %zmm19 {z}{k1} +vpermq $0, (%rax){1to8}, %zmm19 {z}{k1} + +vpermq %zmm16, %zmm17, %zmm19 +vpermq (%rax), %zmm17, %zmm19 +vpermq (%rax){1to8}, %zmm17, %zmm19 +vpermq %zmm16, %zmm17, %zmm19 {k1} +vpermq (%rax), %zmm17, %zmm19 {k1} +vpermq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpermq %zmm16, %zmm17, %zmm19 {z}{k1} +vpermq (%rax), %zmm17, %zmm19 {z}{k1} +vpermq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpshufd $0, %zmm16, %zmm19 +vpshufd $0, (%rax), %zmm19 +vpshufd $0, (%rax){1to16}, %zmm19 +vpshufd $0, %zmm16, %zmm19 {k1} +vpshufd $0, (%rax), %zmm19 {k1} +vpshufd $0, (%rax){1to16}, %zmm19 {k1} +vpshufd $0, %zmm16, %zmm19 {z}{k1} +vpshufd $0, (%rax), %zmm19 {z}{k1} +vpshufd $0, (%rax){1to16}, %zmm19 {z}{k1} + +vpsubd %zmm16, %zmm17, %zmm19 +vpsubd (%rax), %zmm17, %zmm19 +vpsubd (%rax){1to16}, %zmm17, %zmm19 +vpsubd %zmm16, %zmm17, %zmm19 {k1} +vpsubd (%rax), %zmm17, %zmm19 {k1} +vpsubd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpsubd %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubd (%rax), %zmm17, %zmm19 {z}{k1} +vpsubd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpsubq %zmm16, %zmm17, %zmm19 +vpsubq (%rax), %zmm17, %zmm19 +vpsubq (%rax){1to8}, %zmm17, %zmm19 +vpsubq %zmm16, %zmm17, %zmm19 {k1} +vpsubq (%rax), %zmm17, %zmm19 {k1} +vpsubq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpsubq %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubq (%rax), %zmm17, %zmm19 {z}{k1} +vpsubq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpunpckhdq %zmm16, %zmm17, %zmm19 +vpunpckhdq (%rax), %zmm17, %zmm19 +vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 +vpunpckhdq %zmm16, %zmm17, %zmm19 {k1} +vpunpckhdq (%rax), %zmm17, %zmm19 {k1} +vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {k1} +vpunpckhdq %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpckhdq (%rax), %zmm17, %zmm19 {z}{k1} +vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpunpckhqdq %zmm16, %zmm17, %zmm19 +vpunpckhqdq (%rax), %zmm17, %zmm19 +vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 +vpunpckhqdq %zmm16, %zmm17, %zmm19 {k1} +vpunpckhqdq (%rax), %zmm17, %zmm19 {k1} +vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpunpckhqdq %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpckhqdq (%rax), %zmm17, %zmm19 {z}{k1} +vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vpunpckldq %zmm16, %zmm17, %zmm19 +vpunpckldq (%rax), %zmm17, %zmm19 +vpunpckldq (%rax){1to16}, %zmm17, %zmm19 +vpunpckldq %zmm16, %zmm17, %zmm19 {k1} +vpunpckldq (%rax), %zmm17, %zmm19 {k1} +vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {k1} +vpunpckldq %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpckldq (%rax), %zmm17, %zmm19 {z}{k1} +vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpunpcklqdq %zmm16, %zmm17, %zmm19 +vpunpcklqdq (%rax), %zmm17, %zmm19 +vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 +vpunpcklqdq %zmm16, %zmm17, %zmm19 {k1} +vpunpcklqdq (%rax), %zmm17, %zmm19 {k1} +vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpunpcklqdq %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpcklqdq (%rax), %zmm17, %zmm19 {z}{k1} +vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vshuff32x4 $0, %zmm16, %zmm17, %zmm19 +vshuff32x4 $0, (%rax), %zmm17, %zmm19 +vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {k1} +vshuff32x4 $0, (%rax), %zmm17, %zmm19 {k1} +vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {k1} +vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vshuff32x4 $0, (%rax), %zmm17, %zmm19 {z}{k1} +vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vshuff64x2 $0, %zmm16, %zmm17, %zmm19 +vshuff64x2 $0, (%rax), %zmm17, %zmm19 +vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {k1} +vshuff64x2 $0, (%rax), %zmm17, %zmm19 {k1} +vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {k1} +vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vshuff64x2 $0, (%rax), %zmm17, %zmm19 {z}{k1} +vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vshufi32x4 $0, %zmm16, %zmm17, %zmm19 +vshufi32x4 $0, (%rax), %zmm17, %zmm19 +vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {k1} +vshufi32x4 $0, (%rax), %zmm17, %zmm19 {k1} +vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {k1} +vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vshufi32x4 $0, (%rax), %zmm17, %zmm19 {z}{k1} +vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vshufi64x2 $0, %zmm16, %zmm17, %zmm19 +vshufi64x2 $0, (%rax), %zmm17, %zmm19 +vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {k1} +vshufi64x2 $0, (%rax), %zmm17, %zmm19 {k1} +vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {k1} +vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vshufi64x2 $0, (%rax), %zmm17, %zmm19 {z}{k1} +vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vsqrtpd %zmm16, %zmm19 +vsqrtpd (%rax), %zmm19 +vsqrtpd (%rax){1to8}, %zmm19 +vsqrtpd %zmm16, %zmm19 {k1} +vsqrtpd (%rax), %zmm19 {k1} +vsqrtpd (%rax){1to8}, %zmm19 {k1} +vsqrtpd %zmm16, %zmm19 {z}{k1} +vsqrtpd (%rax), %zmm19 {z}{k1} +vsqrtpd (%rax){1to8}, %zmm19 {z}{k1} + +vsqrtps %zmm16, %zmm19 +vsqrtps (%rax), %zmm19 +vsqrtps (%rax){1to16}, %zmm19 +vsqrtps %zmm16, %zmm19 {k1} +vsqrtps (%rax), %zmm19 {k1} +vsqrtps (%rax){1to16}, %zmm19 {k1} +vsqrtps %zmm16, %zmm19 {z}{k1} +vsqrtps (%rax), %zmm19 {z}{k1} +vsqrtps (%rax){1to16}, %zmm19 {z}{k1} + +vsqrtsd %xmm16, %xmm17, %xmm19 +vsqrtsd (%rax), %xmm17, %xmm19 +vsqrtsd %xmm16, %xmm17, %xmm19 {k1} +vsqrtsd (%rax), %xmm17, %xmm19 {k1} +vsqrtsd %xmm16, %xmm17, %xmm19 {z}{k1} +vsqrtsd (%rax), %xmm17, %xmm19 {z}{k1} + +vsqrtss %xmm16, %xmm17, %xmm19 +vsqrtss (%rax), %xmm17, %xmm19 +vsqrtss %xmm16, %xmm17, %xmm19 {k1} +vsqrtss (%rax), %xmm17, %xmm19 {k1} +vsqrtss %xmm16, %xmm17, %xmm19 {z}{k1} +vsqrtss (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubd %zmm16, %zmm17, %zmm19 +vpsubd (%rax), %zmm17, %zmm19 +vpsubd (%rax){1to16}, %zmm17, %zmm19 +vpsubd %zmm16, %zmm17, %zmm19 {k1} +vpsubd (%rax), %zmm17, %zmm19 {k1} +vpsubd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpsubd %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubd (%rax), %zmm17, %zmm19 {z}{k1} +vpsubd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpsubq %zmm16, %zmm17, %zmm19 +vpsubq (%rax), %zmm17, %zmm19 +vpsubq (%rax){1to8}, %zmm17, %zmm19 +vpsubq %zmm16, %zmm17, %zmm19 {k1} +vpsubq (%rax), %zmm17, %zmm19 {k1} +vpsubq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpsubq %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubq (%rax), %zmm17, %zmm19 {z}{k1} +vpsubq (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vptestmd %zmm0, %zmm1, %k2 +vptestmd (%rax), %zmm1, %k2 +vptestmd (%rax){1to16}, %zmm1, %k2 +vptestmd %zmm0, %zmm1, %k2 {k3} +vptestmd (%rax), %zmm1, %k2 {k3} +vptestmd (%rax){1to16}, %zmm1, %k2 {k3} + +vptestmq %zmm0, %zmm1, %k2 +vptestmq (%rax), %zmm1, %k2 +vptestmq (%rax){1to8}, %zmm1, %k2 +vptestmq %zmm0, %zmm1, %k2 {k3} +vptestmq (%rax), %zmm1, %k2 {k3} +vptestmq (%rax){1to8}, %zmm1, %k2 {k3} + +vptestnmd %zmm0, %zmm1, %k2 +vptestnmd (%rax), %zmm1, %k2 +vptestnmd (%rax){1to16}, %zmm1, %k2 +vptestnmd %zmm0, %zmm1, %k2 {k3} +vptestnmd (%rax), %zmm1, %k2 {k3} +vptestnmd (%rax){1to16}, %zmm1, %k2 {k3} + +vptestnmq %zmm0, %zmm1, %k2 +vptestnmq (%rax), %zmm1, %k2 +vptestnmq (%rax){1to8}, %zmm1, %k2 +vptestnmq %zmm0, %zmm1, %k2 {k3} +vptestnmq (%rax), %zmm1, %k2 {k3} +vptestnmq (%rax){1to8}, %zmm1, %k2 {k3} + +vsubpd %zmm16, %zmm17, %zmm19 +vsubpd (%rax), %zmm17, %zmm19 +vsubpd (%rax){1to8}, %zmm17, %zmm19 +vsubpd %zmm16, %zmm17, %zmm19 {k1} +vsubpd (%rax), %zmm17, %zmm19 {k1} +vsubpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vsubpd %zmm16, %zmm17, %zmm19 {z}{k1} +vsubpd (%rax), %zmm17, %zmm19 {z}{k1} +vsubpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vsubps %zmm16, %zmm17, %zmm19 +vsubps (%rax), %zmm17, %zmm19 +vsubps (%rax){1to16}, %zmm17, %zmm19 +vsubps %zmm16, %zmm17, %zmm19 {k1} +vsubps (%rax), %zmm17, %zmm19 {k1} +vsubps (%rax){1to16}, %zmm17, %zmm19 {k1} +vsubps %zmm16, %zmm17, %zmm19 {z}{k1} +vsubps (%rax), %zmm17, %zmm19 {z}{k1} +vsubps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vucomiss %xmm16, %xmm17 +vucomiss (%rax), %xmm17 + +vunpckhpd %zmm16, %zmm17, %zmm19 +vunpckhpd (%rax), %zmm17, %zmm19 +vunpckhpd (%rax){1to8}, %zmm17, %zmm19 +vunpckhpd %zmm16, %zmm17, %zmm19 {k1} +vunpckhpd (%rax), %zmm17, %zmm19 {k1} +vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vunpckhpd %zmm16, %zmm17, %zmm19 {z}{k1} +vunpckhpd (%rax), %zmm17, %zmm19 {z}{k1} +vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vunpckhps %zmm16, %zmm17, %zmm19 +vunpckhps (%rax), %zmm17, %zmm19 +vunpckhps (%rax){1to16}, %zmm17, %zmm19 +vunpckhps %zmm16, %zmm17, %zmm19 {k1} +vunpckhps (%rax), %zmm17, %zmm19 {k1} +vunpckhps (%rax){1to16}, %zmm17, %zmm19 {k1} +vunpckhps %zmm16, %zmm17, %zmm19 {z}{k1} +vunpckhps (%rax), %zmm17, %zmm19 {z}{k1} +vunpckhps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vunpcklpd %zmm16, %zmm17, %zmm19 +vunpcklpd (%rax), %zmm17, %zmm19 +vunpcklpd (%rax){1to8}, %zmm17, %zmm19 +vunpcklpd %zmm16, %zmm17, %zmm19 {k1} +vunpcklpd (%rax), %zmm17, %zmm19 {k1} +vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vunpcklpd %zmm16, %zmm17, %zmm19 {z}{k1} +vunpcklpd (%rax), %zmm17, %zmm19 {z}{k1} +vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vunpcklps %zmm16, %zmm17, %zmm19 +vunpcklps (%rax), %zmm17, %zmm19 +vunpcklps (%rax){1to16}, %zmm17, %zmm19 +vunpcklps %zmm16, %zmm17, %zmm19 {k1} +vunpcklps (%rax), %zmm17, %zmm19 {k1} +vunpcklps (%rax){1to16}, %zmm17, %zmm19 {k1} +vunpcklps %zmm16, %zmm17, %zmm19 {z}{k1} +vunpcklps (%rax), %zmm17, %zmm19 {z}{k1} +vunpcklps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 1.00 kandw %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandnw %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 knotw %k0, %k2 +# CHECK-NEXT: 1 1 1.00 korw %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxnorw %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxorw %k0, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftlw $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftrw $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kunpckbw %k0, %k1, %k2 +# CHECK-NEXT: 1 3 0.50 vaddpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 0.50 vaddpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vaddps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 0.50 vaddps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 valignd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 valignd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 valignd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 valignq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 valignq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 valignq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf32x4 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf64x4 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcastf64x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf64x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti32x4 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti64x4 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcasti64x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti64x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastsd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastsd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vbroadcastsd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastss (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastss (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vbroadcastss (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqps %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqps %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqsd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqsd (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqsd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqsd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqss %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqss (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqss %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqss (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcomiss %xmm16, %xmm17 +# CHECK-NEXT: 2 8 1.00 * vcomiss (%rax), %xmm17 +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %ymm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtdq2ps %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtdq2ps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtdq2ps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtdq2ps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtps2dq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtps2dq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtps2dq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtps2dq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvttps2dq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvttps2dq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvttps2dq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttps2dq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %ymm16, %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax), %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtsd2usi %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 vcvtsd2usi %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * vcvtsd2usi (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvtsd2usi (%rax), %rcx +# CHECK-NEXT: 2 7 1.00 vcvtss2usi %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 vcvtss2usi %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * vcvtss2usi (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvtss2usi (%rax), %rcx +# CHECK-NEXT: 1 4 1.00 vcvtps2udq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtps2udq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtps2udq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtps2udq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvttps2udq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvttps2udq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvttps2udq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttps2udq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttsd2usi %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 vcvttsd2usi %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * vcvttsd2usi (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvttsd2usi (%rax), %rcx +# CHECK-NEXT: 2 7 1.00 vcvttss2usi %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 vcvttss2usi %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * vcvttss2usi (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * vcvttss2usi (%rax), %rcx +# CHECK-NEXT: 2 7 1.00 vcvtudq2pd %ymm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvtudq2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtudq2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtudq2ps %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtudq2ps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtudq2ps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtudq2ps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtusi2sd %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtusi2sd %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtusi2sdl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtusi2sdq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2 7 1.00 vcvtusi2ss %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 3 8 2.00 vcvtusi2ss %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vcvtusi2ssl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * vcvtusi2ssq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 3 23 2.00 vdivpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 3 23 2.00 vdivpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 23 2.00 vdivpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 30 2.00 * vdivpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 17 2.00 vdivps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 3 18 2.00 vdivps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 18 2.00 vdivps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 25 2.00 * vdivps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 11 28 2.67 * vgatherdpd (%rax,%ymm1,2), %zmm2 {%k1} +# CHECK-NEXT: 19 30 5.33 * vgatherdps (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 11 28 2.67 * vgatherqpd (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 11 28 2.67 * vgatherqps (%rax,%zmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1 4 1.00 vmaxpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vmaxpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vmaxpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmaxpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vmaxps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vmaxps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vmaxps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmaxps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vminpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vminpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vminpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vminpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vminps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vminps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vminps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vminps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vminps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vminps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vminps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vminps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vminps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovapd %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovapd (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovapd %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovapd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovapd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovapd %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovapd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovapd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovaps %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovaps (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovaps %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovaps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovaps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovaps %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovaps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovaps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vmovddup %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovddup (%rax), %zmm19 +# CHECK-NEXT: 1 1 1.00 vmovddup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovddup (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vmovddup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovddup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa32 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqa32 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovdqa32 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovdqa32 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovdqa32 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovdqa32 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa64 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqa64 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovdqa64 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovdqa64 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovdqa64 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovdqa64 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu32 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu32 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovdqu32 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovdqu32 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovdqu32 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovdqu32 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu64 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu64 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovdqu64 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovdqu64 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovdqu64 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovdqu64 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vmovshdup %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovshdup (%rax), %zmm19 +# CHECK-NEXT: 1 1 1.00 vmovshdup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovshdup (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vmovshdup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovshdup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vmovsldup %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovsldup (%rax), %zmm19 +# CHECK-NEXT: 1 1 1.00 vmovsldup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovsldup (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vmovsldup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovsldup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovupd %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovupd (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovupd %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovupd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovupd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovupd %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovupd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovupd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovups %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovups (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovups %zmm16, (%rax) +# CHECK-NEXT: 1 1 0.50 vmovups %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vmovups (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovups %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vmovups %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vmovups (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vmulpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vmulpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vmulpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmulpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vmulps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vmulps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vmulps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vmulps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpabsd %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax), %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpabsd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpabsd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpabsd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpabsq %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax), %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpabsq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpabsq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpabsq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpaddd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpaddd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpaddd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpaddq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpaddq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpaddq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpbroadcastd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpbroadcastd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpbroadcastq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpbroadcastq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 11 28 2.67 * vpgatherdq (%rax,%ymm1,2), %zmm2 {%k1} +# CHECK-NEXT: 19 30 5.33 * vpgatherdd (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 11 28 2.67 * vpgatherqq (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 11 28 2.67 * vpgatherqd (%rax,%zmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 10 2.00 vpmulld %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 2 10 2.00 vpmulld %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 10 2.00 vpmulld %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 18 2.00 * vpmulld (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpermilps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermq $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermq $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermq $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpermq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshufd $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax), %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshufd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpshufd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshufd $0, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpckhdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpunpckhdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpunpckhdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpckhqdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpunpckhqdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpunpckhqdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpckldq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpunpckldq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpunpckldq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpcklqdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpunpcklqdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpunpcklqdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 31 2.00 vsqrtpd %zmm16, %zmm19 +# CHECK-NEXT: 4 38 2.00 * vsqrtpd (%rax), %zmm19 +# CHECK-NEXT: 4 39 2.00 * vsqrtpd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 3 32 2.00 vsqrtpd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 4 31 2.00 * vsqrtpd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 4 31 2.00 * vsqrtpd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 3 32 2.00 vsqrtpd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 31 2.00 * vsqrtpd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 4 31 2.00 * vsqrtpd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 19 2.00 vsqrtps %zmm16, %zmm19 +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax), %zmm19 +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 3 20 2.00 vsqrtps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 3 20 2.00 vsqrtps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 4 27 2.00 * vsqrtps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 18 1.00 vsqrtsd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 24 1.00 * vsqrtsd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 18 1.00 vsqrtsd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vsqrtsd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 18 1.00 vsqrtsd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vsqrtsd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 12 1.00 vsqrtss %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 19 1.00 * vsqrtss (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 12 1.00 vsqrtss %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 19 1.00 * vsqrtss (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 12 1.00 vsqrtss %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 19 1.00 * vsqrtss (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vptestmd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmd %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmq %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 0.50 vsubpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 0.50 vsubpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vsubps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 0.50 vsubps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vucomiss %xmm16, %xmm17 +# CHECK-NEXT: 2 8 1.00 * vucomiss (%rax), %xmm17 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpckhps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vunpckhps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vunpcklpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vunpcklps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 436.00 12.00 206.33 206.33 8.00 575.00 - 8.00 8.00 8.00 - 206.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandw %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandnw %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - knotw %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - korw %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxnorw %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxorw %k0, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftlw $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftrw $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kunpckbw %k0, %k1, %k2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vaddps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf32x4 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf64x4 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf64x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf64x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x4 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti64x4 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti64x4 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti64x4 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastsd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastsd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastsd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastss (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastss (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastss (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqsd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqsd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqsd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqsd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqss %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqss (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqss %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqss (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcomiss %xmm16, %xmm17 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcomiss (%rax), %xmm17 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtdq2pd %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtdq2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtdq2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtdq2ps %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtdq2ps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtdq2ps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2dq %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2dq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2dq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2udq %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2udq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2udq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2dq %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2dq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2dq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2udq %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2udq %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttpd2udq %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2ps %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtpd2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2dq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2dq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2dq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2dq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2dq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2dq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2pd %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtsd2usi %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtsd2usi %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsd2usi (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtsd2usi (%rax), %rcx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvtss2usi %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - vcvtss2usi %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtss2usi (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtss2usi (%rax), %rcx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2udq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2udq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtps2udq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2udq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2udq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttps2udq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttsd2usi %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttsd2usi %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttsd2usi (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttsd2usi (%rax), %rcx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - vcvttss2usi %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - vcvttss2usi %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttss2usi (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttss2usi (%rax), %rcx +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtudq2pd %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtudq2pd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtudq2pd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtudq2ps %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtudq2ps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtudq2ps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtudq2ps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtusi2sd %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtusi2sd %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtusi2sdl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtusi2sdq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtusi2ss %ecx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 2.00 - - - - - - - vcvtusi2ss %rcx, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtusi2ssl (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtusi2ssq (%rax), %xmm0, %xmm2 +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vdivps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vdivps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vgatherdpd (%rax,%ymm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 5.33 5.33 - 2.00 - - - - - 5.33 - vgatherdps (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vgatherqpd (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vgatherqps (%rax,%zmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmaxps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vminps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovapd %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovapd (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovapd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovapd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovapd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovapd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovaps %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovaps (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovaps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovaps (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovaps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovaps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovddup (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovddup (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovddup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa32 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa32 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqa32 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqa32 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqa32 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqa32 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa64 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa64 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqa64 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqa64 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqa64 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqa64 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu32 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu32 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu32 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu32 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu32 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu32 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu64 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu64 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu64 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu64 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu64 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu64 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovshdup %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovshdup (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovshdup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovshdup (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovshdup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovshdup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovsldup %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsldup (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovsldup %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovsldup (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovsldup %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovsldup (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovupd %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovupd (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovupd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovupd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovupd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovupd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovups %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovups (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovups %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovups (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovups %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovups (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vmulps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsd %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpbroadcastd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpbroadcastd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpbroadcastq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpbroadcastq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vpgatherdq (%rax,%ymm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 5.33 5.33 - 2.00 - - - - - 5.33 - vpgatherdd (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vpgatherqq (%rax,%zmm1,2), %zmm2 {%k1} +# CHECK-NEXT: 1.00 - 2.67 2.67 - 2.00 - - - - - 2.67 - vpgatherqd (%rax,%zmm1,2), %ymm2 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2.00 - - - - - - - - - - - - vpmulld %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 2.00 - - - - - - - - - - - - vpmulld %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2.00 - - - - - - - - - - - - vpmulld %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to16}, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to8}, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufd $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax), %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax){1to16}, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufd $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufd $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufd $0, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhdq (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhqdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhqdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhqdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckldq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckldq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckldq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckldq (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklqdq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklqdq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklqdq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklqdq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtpd %zmm16, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax), %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtpd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtpd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtpd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtps %zmm16, %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax), %zmm19 +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax){1to16}, %zmm19 +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtps %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 2.50 - - - - 0.50 - - - - - - - vsqrtps %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsqrtps (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtsd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtsd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtsd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtsd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtsd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtsd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtss %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtss (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtss %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtss (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtss %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtss (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to16}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to16}, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to8}, %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to8}, %zmm1, %k2 {%k3} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vsubps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vucomiss %xmm16, %xmm17 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vucomiss (%rax), %xmm17 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalg.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalg.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalg.s @@ -0,0 +1,85 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpopcntb %zmm1, %zmm0 +vpopcntb (%rdi), %zmm0 +vpopcntb %zmm1, %zmm0 {%k1} +vpopcntb (%rdi), %zmm0 {%k1} +vpopcntb %zmm1, %zmm0 {%k1} {z} +vpopcntb (%rdi), %zmm0 {%k1} {z} + +vpopcntw %zmm1, %zmm0 +vpopcntw (%rdi), %zmm0 +vpopcntw %zmm1, %zmm0 {%k1} +vpopcntw (%rdi), %zmm0 {%k1} +vpopcntw %zmm1, %zmm0 {%k1} {z} +vpopcntw (%rdi), %zmm0 {%k1} {z} + +vpshufbitqmb %zmm16, %zmm17, %k2 +vpshufbitqmb (%rdi), %zmm17, %k2 +vpshufbitqmb %zmm16, %zmm17, %k2 {%k1} +vpshufbitqmb (%rdi), %zmm17, %k2 {%k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpopcntb %zmm1, %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntb (%rdi), %zmm0 +# CHECK-NEXT: 1 5 1.00 vpopcntb %zmm1, %zmm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %zmm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntb %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntw %zmm1, %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntw (%rdi), %zmm0 +# CHECK-NEXT: 1 5 1.00 vpopcntw %zmm1, %zmm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %zmm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntw %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: 2 6 1.00 vpshufbitqmb %zmm16, %zmm17, %k2 +# CHECK-NEXT: 3 6 1.00 * vpshufbitqmb (%rdi), %zmm17, %k2 +# CHECK-NEXT: 2 8 1.00 vpshufbitqmb %zmm16, %zmm17, %k2 {%k1} +# CHECK-NEXT: 3 8 1.00 * vpshufbitqmb (%rdi), %zmm17, %k2 {%k1} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 4.00 - 2.67 2.67 - 16.00 - - - - - 2.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %zmm1, %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %zmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %zmm1, %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %zmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %zmm1, %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %zmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %zmm1, %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %zmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %zmm16, %zmm17, %k2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %zmm17, %k2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %zmm16, %zmm17, %k2 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %zmm17, %k2 {%k1} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalgvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalgvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bitalgvl.s @@ -0,0 +1,136 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpopcntb %xmm1, %xmm0 +vpopcntb (%rdi), %xmm0 +vpopcntb %xmm1, %xmm0 {%k1} +vpopcntb (%rdi), %xmm0 {%k1} +vpopcntb %xmm1, %xmm0 {%k1} {z} +vpopcntb (%rdi), %xmm0 {%k1} {z} + +vpopcntb %ymm1, %ymm0 +vpopcntb (%rdi), %ymm0 +vpopcntb %ymm1, %ymm0 {%k1} +vpopcntb (%rdi), %ymm0 {%k1} +vpopcntb %ymm1, %ymm0 {%k1} {z} +vpopcntb (%rdi), %ymm0 {%k1} {z} + +vpopcntw %xmm1, %xmm0 +vpopcntw (%rdi), %xmm0 +vpopcntw %xmm1, %xmm0 {%k1} +vpopcntw (%rdi), %xmm0 {%k1} +vpopcntw %xmm1, %xmm0 {%k1} {z} +vpopcntw (%rdi), %xmm0 {%k1} {z} + +vpopcntw %ymm1, %ymm0 +vpopcntw (%rdi), %ymm0 +vpopcntw %ymm1, %ymm0 {%k1} +vpopcntw (%rdi), %ymm0 {%k1} +vpopcntw %ymm1, %ymm0 {%k1} {z} +vpopcntw (%rdi), %ymm0 {%k1} {z} + +vpshufbitqmb %xmm16, %xmm17, %k2 +vpshufbitqmb (%rdi), %xmm17, %k2 +vpshufbitqmb %xmm16, %xmm17, %k2 {%k1} +vpshufbitqmb (%rdi), %xmm17, %k2 {%k1} + +vpshufbitqmb %ymm16, %ymm17, %k2 +vpshufbitqmb (%rdi), %ymm17, %k2 +vpshufbitqmb %ymm16, %ymm17, %k2 {%k1} +vpshufbitqmb (%rdi), %ymm17, %k2 {%k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpopcntb %xmm1, %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntb (%rdi), %xmm0 +# CHECK-NEXT: 1 5 1.00 vpopcntb %xmm1, %xmm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %xmm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntb %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntb %ymm1, %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntb (%rdi), %ymm0 +# CHECK-NEXT: 1 5 1.00 vpopcntb %ymm1, %ymm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %ymm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntb %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntb (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntw %xmm1, %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntw (%rdi), %xmm0 +# CHECK-NEXT: 1 5 1.00 vpopcntw %xmm1, %xmm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %xmm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntw %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntw %ymm1, %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntw (%rdi), %ymm0 +# CHECK-NEXT: 1 5 1.00 vpopcntw %ymm1, %ymm0 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %ymm0 {%k1} +# CHECK-NEXT: 1 5 1.00 vpopcntw %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpopcntw (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: 2 6 1.00 vpshufbitqmb %xmm16, %xmm17, %k2 +# CHECK-NEXT: 3 6 1.00 * vpshufbitqmb (%rdi), %xmm17, %k2 +# CHECK-NEXT: 2 8 1.00 vpshufbitqmb %xmm16, %xmm17, %k2 {%k1} +# CHECK-NEXT: 3 8 1.00 * vpshufbitqmb (%rdi), %xmm17, %k2 {%k1} +# CHECK-NEXT: 2 6 1.00 vpshufbitqmb %ymm16, %ymm17, %k2 +# CHECK-NEXT: 3 6 1.00 * vpshufbitqmb (%rdi), %ymm17, %k2 +# CHECK-NEXT: 2 8 1.00 vpshufbitqmb %ymm16, %ymm17, %k2 {%k1} +# CHECK-NEXT: 3 8 1.00 * vpshufbitqmb (%rdi), %ymm17, %k2 {%k1} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 8.00 - 5.33 5.33 - 32.00 - - - - - 5.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %xmm1, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %xmm1, %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %xmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %ymm1, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %ymm1, %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %ymm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntb %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntb (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %xmm1, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %xmm1, %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %xmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %ymm1, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %ymm1, %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %ymm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntw %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntw (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %xmm16, %xmm17, %k2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %xmm17, %k2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %xmm16, %xmm17, %k2 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %xmm17, %k2 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %ymm16, %ymm17, %k2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %ymm17, %k2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpshufbitqmb %ymm16, %ymm17, %k2 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufbitqmb (%rdi), %ymm17, %k2 {%k1} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bw.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bw.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bw.s @@ -0,0 +1,1635 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +kaddd %k0, %k1, %k2 +kaddq %k0, %k1, %k2 + +kandd %k0, %k1, %k2 +kandq %k0, %k1, %k2 + +kandnd %k0, %k1, %k2 +kandnq %k0, %k1, %k2 + +kmovd %k0, %k2 +kmovd (%rax), %k2 +kmovd %k0, (%rax) +kmovd %eax, %k2 +kmovd %k0, %eax + +kmovq %k0, %k2 +kmovq (%rax), %k2 +kmovq %k0, (%rax) +kmovq %rax, %k2 +kmovq %k0, %rax + +knotd %k0, %k2 +knotq %k0, %k2 + +kord %k0, %k1, %k2 +korq %k0, %k1, %k2 + +kortestd %k0, %k2 +kortestq %k0, %k2 + +kshiftld $2, %k1, %k2 +kshiftlq $2, %k1, %k2 + +kshiftrd $2, %k1, %k2 +kshiftrq $2, %k1, %k2 + +ktestd %k0, %k2 +ktestq %k0, %k2 + +kunpckdq %k0, %k1, %k2 +kunpckwd %k0, %k1, %k2 + +kxnord %k0, %k1, %k2 +kxnorq %k0, %k1, %k2 + +kxord %k0, %k1, %k2 +kxorq %k0, %k1, %k2 + +vdbpsadbw $0, %zmm16, %zmm17, %zmm19 +vdbpsadbw $0, (%rax), %zmm17, %zmm19 +vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {k1} +vdbpsadbw $0, (%rax), %zmm17, %zmm19 {k1} +vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vdbpsadbw $0, (%rax), %zmm17, %zmm19 {z}{k1} + +vmovdqu8 %zmm16, %zmm19 +vmovdqu8 (%rax), %zmm19 +vmovdqu8 %zmm16, (%rax) +vmovdqu8 %zmm16, %zmm19 {k1} +vmovdqu8 (%rax), %zmm19 {k1} +vmovdqu8 %zmm16, (%rax) {k1} +vmovdqu8 %zmm16, %zmm19 {z}{k1} +vmovdqu8 (%rax), %zmm19 {z}{k1} + +vmovdqu16 %zmm16, %zmm19 +vmovdqu16 (%rax), %zmm19 +vmovdqu16 %zmm16, (%rax) +vmovdqu16 %zmm16, %zmm19 {k1} +vmovdqu16 (%rax), %zmm19 {k1} +vmovdqu16 %zmm16, (%rax) {k1} +vmovdqu16 %zmm16, %zmm19 {z}{k1} +vmovdqu16 (%rax), %zmm19 {z}{k1} + +vpabsb %zmm16, %zmm19 +vpabsb (%rax), %zmm19 +vpabsb %zmm16, %zmm19 {k1} +vpabsb (%rax), %zmm19 {k1} +vpabsb %zmm16, %zmm19 {z}{k1} +vpabsb (%rax), %zmm19 {z}{k1} + +vpabsw %zmm16, %zmm19 +vpabsw (%rax), %zmm19 +vpabsw %zmm16, %zmm19 {k1} +vpabsw (%rax), %zmm19 {k1} +vpabsw %zmm16, %zmm19 {z}{k1} +vpabsw (%rax), %zmm19 {z}{k1} + +vpackssdw %zmm16, %zmm17, %zmm19 +vpackssdw (%rax), %zmm17, %zmm19 +vpackssdw %zmm16, %zmm17, %zmm19 {k1} +vpackssdw (%rax), %zmm17, %zmm19 {k1} +vpackssdw %zmm16, %zmm17, %zmm19 {z}{k1} +vpackssdw (%rax), %zmm17, %zmm19 {z}{k1} + +vpacksswb %zmm16, %zmm17, %zmm19 +vpacksswb (%rax), %zmm17, %zmm19 +vpacksswb %zmm16, %zmm17, %zmm19 {k1} +vpacksswb (%rax), %zmm17, %zmm19 {k1} +vpacksswb %zmm16, %zmm17, %zmm19 {z}{k1} +vpacksswb (%rax), %zmm17, %zmm19 {z}{k1} + +vpackusdw %zmm16, %zmm17, %zmm19 +vpackusdw (%rax), %zmm17, %zmm19 +vpackusdw %zmm16, %zmm17, %zmm19 {k1} +vpackusdw (%rax), %zmm17, %zmm19 {k1} +vpackusdw %zmm16, %zmm17, %zmm19 {z}{k1} +vpackusdw (%rax), %zmm17, %zmm19 {z}{k1} + +vpackuswb %zmm16, %zmm17, %zmm19 +vpackuswb (%rax), %zmm17, %zmm19 +vpackuswb %zmm16, %zmm17, %zmm19 {k1} +vpackuswb (%rax), %zmm17, %zmm19 {k1} +vpackuswb %zmm16, %zmm17, %zmm19 {z}{k1} +vpackuswb (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddb %zmm16, %zmm17, %zmm19 +vpaddb (%rax), %zmm17, %zmm19 +vpaddb %zmm16, %zmm17, %zmm19 {k1} +vpaddb (%rax), %zmm17, %zmm19 {k1} +vpaddb %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddb (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddsb %zmm16, %zmm17, %zmm19 +vpaddsb (%rax), %zmm17, %zmm19 +vpaddsb %zmm16, %zmm17, %zmm19 {k1} +vpaddsb (%rax), %zmm17, %zmm19 {k1} +vpaddsb %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddsb (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddsw %zmm16, %zmm17, %zmm19 +vpaddsw (%rax), %zmm17, %zmm19 +vpaddsw %zmm16, %zmm17, %zmm19 {k1} +vpaddsw (%rax), %zmm17, %zmm19 {k1} +vpaddsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddusb %zmm16, %zmm17, %zmm19 +vpaddusb (%rax), %zmm17, %zmm19 +vpaddusb %zmm16, %zmm17, %zmm19 {k1} +vpaddusb (%rax), %zmm17, %zmm19 {k1} +vpaddusb %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddusb (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddusw %zmm16, %zmm17, %zmm19 +vpaddusw (%rax), %zmm17, %zmm19 +vpaddusw %zmm16, %zmm17, %zmm19 {k1} +vpaddusw (%rax), %zmm17, %zmm19 {k1} +vpaddusw %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddusw (%rax), %zmm17, %zmm19 {z}{k1} + +vpaddw %zmm16, %zmm17, %zmm19 +vpaddw (%rax), %zmm17, %zmm19 +vpaddw %zmm16, %zmm17, %zmm19 {k1} +vpaddw (%rax), %zmm17, %zmm19 {k1} +vpaddw %zmm16, %zmm17, %zmm19 {z}{k1} +vpaddw (%rax), %zmm17, %zmm19 {z}{k1} + +vpalignr $1, %zmm16, %zmm17, %zmm19 +vpalignr $1, (%rax), %zmm17, %zmm19 +vpalignr $1, %zmm16, %zmm17, %zmm19 {k1} +vpalignr $1, (%rax), %zmm17, %zmm19 {k1} +vpalignr $1, %zmm16, %zmm17, %zmm19 {z}{k1} +vpalignr $1, (%rax), %zmm17, %zmm19 {z}{k1} + +vpavgb %zmm16, %zmm17, %zmm19 +vpavgb (%rax), %zmm17, %zmm19 +vpavgb %zmm16, %zmm17, %zmm19 {k1} +vpavgb (%rax), %zmm17, %zmm19 {k1} +vpavgb %zmm16, %zmm17, %zmm19 {z}{k1} +vpavgb (%rax), %zmm17, %zmm19 {z}{k1} + +vpavgw %zmm16, %zmm17, %zmm19 +vpavgw (%rax), %zmm17, %zmm19 +vpavgw %zmm16, %zmm17, %zmm19 {k1} +vpavgw (%rax), %zmm17, %zmm19 {k1} +vpavgw %zmm16, %zmm17, %zmm19 {z}{k1} +vpavgw (%rax), %zmm17, %zmm19 {z}{k1} + +vpblendmb %zmm16, %zmm17, %zmm19 +vpblendmb (%rax), %zmm17, %zmm19 +vpblendmb %zmm16, %zmm17, %zmm19 {k1} +vpblendmb (%rax), %zmm17, %zmm19 {k1} +vpblendmb %zmm16, %zmm17, %zmm19 {z}{k1} +vpblendmb (%rax), %zmm17, %zmm19 {z}{k1} + +vpblendmw %zmm16, %zmm17, %zmm19 +vpblendmw (%rax), %zmm17, %zmm19 +vpblendmw %zmm16, %zmm17, %zmm19 {k1} +vpblendmw (%rax), %zmm17, %zmm19 {k1} +vpblendmw %zmm16, %zmm17, %zmm19 {z}{k1} +vpblendmw (%rax), %zmm17, %zmm19 {z}{k1} + +vpbroadcastb %xmm16, %zmm19 +vpbroadcastb (%rax), %zmm19 +vpbroadcastb %eax, %zmm19 +vpbroadcastb %xmm16, %zmm19 {k1} +vpbroadcastb (%rax), %zmm19 {k1} +vpbroadcastb %eax, %zmm19 {k1} +vpbroadcastb %xmm16, %zmm19 {z}{k1} +vpbroadcastb (%rax), %zmm19 {z}{k1} +vpbroadcastb %eax, %zmm19 {z}{k1} + +vpbroadcastw %xmm16, %zmm19 +vpbroadcastw (%rax), %zmm19 +vpbroadcastw %eax, %zmm19 +vpbroadcastw %xmm16, %zmm19 {k1} +vpbroadcastw (%rax), %zmm19 {k1} +vpbroadcastw %eax, %zmm19 {k1} +vpbroadcastw %xmm16, %zmm19 {z}{k1} +vpbroadcastw (%rax), %zmm19 {z}{k1} +vpbroadcastw %eax, %zmm19 {z}{k1} + +vpcmpb $0, %zmm0, %zmm1, %k2 +vpcmpb $0, (%rax), %zmm1, %k2 +vpcmpb $0, %zmm0, %zmm1, %k2 {k3} +vpcmpb $0, (%rax), %zmm1, %k2 {k3} + +vpcmpeqb %zmm0, %zmm1, %k2 +vpcmpeqb (%rax), %zmm1, %k2 +vpcmpeqb %zmm0, %zmm1, %k2 {k3} +vpcmpeqb (%rax), %zmm1, %k2 {k3} + +vpcmpeqw %zmm0, %zmm1, %k2 +vpcmpeqw (%rax), %zmm1, %k2 +vpcmpeqw %zmm0, %zmm1, %k2 {k3} +vpcmpeqw (%rax), %zmm1, %k2 {k3} + +vpcmpgtb %zmm0, %zmm1, %k2 +vpcmpgtb (%rax), %zmm1, %k2 +vpcmpgtb %zmm0, %zmm1, %k2 {k3} +vpcmpgtb (%rax), %zmm1, %k2 {k3} + +vpcmpgtw %zmm0, %zmm1, %k2 +vpcmpgtw (%rax), %zmm1, %k2 +vpcmpgtw %zmm0, %zmm1, %k2 {k3} +vpcmpgtw (%rax), %zmm1, %k2 {k3} + +vpcmpub $0, %zmm0, %zmm1, %k2 +vpcmpub $0, (%rax), %zmm1, %k2 +vpcmpub $0, %zmm0, %zmm1, %k2 {k3} +vpcmpub $0, (%rax), %zmm1, %k2 {k3} + +vpcmpuw $0, %zmm0, %zmm1, %k2 +vpcmpuw $0, (%rax), %zmm1, %k2 +vpcmpuw $0, %zmm0, %zmm1, %k2 {k3} +vpcmpuw $0, (%rax), %zmm1, %k2 {k3} + +vpcmpw $0, %zmm0, %zmm1, %k2 +vpcmpw $0, (%rax), %zmm1, %k2 +vpcmpw $0, %zmm0, %zmm1, %k2 {k3} +vpcmpw $0, (%rax), %zmm1, %k2 {k3} + +vpextrb $0, %xmm16, %rax +vpextrb $0, %xmm16, (%rax) + +vpextrw $0, %xmm16, %rax +vpextrw $0, %xmm16, (%rax) + +vpinsrb $0, %rax, %xmm16, %xmm19 +vpinsrb $0, (%rax), %xmm16, %xmm19 + +vpinsrw $0, %rax, %xmm16, %xmm19 +vpinsrw $0, (%rax), %xmm16, %xmm19 + +vpermw %zmm16, %zmm17, %zmm19 +vpermw (%rax), %zmm17, %zmm19 +vpermw %zmm16, %zmm17, %zmm19 {k1} +vpermw (%rax), %zmm17, %zmm19 {k1} +vpermw %zmm16, %zmm17, %zmm19 {z}{k1} +vpermw (%rax), %zmm17, %zmm19 {z}{k1} + +vpermi2w %zmm16, %zmm17, %zmm19 +vpermi2w (%rax), %zmm17, %zmm19 +vpermi2w %zmm16, %zmm17, %zmm19 {k1} +vpermi2w (%rax), %zmm17, %zmm19 {k1} +vpermi2w %zmm16, %zmm17, %zmm19 {z}{k1} +vpermi2w (%rax), %zmm17, %zmm19 {z}{k1} + +vpermt2w %zmm16, %zmm17, %zmm19 +vpermt2w (%rax), %zmm17, %zmm19 +vpermt2w %zmm16, %zmm17, %zmm19 {k1} +vpermt2w (%rax), %zmm17, %zmm19 {k1} +vpermt2w %zmm16, %zmm17, %zmm19 {z}{k1} +vpermt2w (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaddubsw %zmm16, %zmm17, %zmm19 +vpmaddubsw (%rax), %zmm17, %zmm19 +vpmaddubsw %zmm16, %zmm17, %zmm19 {k1} +vpmaddubsw (%rax), %zmm17, %zmm19 {k1} +vpmaddubsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaddubsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaddwd %zmm16, %zmm17, %zmm19 +vpmaddwd (%rax), %zmm17, %zmm19 +vpmaddwd %zmm16, %zmm17, %zmm19 {k1} +vpmaddwd (%rax), %zmm17, %zmm19 {k1} +vpmaddwd %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaddwd (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaxsb %zmm16, %zmm17, %zmm19 +vpmaxsb (%rax), %zmm17, %zmm19 +vpmaxsb %zmm16, %zmm17, %zmm19 {k1} +vpmaxsb (%rax), %zmm17, %zmm19 {k1} +vpmaxsb %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaxsb (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaxsw %zmm16, %zmm17, %zmm19 +vpmaxsw (%rax), %zmm17, %zmm19 +vpmaxsw %zmm16, %zmm17, %zmm19 {k1} +vpmaxsw (%rax), %zmm17, %zmm19 {k1} +vpmaxsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaxsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaxub %zmm16, %zmm17, %zmm19 +vpmaxub (%rax), %zmm17, %zmm19 +vpmaxub %zmm16, %zmm17, %zmm19 {k1} +vpmaxub (%rax), %zmm17, %zmm19 {k1} +vpmaxub %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaxub (%rax), %zmm17, %zmm19 {z}{k1} + +vpmaxuw %zmm16, %zmm17, %zmm19 +vpmaxuw (%rax), %zmm17, %zmm19 +vpmaxuw %zmm16, %zmm17, %zmm19 {k1} +vpmaxuw (%rax), %zmm17, %zmm19 {k1} +vpmaxuw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmaxuw (%rax), %zmm17, %zmm19 {z}{k1} + +vpminsb %zmm16, %zmm17, %zmm19 +vpminsb (%rax), %zmm17, %zmm19 +vpminsb %zmm16, %zmm17, %zmm19 {k1} +vpminsb (%rax), %zmm17, %zmm19 {k1} +vpminsb %zmm16, %zmm17, %zmm19 {z}{k1} +vpminsb (%rax), %zmm17, %zmm19 {z}{k1} + +vpminsw %zmm16, %zmm17, %zmm19 +vpminsw (%rax), %zmm17, %zmm19 +vpminsw %zmm16, %zmm17, %zmm19 {k1} +vpminsw (%rax), %zmm17, %zmm19 {k1} +vpminsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpminsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpminub %zmm16, %zmm17, %zmm19 +vpminub (%rax), %zmm17, %zmm19 +vpminub %zmm16, %zmm17, %zmm19 {k1} +vpminub (%rax), %zmm17, %zmm19 {k1} +vpminub %zmm16, %zmm17, %zmm19 {z}{k1} +vpminub (%rax), %zmm17, %zmm19 {z}{k1} + +vpminuw %zmm16, %zmm17, %zmm19 +vpminuw (%rax), %zmm17, %zmm19 +vpminuw %zmm16, %zmm17, %zmm19 {k1} +vpminuw (%rax), %zmm17, %zmm19 {k1} +vpminuw %zmm16, %zmm17, %zmm19 {z}{k1} +vpminuw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmovb2m %zmm0, %k0 +vpmovw2m %zmm0, %k0 + +vpmovm2b %k0, %zmm0 +vpmovm2w %k0, %zmm0 + +vpmovsxbw %ymm16, %zmm19 +vpmovsxbw (%rax), %zmm19 +vpmovsxbw %ymm16, %zmm19 {k1} +vpmovsxbw (%rax), %zmm19 {k1} +vpmovsxbw %ymm16, %zmm19 {z}{k1} +vpmovsxbw (%rax), %zmm19 {z}{k1} + +vpmovswb %zmm16, %ymm19 +vpmovswb %zmm16, (%rax) +vpmovswb %zmm16, %ymm19 {k1} +vpmovswb %zmm16, (%rax) {k1} + +vpmovuswb %zmm16, %ymm19 +vpmovuswb %zmm16, (%rax) +vpmovuswb %zmm16, %ymm19 {k1} +vpmovuswb %zmm16, (%rax) {k1} + +vpmovwb %zmm16, %ymm19 +vpmovwb %zmm16, (%rax) +vpmovwb %zmm16, %ymm19 {k1} +vpmovwb %zmm16, (%rax) {k1} + +vpmovzxbw %ymm16, %zmm19 +vpmovzxbw (%rax), %zmm19 +vpmovzxbw %ymm16, %zmm19 {k1} +vpmovzxbw (%rax), %zmm19 {k1} +vpmovzxbw %ymm16, %zmm19 {z}{k1} +vpmovzxbw (%rax), %zmm19 {z}{k1} + +vpmulhrsw %zmm16, %zmm17, %zmm19 +vpmulhrsw (%rax), %zmm17, %zmm19 +vpmulhrsw %zmm16, %zmm17, %zmm19 {k1} +vpmulhrsw (%rax), %zmm17, %zmm19 {k1} +vpmulhrsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmulhrsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmulhuw %zmm16, %zmm17, %zmm19 +vpmulhuw (%rax), %zmm17, %zmm19 +vpmulhuw %zmm16, %zmm17, %zmm19 {k1} +vpmulhuw (%rax), %zmm17, %zmm19 {k1} +vpmulhuw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmulhuw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmulhw %zmm16, %zmm17, %zmm19 +vpmulhw (%rax), %zmm17, %zmm19 +vpmulhw %zmm16, %zmm17, %zmm19 {k1} +vpmulhw (%rax), %zmm17, %zmm19 {k1} +vpmulhw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmulhw (%rax), %zmm17, %zmm19 {z}{k1} + +vpmullw %zmm16, %zmm17, %zmm19 +vpmullw (%rax), %zmm17, %zmm19 +vpmullw %zmm16, %zmm17, %zmm19 {k1} +vpmullw (%rax), %zmm17, %zmm19 {k1} +vpmullw %zmm16, %zmm17, %zmm19 {z}{k1} +vpmullw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsadbw %zmm16, %zmm17, %zmm19 +vpsadbw (%rax), %zmm17, %zmm19 + +vpshufb %zmm16, %zmm17, %zmm19 +vpshufb (%rax), %zmm17, %zmm19 +vpshufb %zmm16, %zmm17, %zmm19 {k1} +vpshufb (%rax), %zmm17, %zmm19 {k1} +vpshufb %zmm16, %zmm17, %zmm19 {z}{k1} +vpshufb (%rax), %zmm17, %zmm19 {z}{k1} + +vpshufhw $0, %zmm16, %zmm19 +vpshufhw $0, (%rax), %zmm19 +vpshufhw $0, %zmm16, %zmm19 {k1} +vpshufhw $0, (%rax), %zmm19 {k1} +vpshufhw $0, %zmm16, %zmm19 {z}{k1} +vpshufhw $0, (%rax), %zmm19 {z}{k1} + +vpshuflw $0, %zmm16, %zmm19 +vpshuflw $0, (%rax), %zmm19 +vpshuflw $0, %zmm16, %zmm19 {k1} +vpshuflw $0, (%rax), %zmm19 {k1} +vpshuflw $0, %zmm16, %zmm19 {z}{k1} +vpshuflw $0, (%rax), %zmm19 {z}{k1} + +vpslldq $1, %zmm16, %zmm19 +vpslldq $1, (%rax), %zmm19 + +vpsllvw %zmm16, %zmm17, %zmm19 +vpsllvw (%rax), %zmm17, %zmm19 +vpsllvw %zmm16, %zmm17, %zmm19 {k1} +vpsllvw (%rax), %zmm17, %zmm19 {k1} +vpsllvw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsllvw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsllw $0, %zmm16, %zmm19 +vpsllw $0, (%rax), %zmm19 +vpsllw $0, %zmm16, %zmm19 {k1} +vpsllw $0, (%rax), %zmm19 {k1} +vpsllw $0, %zmm16, %zmm19 {z}{k1} +vpsllw $0, (%rax), %zmm19 {z}{k1} + +vpsllw %xmm16, %zmm17, %zmm19 +vpsllw (%rax), %zmm17, %zmm19 +vpsllw %xmm16, %zmm17, %zmm19 {k1} +vpsllw (%rax), %zmm17, %zmm19 {k1} +vpsllw %xmm16, %zmm17, %zmm19 {z}{k1} +vpsllw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsravw %zmm16, %zmm17, %zmm19 +vpsravw (%rax), %zmm17, %zmm19 +vpsravw %zmm16, %zmm17, %zmm19 {k1} +vpsravw (%rax), %zmm17, %zmm19 {k1} +vpsravw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsravw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsraw $0, %zmm16, %zmm19 +vpsraw $0, (%rax), %zmm19 +vpsraw $0, %zmm16, %zmm19 {k1} +vpsraw $0, (%rax), %zmm19 {k1} +vpsraw $0, %zmm16, %zmm19 {z}{k1} +vpsraw $0, (%rax), %zmm19 {z}{k1} + +vpsraw %xmm16, %zmm17, %zmm19 +vpsraw (%rax), %zmm17, %zmm19 +vpsraw %xmm16, %zmm17, %zmm19 {k1} +vpsraw (%rax), %zmm17, %zmm19 {k1} +vpsraw %xmm16, %zmm17, %zmm19 {z}{k1} +vpsraw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsrldq $1, %zmm16, %zmm19 +vpsrldq $1, (%rax), %zmm19 + +vpsrlvw %zmm16, %zmm17, %zmm19 +vpsrlvw (%rax), %zmm17, %zmm19 +vpsrlvw %zmm16, %zmm17, %zmm19 {k1} +vpsrlvw (%rax), %zmm17, %zmm19 {k1} +vpsrlvw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsrlvw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsrlw $0, %zmm16, %zmm19 +vpsrlw $0, (%rax), %zmm19 +vpsrlw $0, %zmm16, %zmm19 {k1} +vpsrlw $0, (%rax), %zmm19 {k1} +vpsrlw $0, %zmm16, %zmm19 {z}{k1} +vpsrlw $0, (%rax), %zmm19 {z}{k1} + +vpsrlw %xmm16, %zmm17, %zmm19 +vpsrlw (%rax), %zmm17, %zmm19 +vpsrlw %xmm16, %zmm17, %zmm19 {k1} +vpsrlw (%rax), %zmm17, %zmm19 {k1} +vpsrlw %xmm16, %zmm17, %zmm19 {z}{k1} +vpsrlw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubb %zmm16, %zmm17, %zmm19 +vpsubb (%rax), %zmm17, %zmm19 +vpsubb %zmm16, %zmm17, %zmm19 {k1} +vpsubb (%rax), %zmm17, %zmm19 {k1} +vpsubb %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubb (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubsb %zmm16, %zmm17, %zmm19 +vpsubsb (%rax), %zmm17, %zmm19 +vpsubsb %zmm16, %zmm17, %zmm19 {k1} +vpsubsb (%rax), %zmm17, %zmm19 {k1} +vpsubsb %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubsb (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubsw %zmm16, %zmm17, %zmm19 +vpsubsw (%rax), %zmm17, %zmm19 +vpsubsw %zmm16, %zmm17, %zmm19 {k1} +vpsubsw (%rax), %zmm17, %zmm19 {k1} +vpsubsw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubsw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubusb %zmm16, %zmm17, %zmm19 +vpsubusb (%rax), %zmm17, %zmm19 +vpsubusb %zmm16, %zmm17, %zmm19 {k1} +vpsubusb (%rax), %zmm17, %zmm19 {k1} +vpsubusb %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubusb (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubusw %zmm16, %zmm17, %zmm19 +vpsubusw (%rax), %zmm17, %zmm19 +vpsubusw %zmm16, %zmm17, %zmm19 {k1} +vpsubusw (%rax), %zmm17, %zmm19 {k1} +vpsubusw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubusw (%rax), %zmm17, %zmm19 {z}{k1} + +vpsubw %zmm16, %zmm17, %zmm19 +vpsubw (%rax), %zmm17, %zmm19 +vpsubw %zmm16, %zmm17, %zmm19 {k1} +vpsubw (%rax), %zmm17, %zmm19 {k1} +vpsubw %zmm16, %zmm17, %zmm19 {z}{k1} +vpsubw (%rax), %zmm17, %zmm19 {z}{k1} + +vptestmb %zmm0, %zmm1, %k2 +vptestmb (%rax), %zmm1, %k2 +vptestmb %zmm0, %zmm1, %k2 {k3} +vptestmb (%rax), %zmm1, %k2 {k3} + +vptestmw %zmm0, %zmm1, %k2 +vptestmw (%rax), %zmm1, %k2 +vptestmw %zmm0, %zmm1, %k2 {k3} +vptestmw (%rax), %zmm1, %k2 {k3} + +vptestnmb %zmm0, %zmm1, %k2 +vptestnmb (%rax), %zmm1, %k2 +vptestnmb %zmm0, %zmm1, %k2 {k3} +vptestnmb (%rax), %zmm1, %k2 {k3} + +vptestnmw %zmm0, %zmm1, %k2 +vptestnmw (%rax), %zmm1, %k2 +vptestnmw %zmm0, %zmm1, %k2 {k3} +vptestnmw (%rax), %zmm1, %k2 {k3} + +vpunpckhbw %zmm16, %zmm17, %zmm19 +vpunpckhbw (%rax), %zmm17, %zmm19 +vpunpckhbw %zmm16, %zmm17, %zmm19 {k1} +vpunpckhbw (%rax), %zmm17, %zmm19 {k1} +vpunpckhbw %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpckhbw (%rax), %zmm17, %zmm19 {z}{k1} + +vpunpckhwd %zmm16, %zmm17, %zmm19 +vpunpckhwd (%rax), %zmm17, %zmm19 +vpunpckhwd %zmm16, %zmm17, %zmm19 {k1} +vpunpckhwd (%rax), %zmm17, %zmm19 {k1} +vpunpckhwd %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpckhwd (%rax), %zmm17, %zmm19 {z}{k1} + +vpunpcklbw %zmm16, %zmm17, %zmm19 +vpunpcklbw (%rax), %zmm17, %zmm19 +vpunpcklbw %zmm16, %zmm17, %zmm19 {k1} +vpunpcklbw (%rax), %zmm17, %zmm19 {k1} +vpunpcklbw %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpcklbw (%rax), %zmm17, %zmm19 {z}{k1} + +vpunpcklwd %zmm16, %zmm17, %zmm19 +vpunpcklwd (%rax), %zmm17, %zmm19 +vpunpcklwd %zmm16, %zmm17, %zmm19 {k1} +vpunpcklwd (%rax), %zmm17, %zmm19 {k1} +vpunpcklwd %zmm16, %zmm17, %zmm19 {z}{k1} +vpunpcklwd (%rax), %zmm17, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 4 1.00 kaddd %k0, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kaddq %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandd %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandq %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandnd %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandnq %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kmovd %k0, %k2 +# CHECK-NEXT: 2 7 1.00 * kmovd (%rax), %k2 +# CHECK-NEXT: 2 12 0.50 * kmovd %k0, (%rax) +# CHECK-NEXT: 1 3 1.00 kmovd %eax, %k2 +# CHECK-NEXT: 1 3 1.00 kmovd %k0, %eax +# CHECK-NEXT: 1 1 1.00 kmovq %k0, %k2 +# CHECK-NEXT: 2 7 1.00 * kmovq (%rax), %k2 +# CHECK-NEXT: 2 12 0.50 * kmovq %k0, (%rax) +# CHECK-NEXT: 1 1 1.00 kmovq %rax, %k2 +# CHECK-NEXT: 1 3 1.00 kmovq %k0, %rax +# CHECK-NEXT: 1 1 1.00 knotd %k0, %k2 +# CHECK-NEXT: 1 1 1.00 knotq %k0, %k2 +# CHECK-NEXT: 1 1 1.00 kord %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 korq %k0, %k1, %k2 +# CHECK-NEXT: 1 3 1.00 kortestd %k0, %k2 +# CHECK-NEXT: 1 3 1.00 kortestq %k0, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftld $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftlq $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftrd $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftrq $2, %k1, %k2 +# CHECK-NEXT: 1 3 1.00 ktestd %k0, %k2 +# CHECK-NEXT: 1 3 1.00 ktestq %k0, %k2 +# CHECK-NEXT: 1 4 1.00 kunpckdq %k0, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kunpckwd %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxnord %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxnorq %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxord %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxorq %k0, %k1, %k2 +# CHECK-NEXT: 1 3 1.00 vdbpsadbw $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vdbpsadbw $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu8 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu8 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu8 %zmm16, (%rax) +# CHECK-NEXT: 1 3 0.50 vmovdqu8 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmovdqu8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 5 12 1.00 * vmovdqu8 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.50 vmovdqu8 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmovdqu8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu16 %zmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu16 (%rax), %zmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %zmm16, (%rax) +# CHECK-NEXT: 1 3 0.50 vmovdqu16 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmovdqu16 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.50 vmovdqu16 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmovdqu16 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpabsb %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsb (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpabsb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpabsb (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpabsb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpabsb (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpabsw %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpabsw (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpabsw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpabsw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpabsw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpabsw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackssdw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpackssdw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpackssdw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackssdw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpacksswb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpacksswb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpacksswb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpacksswb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackusdw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpackusdw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpackusdw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackusdw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackuswb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpackuswb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpackuswb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackuswb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpaddb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpaddsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpaddsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpaddsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpaddsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpaddsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpaddsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpaddsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpaddsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpaddsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpaddsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpaddsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpaddsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpaddusb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpaddusb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpaddusb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpaddusb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpaddusb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpaddusb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpaddusw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpaddusw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpaddusw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpaddusw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpaddusw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpaddusw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpaddw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpaddw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpalignr $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpalignr $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpavgb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpavgb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpavgb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpavgb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpavgb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpavgb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpavgw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpavgw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpavgw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpavgw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpavgw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpavgw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpblendmb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpblendmb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpblendmb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpblendmb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpblendmb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpblendmb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpblendmw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpblendmw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpblendmw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpblendmw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpblendmw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpblendmw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastb %xmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastb (%rax), %zmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastw %xmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastw (%rax), %zmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 4 1.00 vpextrb $0, %xmm16, %eax +# CHECK-NEXT: 3 19 0.50 * vpextrb $0, %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpextrw $0, %xmm16, %eax +# CHECK-NEXT: 3 19 0.50 * vpextrw $0, %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpinsrb $0, %eax, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpinsrb $0, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 2 4 1.00 vpinsrw $0, %eax, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpinsrw $0, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 2 4 1.00 vpermw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 3 11 1.00 * vpermw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 6 1.00 vpermw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpermw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermi2w %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 15 2.00 * vpermi2w (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 9 2.00 vpermi2w %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 17 2.00 * vpermi2w (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermi2w %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 17 2.00 * vpermi2w (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermt2w %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 14 2.00 * vpermt2w (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 9 2.00 vpermt2w %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 16 2.00 * vpermt2w (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermt2w %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 16 2.00 * vpermt2w (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmaddubsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmaddubsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 7 1.00 vpmaddubsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 14 1.00 * vpmaddubsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 7 1.00 vpmaddubsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 14 1.00 * vpmaddubsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmaddwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmaddwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpmaddwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmaddwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmaddwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmaddwd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpmaxsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpmaxsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmaxsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmaxsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmaxsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmaxsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpmaxsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpmaxsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmaxsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmaxsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmaxsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmaxsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpmaxub %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpmaxub (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmaxub %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmaxub (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmaxub %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmaxub (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpmaxuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpmaxuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpmaxuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmaxuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmaxuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmaxuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpminsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpminsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpminsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpminsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpminsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpminsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpminsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpminsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpminsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpminsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpminsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpminsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpminub %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpminub (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpminub %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpminub (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpminub %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpminub (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpminuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpminuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpminuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpminuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpminuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpminuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovb2m %zmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovw2m %zmm0, %k0 +# CHECK-NEXT: 1 3 0.50 vpmovm2b %k0, %zmm0 +# CHECK-NEXT: 1 3 0.50 vpmovm2w %k0, %zmm0 +# CHECK-NEXT: 1 3 1.00 vpmovsxbw %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbw (%rax), %zmm19 +# CHECK-NEXT: 1 5 1.00 vpmovsxbw %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmovsxbw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmovsxbw %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmovsxbw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 4 2.00 vpmovswb %zmm16, %ymm19 +# CHECK-NEXT: 4 12 2.00 * vpmovswb %zmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpmovswb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 4 15 2.00 * vpmovswb %zmm16, (%rax) {%k1} +# CHECK-NEXT: 2 4 2.00 vpmovuswb %zmm16, %ymm19 +# CHECK-NEXT: 4 12 2.00 * vpmovuswb %zmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpmovuswb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 4 15 2.00 * vpmovuswb %zmm16, (%rax) {%k1} +# CHECK-NEXT: 2 4 2.00 vpmovwb %zmm16, %ymm19 +# CHECK-NEXT: 4 12 2.00 * vpmovwb %zmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpmovwb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 4 15 2.00 * vpmovwb %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxbw %ymm16, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbw (%rax), %zmm19 +# CHECK-NEXT: 1 5 1.00 vpmovzxbw %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmovzxbw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmovzxbw %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmovzxbw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmulhrsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmulhrsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 7 1.00 vpmulhrsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 14 1.00 * vpmulhrsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 7 1.00 vpmulhrsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 14 1.00 * vpmulhrsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmulhuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmulhuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 7 1.00 vpmulhuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 14 1.00 * vpmulhuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 7 1.00 vpmulhuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 14 1.00 * vpmulhuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmulhw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmulhw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 7 1.00 vpmulhw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 14 1.00 * vpmulhw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 7 1.00 vpmulhw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 14 1.00 * vpmulhw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpmullw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpmullw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 7 1.00 vpmullw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 14 1.00 * vpmullw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 7 1.00 vpmullw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 14 1.00 * vpmullw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpsadbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpsadbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshufb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshufb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpshufb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpshufb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpshufb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpshufb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshufhw $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshufhw $0, (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpshufhw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpshufhw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpshufhw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpshufhw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshuflw $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshuflw $0, (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpshuflw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpshuflw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpshuflw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpshuflw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpslldq $1, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpslldq $1, (%rax), %zmm19 +# CHECK-NEXT: 1 1 1.00 vpsllvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsllvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsllvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsllvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsllvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsllvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsllw $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsllw $0, (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsllw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsllw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsllw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsllw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsllw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsllw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 6 1.00 vpsllw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsllw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsllw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsllw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsravw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsravw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsravw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsravw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsravw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsravw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsraw $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsraw $0, (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsraw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsraw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsraw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsraw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsraw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsraw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 6 1.00 vpsraw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsraw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsraw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsraw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsrldq $1, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsrldq $1, (%rax), %zmm19 +# CHECK-NEXT: 1 1 1.00 vpsrlvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsrlvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsrlvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsrlvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsrlvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsrlvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsrlw $0, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsrlw $0, (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsrlw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsrlw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsrlw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsrlw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsrlw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsrlw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 6 1.00 vpsrlw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsrlw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsrlw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsrlw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpsubb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsubsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsubsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsubsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsubsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsubsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsubsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsubsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsubsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsubsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsubsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsubsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsubsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsubusb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsubusb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsubusb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsubusb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsubusb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsubusb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpsubusw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpsubusw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpsubusw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpsubusw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpsubusw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpsubusw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vpsubw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 0.50 vpsubw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vptestmb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmb %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmw %zmm0, %zmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %zmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1 1 1.00 vpunpckhbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpunpckhbw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpunpckhbw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpunpckhbw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpunpckhbw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpckhwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpckhwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpunpckhwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpunpckhwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpunpckhwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpunpckhwd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpcklbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpcklbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpunpcklbw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpunpcklbw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpunpcklbw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpunpcklbw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpunpcklwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpunpcklwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpunpcklwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpunpcklwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpunpcklwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpunpcklwd (%rax), %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 269.20 4.20 73.33 73.33 7.50 272.20 0.20 7.50 7.50 7.50 0.20 73.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kaddd %k0, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kaddq %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandd %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandq %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandnd %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandnq %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovd %k0, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - kmovd (%rax), %k2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - kmovd %k0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kmovd %eax, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovd %k0, %eax +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovq %k0, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - kmovq (%rax), %k2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - kmovq %k0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kmovq %rax, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovq %k0, %rax +# CHECK-NEXT: 1.00 - - - - - - - - - - - - knotd %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - knotq %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kord %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - korq %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kortestd %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kortestq %k0, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftld $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftlq $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftrd $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftrq $2, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ktestd %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ktestq %k0, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kunpckdq %k0, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kunpckwd %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxnord %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxnorq %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxord %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxorq %k0, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu8 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu8 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu8 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu8 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.20 0.20 - - 1.00 0.20 0.20 1.00 1.00 1.00 0.20 - - vmovdqu8 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu8 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu16 %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu16 (%rax), %zmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %zmm16, (%rax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu16 %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu16 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %zmm16, (%rax) {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vmovdqu16 %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vmovdqu16 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsb %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsw %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpabsw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpaddusw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpaddw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpaddw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpavgw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpblendmw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpblendmw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrb $0, %xmm16, %eax +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrb $0, %xmm16, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrw $0, %xmm16, %eax +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrw $0, %xmm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrb $0, %eax, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrb $0, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrw $0, %eax, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrw $0, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpermw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpermw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpermw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2w %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2w (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2w %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2w (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2w %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2w (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2w %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2w (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2w %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2w (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2w %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2w (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddubsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddubsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddubsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaddwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxub %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxub %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxub %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmaxuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminub %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminub %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminub %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpminuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovb2m %zmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovw2m %zmm0, %k0 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpmovm2b %k0, %zmm0 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpmovm2w %k0, %zmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovswb %zmm16, %ymm19 +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovswb %zmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovswb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovswb %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovuswb %zmm16, %ymm19 +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovuswb %zmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovuswb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovuswb %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovwb %zmm16, %ymm19 +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovwb %zmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpmovwb %zmm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 2.00 - 0.50 0.50 0.50 - - - vpmovwb %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %ymm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %ymm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhrsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhrsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhrsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhuw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhuw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhuw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmulhw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmullw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmullw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmullw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsadbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsadbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufhw $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufhw $0, (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufhw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufhw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshufhw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshufhw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshuflw $0, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshuflw $0, (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshuflw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshuflw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpshuflw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpshuflw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpslldq $1, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpslldq $1, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllw $0, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsllw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsllw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsllw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsllw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsravw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsravw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsravw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsraw $0, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsraw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsraw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsraw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsraw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsraw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsrldq $1, %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsrldq $1, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlw $0, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlw $0, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsrlw $0, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsrlw %xmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsrlw %xmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpsrlw %xmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubsw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubusw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpsubw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpsubw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %zmm0, %zmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %zmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %zmm0, %zmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %zmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhbw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhbw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhbw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhbw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpckhwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpckhwd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklbw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklbw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklbw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklbw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklbw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklbw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklwd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklwd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklwd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklwd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpunpcklwd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpunpcklwd (%rax), %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bwvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bwvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512bwvl.s @@ -0,0 +1,2948 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vdbpsadbw $0, %xmm16, %xmm17, %xmm19 +vdbpsadbw $0, (%rax), %xmm17, %xmm19 +vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {k1} +vdbpsadbw $0, (%rax), %xmm17, %xmm19 {k1} +vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {z}{k1} +vdbpsadbw $0, (%rax), %xmm17, %xmm19 {z}{k1} + +vdbpsadbw $0, %ymm16, %ymm17, %ymm19 +vdbpsadbw $0, (%rax), %ymm17, %ymm19 +vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {k1} +vdbpsadbw $0, (%rax), %ymm17, %ymm19 {k1} +vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vdbpsadbw $0, (%rax), %ymm17, %ymm19 {z}{k1} + +vmovdqu8 %xmm16, %xmm19 +vmovdqu8 (%rax), %xmm19 +vmovdqu8 %xmm16, (%rax) +vmovdqu8 %xmm16, %xmm19 {k1} +vmovdqu8 (%rax), %xmm19 {k1} +vmovdqu8 %xmm16, (%rax) {k1} +vmovdqu8 %xmm16, %xmm19 {z}{k1} +vmovdqu8 (%rax), %xmm19 {z}{k1} + +vmovdqu8 %ymm16, %ymm19 +vmovdqu8 (%rax), %ymm19 +vmovdqu8 %ymm16, (%rax) +vmovdqu8 %ymm16, %ymm19 {k1} +vmovdqu8 (%rax), %ymm19 {k1} +vmovdqu8 %ymm16, (%rax) {k1} +vmovdqu8 %ymm16, %ymm19 {z}{k1} +vmovdqu8 (%rax), %ymm19 {z}{k1} + +vmovdqu16 %xmm16, %xmm19 +vmovdqu16 (%rax), %xmm19 +vmovdqu16 %xmm16, (%rax) +vmovdqu16 %xmm16, %xmm19 {k1} +vmovdqu16 (%rax), %xmm19 {k1} +vmovdqu16 %xmm16, (%rax) {k1} +vmovdqu16 %xmm16, %xmm19 {z}{k1} +vmovdqu16 (%rax), %xmm19 {z}{k1} + +vmovdqu16 %ymm16, %ymm19 +vmovdqu16 (%rax), %ymm19 +vmovdqu16 %ymm16, (%rax) +vmovdqu16 %ymm16, %ymm19 {k1} +vmovdqu16 (%rax), %ymm19 {k1} +vmovdqu16 %ymm16, (%rax) {k1} +vmovdqu16 %ymm16, %ymm19 {z}{k1} +vmovdqu16 (%rax), %ymm19 {z}{k1} + +vpabsb %xmm16, %xmm19 +vpabsb (%rax), %xmm19 +vpabsb %xmm16, %xmm19 {k1} +vpabsb (%rax), %xmm19 {k1} +vpabsb %xmm16, %xmm19 {z}{k1} +vpabsb (%rax), %xmm19 {z}{k1} + +vpabsb %ymm16, %ymm19 +vpabsb (%rax), %ymm19 +vpabsb %ymm16, %ymm19 {k1} +vpabsb (%rax), %ymm19 {k1} +vpabsb %ymm16, %ymm19 {z}{k1} +vpabsb (%rax), %ymm19 {z}{k1} + +vpabsw %xmm16, %xmm19 +vpabsw (%rax), %xmm19 +vpabsw %xmm16, %xmm19 {k1} +vpabsw (%rax), %xmm19 {k1} +vpabsw %xmm16, %xmm19 {z}{k1} +vpabsw (%rax), %xmm19 {z}{k1} + +vpabsw %ymm16, %ymm19 +vpabsw (%rax), %ymm19 +vpabsw %ymm16, %ymm19 {k1} +vpabsw (%rax), %ymm19 {k1} +vpabsw %ymm16, %ymm19 {z}{k1} +vpabsw (%rax), %ymm19 {z}{k1} + +vpackssdw %xmm16, %xmm17, %xmm19 +vpackssdw (%rax), %xmm17, %xmm19 +vpackssdw %xmm16, %xmm17, %xmm19 {k1} +vpackssdw (%rax), %xmm17, %xmm19 {k1} +vpackssdw %xmm16, %xmm17, %xmm19 {z}{k1} +vpackssdw (%rax), %xmm17, %xmm19 {z}{k1} + +vpackssdw %ymm16, %ymm17, %ymm19 +vpackssdw (%rax), %ymm17, %ymm19 +vpackssdw %ymm16, %ymm17, %ymm19 {k1} +vpackssdw (%rax), %ymm17, %ymm19 {k1} +vpackssdw %ymm16, %ymm17, %ymm19 {z}{k1} +vpackssdw (%rax), %ymm17, %ymm19 {z}{k1} + +vpacksswb %xmm16, %xmm17, %xmm19 +vpacksswb (%rax), %xmm17, %xmm19 +vpacksswb %xmm16, %xmm17, %xmm19 {k1} +vpacksswb (%rax), %xmm17, %xmm19 {k1} +vpacksswb %xmm16, %xmm17, %xmm19 {z}{k1} +vpacksswb (%rax), %xmm17, %xmm19 {z}{k1} + +vpacksswb %ymm16, %ymm17, %ymm19 +vpacksswb (%rax), %ymm17, %ymm19 +vpacksswb %ymm16, %ymm17, %ymm19 {k1} +vpacksswb (%rax), %ymm17, %ymm19 {k1} +vpacksswb %ymm16, %ymm17, %ymm19 {z}{k1} +vpacksswb (%rax), %ymm17, %ymm19 {z}{k1} + +vpackusdw %xmm16, %xmm17, %xmm19 +vpackusdw (%rax), %xmm17, %xmm19 +vpackusdw %xmm16, %xmm17, %xmm19 {k1} +vpackusdw (%rax), %xmm17, %xmm19 {k1} +vpackusdw %xmm16, %xmm17, %xmm19 {z}{k1} +vpackusdw (%rax), %xmm17, %xmm19 {z}{k1} + +vpackusdw %ymm16, %ymm17, %ymm19 +vpackusdw (%rax), %ymm17, %ymm19 +vpackusdw %ymm16, %ymm17, %ymm19 {k1} +vpackusdw (%rax), %ymm17, %ymm19 {k1} +vpackusdw %ymm16, %ymm17, %ymm19 {z}{k1} +vpackusdw (%rax), %ymm17, %ymm19 {z}{k1} + +vpackuswb %xmm16, %xmm17, %xmm19 +vpackuswb (%rax), %xmm17, %xmm19 +vpackuswb %xmm16, %xmm17, %xmm19 {k1} +vpackuswb (%rax), %xmm17, %xmm19 {k1} +vpackuswb %xmm16, %xmm17, %xmm19 {z}{k1} +vpackuswb (%rax), %xmm17, %xmm19 {z}{k1} + +vpackuswb %ymm16, %ymm17, %ymm19 +vpackuswb (%rax), %ymm17, %ymm19 +vpackuswb %ymm16, %ymm17, %ymm19 {k1} +vpackuswb (%rax), %ymm17, %ymm19 {k1} +vpackuswb %ymm16, %ymm17, %ymm19 {z}{k1} +vpackuswb (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddb %xmm16, %xmm17, %xmm19 +vpaddb (%rax), %xmm17, %xmm19 +vpaddb %xmm16, %xmm17, %xmm19 {k1} +vpaddb (%rax), %xmm17, %xmm19 {k1} +vpaddb %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddb (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddb %ymm16, %ymm17, %ymm19 +vpaddb (%rax), %ymm17, %ymm19 +vpaddb %ymm16, %ymm17, %ymm19 {k1} +vpaddb (%rax), %ymm17, %ymm19 {k1} +vpaddb %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddb (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddsb %xmm16, %xmm17, %xmm19 +vpaddsb (%rax), %xmm17, %xmm19 +vpaddsb %xmm16, %xmm17, %xmm19 {k1} +vpaddsb (%rax), %xmm17, %xmm19 {k1} +vpaddsb %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddsb (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddsb %ymm16, %ymm17, %ymm19 +vpaddsb (%rax), %ymm17, %ymm19 +vpaddsb %ymm16, %ymm17, %ymm19 {k1} +vpaddsb (%rax), %ymm17, %ymm19 {k1} +vpaddsb %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddsb (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddsw %xmm16, %xmm17, %xmm19 +vpaddsw (%rax), %xmm17, %xmm19 +vpaddsw %xmm16, %xmm17, %xmm19 {k1} +vpaddsw (%rax), %xmm17, %xmm19 {k1} +vpaddsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddsw %ymm16, %ymm17, %ymm19 +vpaddsw (%rax), %ymm17, %ymm19 +vpaddsw %ymm16, %ymm17, %ymm19 {k1} +vpaddsw (%rax), %ymm17, %ymm19 {k1} +vpaddsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddusb %xmm16, %xmm17, %xmm19 +vpaddusb (%rax), %xmm17, %xmm19 +vpaddusb %xmm16, %xmm17, %xmm19 {k1} +vpaddusb (%rax), %xmm17, %xmm19 {k1} +vpaddusb %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddusb (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddusb %ymm16, %ymm17, %ymm19 +vpaddusb (%rax), %ymm17, %ymm19 +vpaddusb %ymm16, %ymm17, %ymm19 {k1} +vpaddusb (%rax), %ymm17, %ymm19 {k1} +vpaddusb %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddusb (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddusw %xmm16, %xmm17, %xmm19 +vpaddusw (%rax), %xmm17, %xmm19 +vpaddusw %xmm16, %xmm17, %xmm19 {k1} +vpaddusw (%rax), %xmm17, %xmm19 {k1} +vpaddusw %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddusw (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddusw %ymm16, %ymm17, %ymm19 +vpaddusw (%rax), %ymm17, %ymm19 +vpaddusw %ymm16, %ymm17, %ymm19 {k1} +vpaddusw (%rax), %ymm17, %ymm19 {k1} +vpaddusw %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddusw (%rax), %ymm17, %ymm19 {z}{k1} + +vpaddw %xmm16, %xmm17, %xmm19 +vpaddw (%rax), %xmm17, %xmm19 +vpaddw %xmm16, %xmm17, %xmm19 {k1} +vpaddw (%rax), %xmm17, %xmm19 {k1} +vpaddw %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddw (%rax), %xmm17, %xmm19 {z}{k1} + +vpaddw %ymm16, %ymm17, %ymm19 +vpaddw (%rax), %ymm17, %ymm19 +vpaddw %ymm16, %ymm17, %ymm19 {k1} +vpaddw (%rax), %ymm17, %ymm19 {k1} +vpaddw %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddw (%rax), %ymm17, %ymm19 {z}{k1} + +vpalignr $1, %xmm16, %xmm17, %xmm19 +vpalignr $1, (%rax), %xmm17, %xmm19 +vpalignr $1, %xmm16, %xmm17, %xmm19 {k1} +vpalignr $1, (%rax), %xmm17, %xmm19 {k1} +vpalignr $1, %xmm16, %xmm17, %xmm19 {z}{k1} +vpalignr $1, (%rax), %xmm17, %xmm19 {z}{k1} + +vpalignr $1, %ymm16, %ymm17, %ymm19 +vpalignr $1, (%rax), %ymm17, %ymm19 +vpalignr $1, %ymm16, %ymm17, %ymm19 {k1} +vpalignr $1, (%rax), %ymm17, %ymm19 {k1} +vpalignr $1, %ymm16, %ymm17, %ymm19 {z}{k1} +vpalignr $1, (%rax), %ymm17, %ymm19 {z}{k1} + +vpavgb %xmm16, %xmm17, %xmm19 +vpavgb (%rax), %xmm17, %xmm19 +vpavgb %xmm16, %xmm17, %xmm19 {k1} +vpavgb (%rax), %xmm17, %xmm19 {k1} +vpavgb %xmm16, %xmm17, %xmm19 {z}{k1} +vpavgb (%rax), %xmm17, %xmm19 {z}{k1} + +vpavgb %ymm16, %ymm17, %ymm19 +vpavgb (%rax), %ymm17, %ymm19 +vpavgb %ymm16, %ymm17, %ymm19 {k1} +vpavgb (%rax), %ymm17, %ymm19 {k1} +vpavgb %ymm16, %ymm17, %ymm19 {z}{k1} +vpavgb (%rax), %ymm17, %ymm19 {z}{k1} + +vpavgw %xmm16, %xmm17, %xmm19 +vpavgw (%rax), %xmm17, %xmm19 +vpavgw %xmm16, %xmm17, %xmm19 {k1} +vpavgw (%rax), %xmm17, %xmm19 {k1} +vpavgw %xmm16, %xmm17, %xmm19 {z}{k1} +vpavgw (%rax), %xmm17, %xmm19 {z}{k1} + +vpavgw %ymm16, %ymm17, %ymm19 +vpavgw (%rax), %ymm17, %ymm19 +vpavgw %ymm16, %ymm17, %ymm19 {k1} +vpavgw (%rax), %ymm17, %ymm19 {k1} +vpavgw %ymm16, %ymm17, %ymm19 {z}{k1} +vpavgw (%rax), %ymm17, %ymm19 {z}{k1} + +vpblendmb %xmm16, %xmm17, %xmm19 +vpblendmb (%rax), %xmm17, %xmm19 +vpblendmb %xmm16, %xmm17, %xmm19 {k1} +vpblendmb (%rax), %xmm17, %xmm19 {k1} +vpblendmb %xmm16, %xmm17, %xmm19 {z}{k1} +vpblendmb (%rax), %xmm17, %xmm19 {z}{k1} + +vpblendmb %ymm16, %ymm17, %ymm19 +vpblendmb (%rax), %ymm17, %ymm19 +vpblendmb %ymm16, %ymm17, %ymm19 {k1} +vpblendmb (%rax), %ymm17, %ymm19 {k1} +vpblendmb %ymm16, %ymm17, %ymm19 {z}{k1} +vpblendmb (%rax), %ymm17, %ymm19 {z}{k1} + +vpblendmw %xmm16, %xmm17, %xmm19 +vpblendmw (%rax), %xmm17, %xmm19 +vpblendmw %xmm16, %xmm17, %xmm19 {k1} +vpblendmw (%rax), %xmm17, %xmm19 {k1} +vpblendmw %xmm16, %xmm17, %xmm19 {z}{k1} +vpblendmw (%rax), %xmm17, %xmm19 {z}{k1} + +vpblendmw %ymm16, %ymm17, %ymm19 +vpblendmw (%rax), %ymm17, %ymm19 +vpblendmw %ymm16, %ymm17, %ymm19 {k1} +vpblendmw (%rax), %ymm17, %ymm19 {k1} +vpblendmw %ymm16, %ymm17, %ymm19 {z}{k1} +vpblendmw (%rax), %ymm17, %ymm19 {z}{k1} + +vpbroadcastb %xmm16, %xmm19 +vpbroadcastb (%rax), %xmm19 +vpbroadcastb %eax, %xmm19 +vpbroadcastb %xmm16, %xmm19 {k1} +vpbroadcastb (%rax), %xmm19 {k1} +vpbroadcastb %eax, %xmm19 {k1} +vpbroadcastb %xmm16, %xmm19 {z}{k1} +vpbroadcastb (%rax), %xmm19 {z}{k1} +vpbroadcastb %eax, %xmm19 {z}{k1} + +vpbroadcastb %xmm16, %ymm19 +vpbroadcastb (%rax), %ymm19 +vpbroadcastb %eax, %ymm19 +vpbroadcastb %xmm16, %ymm19 {k1} +vpbroadcastb (%rax), %ymm19 {k1} +vpbroadcastb %eax, %ymm19 {k1} +vpbroadcastb %xmm16, %ymm19 {z}{k1} +vpbroadcastb (%rax), %ymm19 {z}{k1} +vpbroadcastb %eax, %ymm19 {z}{k1} + +vpbroadcastw %xmm16, %xmm19 +vpbroadcastw (%rax), %xmm19 +vpbroadcastw %eax, %xmm19 +vpbroadcastw %xmm16, %xmm19 {k1} +vpbroadcastw (%rax), %xmm19 {k1} +vpbroadcastw %eax, %xmm19 {k1} +vpbroadcastw %xmm16, %xmm19 {z}{k1} +vpbroadcastw (%rax), %xmm19 {z}{k1} +vpbroadcastw %eax, %xmm19 {z}{k1} + +vpbroadcastw %xmm16, %ymm19 +vpbroadcastw (%rax), %ymm19 +vpbroadcastw %eax, %ymm19 +vpbroadcastw %xmm16, %ymm19 {k1} +vpbroadcastw (%rax), %ymm19 {k1} +vpbroadcastw %eax, %ymm19 {k1} +vpbroadcastw %xmm16, %ymm19 {z}{k1} +vpbroadcastw (%rax), %ymm19 {z}{k1} +vpbroadcastw %eax, %ymm19 {z}{k1} + +vpcmpb $0, %xmm0, %xmm1, %k2 +vpcmpb $0, (%rax), %xmm1, %k2 +vpcmpb $0, %xmm0, %xmm1, %k2 {k3} +vpcmpb $0, (%rax), %xmm1, %k2 {k3} + +vpcmpb $0, %ymm0, %ymm1, %k2 +vpcmpb $0, (%rax), %ymm1, %k2 +vpcmpb $0, %ymm0, %ymm1, %k2 {k3} +vpcmpb $0, (%rax), %ymm1, %k2 {k3} + +vpcmpeqb %xmm0, %xmm1, %k2 +vpcmpeqb (%rax), %xmm1, %k2 +vpcmpeqb %xmm0, %xmm1, %k2 {k3} +vpcmpeqb (%rax), %xmm1, %k2 {k3} + +vpcmpeqb %ymm0, %ymm1, %k2 +vpcmpeqb (%rax), %ymm1, %k2 +vpcmpeqb %ymm0, %ymm1, %k2 {k3} +vpcmpeqb (%rax), %ymm1, %k2 {k3} + +vpcmpeqw %xmm0, %xmm1, %k2 +vpcmpeqw (%rax), %xmm1, %k2 +vpcmpeqw %xmm0, %xmm1, %k2 {k3} +vpcmpeqw (%rax), %xmm1, %k2 {k3} + +vpcmpeqw %ymm0, %ymm1, %k2 +vpcmpeqw (%rax), %ymm1, %k2 +vpcmpeqw %ymm0, %ymm1, %k2 {k3} +vpcmpeqw (%rax), %ymm1, %k2 {k3} + +vpcmpgtb %xmm0, %xmm1, %k2 +vpcmpgtb (%rax), %xmm1, %k2 +vpcmpgtb %xmm0, %xmm1, %k2 {k3} +vpcmpgtb (%rax), %xmm1, %k2 {k3} + +vpcmpgtb %ymm0, %ymm1, %k2 +vpcmpgtb (%rax), %ymm1, %k2 +vpcmpgtb %ymm0, %ymm1, %k2 {k3} +vpcmpgtb (%rax), %ymm1, %k2 {k3} + +vpcmpgtw %xmm0, %xmm1, %k2 +vpcmpgtw (%rax), %xmm1, %k2 +vpcmpgtw %xmm0, %xmm1, %k2 {k3} +vpcmpgtw (%rax), %xmm1, %k2 {k3} + +vpcmpgtw %ymm0, %ymm1, %k2 +vpcmpgtw (%rax), %ymm1, %k2 +vpcmpgtw %ymm0, %ymm1, %k2 {k3} +vpcmpgtw (%rax), %ymm1, %k2 {k3} + +vpcmpub $0, %xmm0, %xmm1, %k2 +vpcmpub $0, (%rax), %xmm1, %k2 +vpcmpub $0, %xmm0, %xmm1, %k2 {k3} +vpcmpub $0, (%rax), %xmm1, %k2 {k3} + +vpcmpub $0, %ymm0, %ymm1, %k2 +vpcmpub $0, (%rax), %ymm1, %k2 +vpcmpub $0, %ymm0, %ymm1, %k2 {k3} +vpcmpub $0, (%rax), %ymm1, %k2 {k3} + +vpcmpuw $0, %xmm0, %xmm1, %k2 +vpcmpuw $0, (%rax), %xmm1, %k2 +vpcmpuw $0, %xmm0, %xmm1, %k2 {k3} +vpcmpuw $0, (%rax), %xmm1, %k2 {k3} + +vpcmpuw $0, %ymm0, %ymm1, %k2 +vpcmpuw $0, (%rax), %ymm1, %k2 +vpcmpuw $0, %ymm0, %ymm1, %k2 {k3} +vpcmpuw $0, (%rax), %ymm1, %k2 {k3} + +vpcmpw $0, %xmm0, %xmm1, %k2 +vpcmpw $0, (%rax), %xmm1, %k2 +vpcmpw $0, %xmm0, %xmm1, %k2 {k3} +vpcmpw $0, (%rax), %xmm1, %k2 {k3} + +vpcmpw $0, %ymm0, %ymm1, %k2 +vpcmpw $0, (%rax), %ymm1, %k2 +vpcmpw $0, %ymm0, %ymm1, %k2 {k3} +vpcmpw $0, (%rax), %ymm1, %k2 {k3} + +vpermw %xmm16, %xmm17, %xmm19 +vpermw (%rax), %xmm17, %xmm19 +vpermw %xmm16, %xmm17, %xmm19 {k1} +vpermw (%rax), %xmm17, %xmm19 {k1} +vpermw %xmm16, %xmm17, %xmm19 {z}{k1} +vpermw (%rax), %xmm17, %xmm19 {z}{k1} + +vpermw %ymm16, %ymm17, %ymm19 +vpermw (%rax), %ymm17, %ymm19 +vpermw %ymm16, %ymm17, %ymm19 {k1} +vpermw (%rax), %ymm17, %ymm19 {k1} +vpermw %ymm16, %ymm17, %ymm19 {z}{k1} +vpermw (%rax), %ymm17, %ymm19 {z}{k1} + +vpermi2w %xmm16, %xmm17, %xmm19 +vpermi2w (%rax), %xmm17, %xmm19 +vpermi2w %xmm16, %xmm17, %xmm19 {k1} +vpermi2w (%rax), %xmm17, %xmm19 {k1} +vpermi2w %xmm16, %xmm17, %xmm19 {z}{k1} +vpermi2w (%rax), %xmm17, %xmm19 {z}{k1} + +vpermi2w %ymm16, %ymm17, %ymm19 +vpermi2w (%rax), %ymm17, %ymm19 +vpermi2w %ymm16, %ymm17, %ymm19 {k1} +vpermi2w (%rax), %ymm17, %ymm19 {k1} +vpermi2w %ymm16, %ymm17, %ymm19 {z}{k1} +vpermi2w (%rax), %ymm17, %ymm19 {z}{k1} + +vpermt2w %xmm16, %xmm17, %xmm19 +vpermt2w (%rax), %xmm17, %xmm19 +vpermt2w %xmm16, %xmm17, %xmm19 {k1} +vpermt2w (%rax), %xmm17, %xmm19 {k1} +vpermt2w %xmm16, %xmm17, %xmm19 {z}{k1} +vpermt2w (%rax), %xmm17, %xmm19 {z}{k1} + +vpermt2w %ymm16, %ymm17, %ymm19 +vpermt2w (%rax), %ymm17, %ymm19 +vpermt2w %ymm16, %ymm17, %ymm19 {k1} +vpermt2w (%rax), %ymm17, %ymm19 {k1} +vpermt2w %ymm16, %ymm17, %ymm19 {z}{k1} +vpermt2w (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaddubsw %xmm16, %xmm17, %xmm19 +vpmaddubsw (%rax), %xmm17, %xmm19 +vpmaddubsw %xmm16, %xmm17, %xmm19 {k1} +vpmaddubsw (%rax), %xmm17, %xmm19 {k1} +vpmaddubsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaddubsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaddubsw %ymm16, %ymm17, %ymm19 +vpmaddubsw (%rax), %ymm17, %ymm19 +vpmaddubsw %ymm16, %ymm17, %ymm19 {k1} +vpmaddubsw (%rax), %ymm17, %ymm19 {k1} +vpmaddubsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaddubsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaddwd %xmm16, %xmm17, %xmm19 +vpmaddwd (%rax), %xmm17, %xmm19 +vpmaddwd %xmm16, %xmm17, %xmm19 {k1} +vpmaddwd (%rax), %xmm17, %xmm19 {k1} +vpmaddwd %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaddwd (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaddwd %ymm16, %ymm17, %ymm19 +vpmaddwd (%rax), %ymm17, %ymm19 +vpmaddwd %ymm16, %ymm17, %ymm19 {k1} +vpmaddwd (%rax), %ymm17, %ymm19 {k1} +vpmaddwd %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaddwd (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaxsb %xmm16, %xmm17, %xmm19 +vpmaxsb (%rax), %xmm17, %xmm19 +vpmaxsb %xmm16, %xmm17, %xmm19 {k1} +vpmaxsb (%rax), %xmm17, %xmm19 {k1} +vpmaxsb %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaxsb (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaxsb %ymm16, %ymm17, %ymm19 +vpmaxsb (%rax), %ymm17, %ymm19 +vpmaxsb %ymm16, %ymm17, %ymm19 {k1} +vpmaxsb (%rax), %ymm17, %ymm19 {k1} +vpmaxsb %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaxsb (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaxsw %xmm16, %xmm17, %xmm19 +vpmaxsw (%rax), %xmm17, %xmm19 +vpmaxsw %xmm16, %xmm17, %xmm19 {k1} +vpmaxsw (%rax), %xmm17, %xmm19 {k1} +vpmaxsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaxsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaxsw %ymm16, %ymm17, %ymm19 +vpmaxsw (%rax), %ymm17, %ymm19 +vpmaxsw %ymm16, %ymm17, %ymm19 {k1} +vpmaxsw (%rax), %ymm17, %ymm19 {k1} +vpmaxsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaxsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaxub %xmm16, %xmm17, %xmm19 +vpmaxub (%rax), %xmm17, %xmm19 +vpmaxub %xmm16, %xmm17, %xmm19 {k1} +vpmaxub (%rax), %xmm17, %xmm19 {k1} +vpmaxub %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaxub (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaxub %ymm16, %ymm17, %ymm19 +vpmaxub (%rax), %ymm17, %ymm19 +vpmaxub %ymm16, %ymm17, %ymm19 {k1} +vpmaxub (%rax), %ymm17, %ymm19 {k1} +vpmaxub %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaxub (%rax), %ymm17, %ymm19 {z}{k1} + +vpmaxuw %xmm16, %xmm17, %xmm19 +vpmaxuw (%rax), %xmm17, %xmm19 +vpmaxuw %xmm16, %xmm17, %xmm19 {k1} +vpmaxuw (%rax), %xmm17, %xmm19 {k1} +vpmaxuw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmaxuw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmaxuw %ymm16, %ymm17, %ymm19 +vpmaxuw (%rax), %ymm17, %ymm19 +vpmaxuw %ymm16, %ymm17, %ymm19 {k1} +vpmaxuw (%rax), %ymm17, %ymm19 {k1} +vpmaxuw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmaxuw (%rax), %ymm17, %ymm19 {z}{k1} + +vpminsb %xmm16, %xmm17, %xmm19 +vpminsb (%rax), %xmm17, %xmm19 +vpminsb %xmm16, %xmm17, %xmm19 {k1} +vpminsb (%rax), %xmm17, %xmm19 {k1} +vpminsb %xmm16, %xmm17, %xmm19 {z}{k1} +vpminsb (%rax), %xmm17, %xmm19 {z}{k1} + +vpminsb %ymm16, %ymm17, %ymm19 +vpminsb (%rax), %ymm17, %ymm19 +vpminsb %ymm16, %ymm17, %ymm19 {k1} +vpminsb (%rax), %ymm17, %ymm19 {k1} +vpminsb %ymm16, %ymm17, %ymm19 {z}{k1} +vpminsb (%rax), %ymm17, %ymm19 {z}{k1} + +vpminsw %xmm16, %xmm17, %xmm19 +vpminsw (%rax), %xmm17, %xmm19 +vpminsw %xmm16, %xmm17, %xmm19 {k1} +vpminsw (%rax), %xmm17, %xmm19 {k1} +vpminsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpminsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpminsw %ymm16, %ymm17, %ymm19 +vpminsw (%rax), %ymm17, %ymm19 +vpminsw %ymm16, %ymm17, %ymm19 {k1} +vpminsw (%rax), %ymm17, %ymm19 {k1} +vpminsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpminsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpminub %xmm16, %xmm17, %xmm19 +vpminub (%rax), %xmm17, %xmm19 +vpminub %xmm16, %xmm17, %xmm19 {k1} +vpminub (%rax), %xmm17, %xmm19 {k1} +vpminub %xmm16, %xmm17, %xmm19 {z}{k1} +vpminub (%rax), %xmm17, %xmm19 {z}{k1} + +vpminub %ymm16, %ymm17, %ymm19 +vpminub (%rax), %ymm17, %ymm19 +vpminub %ymm16, %ymm17, %ymm19 {k1} +vpminub (%rax), %ymm17, %ymm19 {k1} +vpminub %ymm16, %ymm17, %ymm19 {z}{k1} +vpminub (%rax), %ymm17, %ymm19 {z}{k1} + +vpminuw %xmm16, %xmm17, %xmm19 +vpminuw (%rax), %xmm17, %xmm19 +vpminuw %xmm16, %xmm17, %xmm19 {k1} +vpminuw (%rax), %xmm17, %xmm19 {k1} +vpminuw %xmm16, %xmm17, %xmm19 {z}{k1} +vpminuw (%rax), %xmm17, %xmm19 {z}{k1} + +vpminuw %ymm16, %ymm17, %ymm19 +vpminuw (%rax), %ymm17, %ymm19 +vpminuw %ymm16, %ymm17, %ymm19 {k1} +vpminuw (%rax), %ymm17, %ymm19 {k1} +vpminuw %ymm16, %ymm17, %ymm19 {z}{k1} +vpminuw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmovb2m %xmm0, %k0 +vpmovw2m %xmm0, %k0 + +vpmovb2m %ymm0, %k0 +vpmovw2m %ymm0, %k0 + +vpmovm2b %k0, %xmm0 +vpmovm2w %k0, %xmm0 + +vpmovm2b %k0, %ymm0 +vpmovm2w %k0, %ymm0 + +vpmovsxbw %xmm16, %xmm19 +vpmovsxbw (%rax), %xmm19 +vpmovsxbw %xmm16, %xmm19 {k1} +vpmovsxbw (%rax), %xmm19 {k1} +vpmovsxbw %xmm16, %xmm19 {z}{k1} +vpmovsxbw (%rax), %xmm19 {z}{k1} + +vpmovsxbw %xmm16, %ymm19 +vpmovsxbw (%rax), %ymm19 +vpmovsxbw %xmm16, %ymm19 {k1} +vpmovsxbw (%rax), %ymm19 {k1} +vpmovsxbw %xmm16, %ymm19 {z}{k1} +vpmovsxbw (%rax), %ymm19 {z}{k1} + +vpmovswb %xmm16, %xmm19 +vpmovswb %xmm16, (%rax) +vpmovswb %xmm16, %xmm19 {k1} +vpmovswb %xmm16, (%rax) {k1} + +vpmovswb %ymm16, %xmm19 +vpmovswb %ymm16, (%rax) +vpmovswb %ymm16, %xmm19 {k1} +vpmovswb %ymm16, (%rax) {k1} + +vpmovuswb %xmm16, %xmm19 +vpmovuswb %xmm16, (%rax) +vpmovuswb %xmm16, %xmm19 {k1} +vpmovuswb %xmm16, (%rax) {k1} + +vpmovuswb %ymm16, %xmm19 +vpmovuswb %ymm16, (%rax) +vpmovuswb %ymm16, %xmm19 {k1} +vpmovuswb %ymm16, (%rax) {k1} + +vpmovwb %xmm16, %xmm19 +vpmovwb %xmm16, (%rax) +vpmovwb %xmm16, %xmm19 {k1} +vpmovwb %xmm16, (%rax) {k1} + +vpmovwb %ymm16, %xmm19 +vpmovwb %ymm16, (%rax) +vpmovwb %ymm16, %xmm19 {k1} +vpmovwb %ymm16, (%rax) {k1} + +vpmovzxbw %xmm16, %xmm19 +vpmovzxbw (%rax), %xmm19 +vpmovzxbw %xmm16, %xmm19 {k1} +vpmovzxbw (%rax), %xmm19 {k1} +vpmovzxbw %xmm16, %xmm19 {z}{k1} +vpmovzxbw (%rax), %xmm19 {z}{k1} + +vpmovzxbw %xmm16, %ymm19 +vpmovzxbw (%rax), %ymm19 +vpmovzxbw %xmm16, %ymm19 {k1} +vpmovzxbw (%rax), %ymm19 {k1} +vpmovzxbw %xmm16, %ymm19 {z}{k1} +vpmovzxbw (%rax), %ymm19 {z}{k1} + +vpmulhrsw %xmm16, %xmm17, %xmm19 +vpmulhrsw (%rax), %xmm17, %xmm19 +vpmulhrsw %xmm16, %xmm17, %xmm19 {k1} +vpmulhrsw (%rax), %xmm17, %xmm19 {k1} +vpmulhrsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmulhrsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmulhrsw %ymm16, %ymm17, %ymm19 +vpmulhrsw (%rax), %ymm17, %ymm19 +vpmulhrsw %ymm16, %ymm17, %ymm19 {k1} +vpmulhrsw (%rax), %ymm17, %ymm19 {k1} +vpmulhrsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmulhrsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmulhuw %xmm16, %xmm17, %xmm19 +vpmulhuw (%rax), %xmm17, %xmm19 +vpmulhuw %xmm16, %xmm17, %xmm19 {k1} +vpmulhuw (%rax), %xmm17, %xmm19 {k1} +vpmulhuw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmulhuw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmulhuw %ymm16, %ymm17, %ymm19 +vpmulhuw (%rax), %ymm17, %ymm19 +vpmulhuw %ymm16, %ymm17, %ymm19 {k1} +vpmulhuw (%rax), %ymm17, %ymm19 {k1} +vpmulhuw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmulhuw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmulhw %xmm16, %xmm17, %xmm19 +vpmulhw (%rax), %xmm17, %xmm19 +vpmulhw %xmm16, %xmm17, %xmm19 {k1} +vpmulhw (%rax), %xmm17, %xmm19 {k1} +vpmulhw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmulhw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmulhw %ymm16, %ymm17, %ymm19 +vpmulhw (%rax), %ymm17, %ymm19 +vpmulhw %ymm16, %ymm17, %ymm19 {k1} +vpmulhw (%rax), %ymm17, %ymm19 {k1} +vpmulhw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmulhw (%rax), %ymm17, %ymm19 {z}{k1} + +vpmullw %xmm16, %xmm17, %xmm19 +vpmullw (%rax), %xmm17, %xmm19 +vpmullw %xmm16, %xmm17, %xmm19 {k1} +vpmullw (%rax), %xmm17, %xmm19 {k1} +vpmullw %xmm16, %xmm17, %xmm19 {z}{k1} +vpmullw (%rax), %xmm17, %xmm19 {z}{k1} + +vpmullw %ymm16, %ymm17, %ymm19 +vpmullw (%rax), %ymm17, %ymm19 +vpmullw %ymm16, %ymm17, %ymm19 {k1} +vpmullw (%rax), %ymm17, %ymm19 {k1} +vpmullw %ymm16, %ymm17, %ymm19 {z}{k1} +vpmullw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsadbw %xmm16, %xmm17, %xmm19 +vpsadbw (%rax), %xmm17, %xmm19 + +vpsadbw %ymm16, %ymm17, %ymm19 +vpsadbw (%rax), %ymm17, %ymm19 + +vpshufb %xmm16, %xmm17, %xmm19 +vpshufb (%rax), %xmm17, %xmm19 +vpshufb %xmm16, %xmm17, %xmm19 {k1} +vpshufb (%rax), %xmm17, %xmm19 {k1} +vpshufb %xmm16, %xmm17, %xmm19 {z}{k1} +vpshufb (%rax), %xmm17, %xmm19 {z}{k1} + +vpshufb %ymm16, %ymm17, %ymm19 +vpshufb (%rax), %ymm17, %ymm19 +vpshufb %ymm16, %ymm17, %ymm19 {k1} +vpshufb (%rax), %ymm17, %ymm19 {k1} +vpshufb %ymm16, %ymm17, %ymm19 {z}{k1} +vpshufb (%rax), %ymm17, %ymm19 {z}{k1} + +vpshufhw $0, %xmm16, %xmm19 +vpshufhw $0, (%rax), %xmm19 +vpshufhw $0, %xmm16, %xmm19 {k1} +vpshufhw $0, (%rax), %xmm19 {k1} +vpshufhw $0, %xmm16, %xmm19 {z}{k1} +vpshufhw $0, (%rax), %xmm19 {z}{k1} + +vpshufhw $0, %ymm16, %ymm19 +vpshufhw $0, (%rax), %ymm19 +vpshufhw $0, %ymm16, %ymm19 {k1} +vpshufhw $0, (%rax), %ymm19 {k1} +vpshufhw $0, %ymm16, %ymm19 {z}{k1} +vpshufhw $0, (%rax), %ymm19 {z}{k1} + +vpshuflw $0, %xmm16, %xmm19 +vpshuflw $0, (%rax), %xmm19 +vpshuflw $0, %xmm16, %xmm19 {k1} +vpshuflw $0, (%rax), %xmm19 {k1} +vpshuflw $0, %xmm16, %xmm19 {z}{k1} +vpshuflw $0, (%rax), %xmm19 {z}{k1} + +vpshuflw $0, %ymm16, %ymm19 +vpshuflw $0, (%rax), %ymm19 +vpshuflw $0, %ymm16, %ymm19 {k1} +vpshuflw $0, (%rax), %ymm19 {k1} +vpshuflw $0, %ymm16, %ymm19 {z}{k1} +vpshuflw $0, (%rax), %ymm19 {z}{k1} + +vpslldq $1, %xmm16, %xmm19 +vpslldq $1, (%rax), %xmm19 + +vpslldq $1, %ymm16, %ymm19 +vpslldq $1, (%rax), %ymm19 + +vpsllvw %xmm16, %xmm17, %xmm19 +vpsllvw (%rax), %xmm17, %xmm19 +vpsllvw %xmm16, %xmm17, %xmm19 {k1} +vpsllvw (%rax), %xmm17, %xmm19 {k1} +vpsllvw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsllvw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsllvw %ymm16, %ymm17, %ymm19 +vpsllvw (%rax), %ymm17, %ymm19 +vpsllvw %ymm16, %ymm17, %ymm19 {k1} +vpsllvw (%rax), %ymm17, %ymm19 {k1} +vpsllvw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsllvw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsllw $0, %xmm16, %xmm19 +vpsllw $0, (%rax), %xmm19 +vpsllw $0, %xmm16, %xmm19 {k1} +vpsllw $0, (%rax), %xmm19 {k1} +vpsllw $0, %xmm16, %xmm19 {z}{k1} +vpsllw $0, (%rax), %xmm19 {z}{k1} + +vpsllw $0, %ymm16, %ymm19 +vpsllw $0, (%rax), %ymm19 +vpsllw $0, %ymm16, %ymm19 {k1} +vpsllw $0, (%rax), %ymm19 {k1} +vpsllw $0, %ymm16, %ymm19 {z}{k1} +vpsllw $0, (%rax), %ymm19 {z}{k1} + +vpsllw %xmm16, %xmm17, %xmm19 +vpsllw (%rax), %xmm17, %xmm19 +vpsllw %xmm16, %xmm17, %xmm19 {k1} +vpsllw (%rax), %xmm17, %xmm19 {k1} +vpsllw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsllw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsllw %xmm16, %ymm17, %ymm19 +vpsllw (%rax), %ymm17, %ymm19 +vpsllw %xmm16, %ymm17, %ymm19 {k1} +vpsllw (%rax), %ymm17, %ymm19 {k1} +vpsllw %xmm16, %ymm17, %ymm19 {z}{k1} +vpsllw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsravw %xmm16, %xmm17, %xmm19 +vpsravw (%rax), %xmm17, %xmm19 +vpsravw %xmm16, %xmm17, %xmm19 {k1} +vpsravw (%rax), %xmm17, %xmm19 {k1} +vpsravw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsravw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsravw %ymm16, %ymm17, %ymm19 +vpsravw (%rax), %ymm17, %ymm19 +vpsravw %ymm16, %ymm17, %ymm19 {k1} +vpsravw (%rax), %ymm17, %ymm19 {k1} +vpsravw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsravw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsraw $0, %xmm16, %xmm19 +vpsraw $0, (%rax), %xmm19 +vpsraw $0, %xmm16, %xmm19 {k1} +vpsraw $0, (%rax), %xmm19 {k1} +vpsraw $0, %xmm16, %xmm19 {z}{k1} +vpsraw $0, (%rax), %xmm19 {z}{k1} + +vpsraw $0, %ymm16, %ymm19 +vpsraw $0, (%rax), %ymm19 +vpsraw $0, %ymm16, %ymm19 {k1} +vpsraw $0, (%rax), %ymm19 {k1} +vpsraw $0, %ymm16, %ymm19 {z}{k1} +vpsraw $0, (%rax), %ymm19 {z}{k1} + +vpsraw %xmm16, %xmm17, %xmm19 +vpsraw (%rax), %xmm17, %xmm19 +vpsraw %xmm16, %xmm17, %xmm19 {k1} +vpsraw (%rax), %xmm17, %xmm19 {k1} +vpsraw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsraw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsraw %xmm16, %ymm17, %ymm19 +vpsraw (%rax), %ymm17, %ymm19 +vpsraw %xmm16, %ymm17, %ymm19 {k1} +vpsraw (%rax), %ymm17, %ymm19 {k1} +vpsraw %xmm16, %ymm17, %ymm19 {z}{k1} +vpsraw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsrldq $1, %xmm16, %xmm19 +vpsrldq $1, (%rax), %xmm19 + +vpsrldq $1, %ymm16, %ymm19 +vpsrldq $1, (%rax), %ymm19 + +vpsrlvw %xmm16, %xmm17, %xmm19 +vpsrlvw (%rax), %xmm17, %xmm19 +vpsrlvw %xmm16, %xmm17, %xmm19 {k1} +vpsrlvw (%rax), %xmm17, %xmm19 {k1} +vpsrlvw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsrlvw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsrlvw %ymm16, %ymm17, %ymm19 +vpsrlvw (%rax), %ymm17, %ymm19 +vpsrlvw %ymm16, %ymm17, %ymm19 {k1} +vpsrlvw (%rax), %ymm17, %ymm19 {k1} +vpsrlvw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsrlvw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsrlw $0, %xmm16, %xmm19 +vpsrlw $0, (%rax), %xmm19 +vpsrlw $0, %xmm16, %xmm19 {k1} +vpsrlw $0, (%rax), %xmm19 {k1} +vpsrlw $0, %xmm16, %xmm19 {z}{k1} +vpsrlw $0, (%rax), %xmm19 {z}{k1} + +vpsrlw $0, %ymm16, %ymm19 +vpsrlw $0, (%rax), %ymm19 +vpsrlw $0, %ymm16, %ymm19 {k1} +vpsrlw $0, (%rax), %ymm19 {k1} +vpsrlw $0, %ymm16, %ymm19 {z}{k1} +vpsrlw $0, (%rax), %ymm19 {z}{k1} + +vpsrlw %xmm16, %xmm17, %xmm19 +vpsrlw (%rax), %xmm17, %xmm19 +vpsrlw %xmm16, %xmm17, %xmm19 {k1} +vpsrlw (%rax), %xmm17, %xmm19 {k1} +vpsrlw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsrlw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsrlw %xmm16, %ymm17, %ymm19 +vpsrlw (%rax), %ymm17, %ymm19 +vpsrlw %xmm16, %ymm17, %ymm19 {k1} +vpsrlw (%rax), %ymm17, %ymm19 {k1} +vpsrlw %xmm16, %ymm17, %ymm19 {z}{k1} +vpsrlw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubb %xmm16, %xmm17, %xmm19 +vpsubb (%rax), %xmm17, %xmm19 +vpsubb %xmm16, %xmm17, %xmm19 {k1} +vpsubb (%rax), %xmm17, %xmm19 {k1} +vpsubb %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubb (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubb %ymm16, %ymm17, %ymm19 +vpsubb (%rax), %ymm17, %ymm19 +vpsubb %ymm16, %ymm17, %ymm19 {k1} +vpsubb (%rax), %ymm17, %ymm19 {k1} +vpsubb %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubb (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubsb %xmm16, %xmm17, %xmm19 +vpsubsb (%rax), %xmm17, %xmm19 +vpsubsb %xmm16, %xmm17, %xmm19 {k1} +vpsubsb (%rax), %xmm17, %xmm19 {k1} +vpsubsb %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubsb (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubsb %ymm16, %ymm17, %ymm19 +vpsubsb (%rax), %ymm17, %ymm19 +vpsubsb %ymm16, %ymm17, %ymm19 {k1} +vpsubsb (%rax), %ymm17, %ymm19 {k1} +vpsubsb %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubsb (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubsw %xmm16, %xmm17, %xmm19 +vpsubsw (%rax), %xmm17, %xmm19 +vpsubsw %xmm16, %xmm17, %xmm19 {k1} +vpsubsw (%rax), %xmm17, %xmm19 {k1} +vpsubsw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubsw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubsw %ymm16, %ymm17, %ymm19 +vpsubsw (%rax), %ymm17, %ymm19 +vpsubsw %ymm16, %ymm17, %ymm19 {k1} +vpsubsw (%rax), %ymm17, %ymm19 {k1} +vpsubsw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubsw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubusb %xmm16, %xmm17, %xmm19 +vpsubusb (%rax), %xmm17, %xmm19 +vpsubusb %xmm16, %xmm17, %xmm19 {k1} +vpsubusb (%rax), %xmm17, %xmm19 {k1} +vpsubusb %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubusb (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubusb %ymm16, %ymm17, %ymm19 +vpsubusb (%rax), %ymm17, %ymm19 +vpsubusb %ymm16, %ymm17, %ymm19 {k1} +vpsubusb (%rax), %ymm17, %ymm19 {k1} +vpsubusb %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubusb (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubusw %xmm16, %xmm17, %xmm19 +vpsubusw (%rax), %xmm17, %xmm19 +vpsubusw %xmm16, %xmm17, %xmm19 {k1} +vpsubusw (%rax), %xmm17, %xmm19 {k1} +vpsubusw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubusw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubusw %ymm16, %ymm17, %ymm19 +vpsubusw (%rax), %ymm17, %ymm19 +vpsubusw %ymm16, %ymm17, %ymm19 {k1} +vpsubusw (%rax), %ymm17, %ymm19 {k1} +vpsubusw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubusw (%rax), %ymm17, %ymm19 {z}{k1} + +vpsubw %xmm16, %xmm17, %xmm19 +vpsubw (%rax), %xmm17, %xmm19 +vpsubw %xmm16, %xmm17, %xmm19 {k1} +vpsubw (%rax), %xmm17, %xmm19 {k1} +vpsubw %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubw (%rax), %xmm17, %xmm19 {z}{k1} + +vpsubw %ymm16, %ymm17, %ymm19 +vpsubw (%rax), %ymm17, %ymm19 +vpsubw %ymm16, %ymm17, %ymm19 {k1} +vpsubw (%rax), %ymm17, %ymm19 {k1} +vpsubw %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubw (%rax), %ymm17, %ymm19 {z}{k1} + +vptestmb %xmm0, %xmm1, %k2 +vptestmb (%rax), %xmm1, %k2 +vptestmb %xmm0, %xmm1, %k2 {k3} +vptestmb (%rax), %xmm1, %k2 {k3} + +vptestmb %ymm0, %ymm1, %k2 +vptestmb (%rax), %ymm1, %k2 +vptestmb %ymm0, %ymm1, %k2 {k3} +vptestmb (%rax), %ymm1, %k2 {k3} + +vptestmw %xmm0, %xmm1, %k2 +vptestmw (%rax), %xmm1, %k2 +vptestmw %xmm0, %xmm1, %k2 {k3} +vptestmw (%rax), %xmm1, %k2 {k3} + +vptestmw %ymm0, %ymm1, %k2 +vptestmw (%rax), %ymm1, %k2 +vptestmw %ymm0, %ymm1, %k2 {k3} +vptestmw (%rax), %ymm1, %k2 {k3} + +vptestnmb %xmm0, %xmm1, %k2 +vptestnmb (%rax), %xmm1, %k2 +vptestnmb %xmm0, %xmm1, %k2 {k3} +vptestnmb (%rax), %xmm1, %k2 {k3} + +vptestnmb %ymm0, %ymm1, %k2 +vptestnmb (%rax), %ymm1, %k2 +vptestnmb %ymm0, %ymm1, %k2 {k3} +vptestnmb (%rax), %ymm1, %k2 {k3} + +vptestnmw %xmm0, %xmm1, %k2 +vptestnmw (%rax), %xmm1, %k2 +vptestnmw %xmm0, %xmm1, %k2 {k3} +vptestnmw (%rax), %xmm1, %k2 {k3} + +vptestnmw %ymm0, %ymm1, %k2 +vptestnmw (%rax), %ymm1, %k2 +vptestnmw %ymm0, %ymm1, %k2 {k3} +vptestnmw (%rax), %ymm1, %k2 {k3} + +vpunpckhbw %xmm16, %xmm17, %xmm19 +vpunpckhbw (%rax), %xmm17, %xmm19 +vpunpckhbw %xmm16, %xmm17, %xmm19 {k1} +vpunpckhbw (%rax), %xmm17, %xmm19 {k1} +vpunpckhbw %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpckhbw (%rax), %xmm17, %xmm19 {z}{k1} + +vpunpckhbw %ymm16, %ymm17, %ymm19 +vpunpckhbw (%rax), %ymm17, %ymm19 +vpunpckhbw %ymm16, %ymm17, %ymm19 {k1} +vpunpckhbw (%rax), %ymm17, %ymm19 {k1} +vpunpckhbw %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpckhbw (%rax), %ymm17, %ymm19 {z}{k1} + +vpunpckhwd %xmm16, %xmm17, %xmm19 +vpunpckhwd (%rax), %xmm17, %xmm19 +vpunpckhwd %xmm16, %xmm17, %xmm19 {k1} +vpunpckhwd (%rax), %xmm17, %xmm19 {k1} +vpunpckhwd %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpckhwd (%rax), %xmm17, %xmm19 {z}{k1} + +vpunpckhwd %ymm16, %ymm17, %ymm19 +vpunpckhwd (%rax), %ymm17, %ymm19 +vpunpckhwd %ymm16, %ymm17, %ymm19 {k1} +vpunpckhwd (%rax), %ymm17, %ymm19 {k1} +vpunpckhwd %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpckhwd (%rax), %ymm17, %ymm19 {z}{k1} + +vpunpcklbw %xmm16, %xmm17, %xmm19 +vpunpcklbw (%rax), %xmm17, %xmm19 +vpunpcklbw %xmm16, %xmm17, %xmm19 {k1} +vpunpcklbw (%rax), %xmm17, %xmm19 {k1} +vpunpcklbw %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpcklbw (%rax), %xmm17, %xmm19 {z}{k1} + +vpunpcklbw %ymm16, %ymm17, %ymm19 +vpunpcklbw (%rax), %ymm17, %ymm19 +vpunpcklbw %ymm16, %ymm17, %ymm19 {k1} +vpunpcklbw (%rax), %ymm17, %ymm19 {k1} +vpunpcklbw %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpcklbw (%rax), %ymm17, %ymm19 {z}{k1} + +vpunpcklwd %xmm16, %xmm17, %xmm19 +vpunpcklwd (%rax), %xmm17, %xmm19 +vpunpcklwd %xmm16, %xmm17, %xmm19 {k1} +vpunpcklwd (%rax), %xmm17, %xmm19 {k1} +vpunpcklwd %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpcklwd (%rax), %xmm17, %xmm19 {z}{k1} + +vpunpcklwd %ymm16, %ymm17, %ymm19 +vpunpcklwd (%rax), %ymm17, %ymm19 +vpunpcklwd %ymm16, %ymm17, %ymm19 {k1} +vpunpcklwd (%rax), %ymm17, %ymm19 {k1} +vpunpcklwd %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpcklwd (%rax), %ymm17, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vdbpsadbw $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vdbpsadbw $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vdbpsadbw $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vdbpsadbw $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vdbpsadbw $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu8 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqu8 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu8 %xmm16, (%rax) +# CHECK-NEXT: 1 3 0.33 vmovdqu8 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vmovdqu8 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu8 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.33 vmovdqu8 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vmovdqu8 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu8 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu8 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu8 %ymm16, (%rax) +# CHECK-NEXT: 1 3 0.33 vmovdqu8 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vmovdqu8 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu8 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.33 vmovdqu8 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vmovdqu8 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu16 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqu16 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %xmm16, (%rax) +# CHECK-NEXT: 1 3 0.33 vmovdqu16 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vmovdqu16 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.33 vmovdqu16 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vmovdqu16 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu16 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu16 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %ymm16, (%rax) +# CHECK-NEXT: 1 3 0.33 vmovdqu16 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vmovdqu16 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu16 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 0.33 vmovdqu16 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vmovdqu16 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpabsb %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpabsb (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpabsb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpabsb (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpabsb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpabsb (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpabsb %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpabsb (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpabsb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpabsb (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpabsb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpabsb (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpabsw %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpabsw (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpabsw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpabsw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpabsw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpabsw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpabsw %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpabsw (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpabsw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpabsw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpabsw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpabsw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackssdw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpackssdw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpackssdw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackssdw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackssdw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpackssdw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpackssdw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackssdw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackssdw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpacksswb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpacksswb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpacksswb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpacksswb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpacksswb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpacksswb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpacksswb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpacksswb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpacksswb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackusdw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpackusdw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpackusdw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackusdw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackusdw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpackusdw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpackusdw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackusdw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackusdw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackuswb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpackuswb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpackuswb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackuswb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpackuswb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpackuswb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpackuswb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpackuswb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpackuswb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpaddb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpaddb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpaddb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpaddb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpaddb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpaddb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpaddb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpaddb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpaddsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpaddsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpaddsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpaddsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpaddsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpaddsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpaddsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpaddsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddusb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpaddusb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpaddusb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddusb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddusb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddusb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddusb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpaddusb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpaddusb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddusb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddusb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddusb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddusw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpaddusw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpaddusw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddusw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddusw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddusw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpaddusw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpaddusw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpaddusw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpaddusw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpaddusw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpaddusw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpaddw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpaddw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpaddw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpaddw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpaddw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpaddw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpaddw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpaddw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpalignr $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpalignr $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpalignr $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpalignr $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpalignr $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpalignr $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpavgb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpavgb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpavgb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpavgb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpavgb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpavgb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpavgb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpavgb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpavgb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpavgb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpavgb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpavgb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpavgw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpavgw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpavgw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpavgw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpavgw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpavgw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpavgw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpavgw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpavgw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpavgw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpavgw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpavgw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpblendmb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpblendmb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpblendmb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpblendmb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpblendmb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpblendmb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpblendmb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpblendmb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpblendmb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpblendmb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpblendmb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpblendmb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpblendmw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpblendmw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpblendmw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpblendmw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpblendmw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpblendmw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpblendmw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpblendmw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpblendmw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpblendmw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpblendmw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpblendmw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpbroadcastb %xmm16, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpbroadcastb (%rax), %xmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %xmm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %xmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastb %xmm16, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastb (%rax), %ymm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastb (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastb %eax, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpbroadcastw %xmm16, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpbroadcastw (%rax), %xmm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %xmm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %xmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastw %xmm16, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpbroadcastw (%rax), %ymm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpbroadcastw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpbroadcastw %eax, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 4 1.00 vpermw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 3 10 1.00 * vpermw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 6 1.00 vpermw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpermw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpermw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 3 11 1.00 * vpermw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 6 1.00 vpermw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpermw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vpermw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermi2w %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 4 14 2.00 * vpermi2w (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 9 2.00 vpermi2w %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 4 16 2.00 * vpermi2w (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermi2w %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 16 2.00 * vpermi2w (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermi2w %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 4 15 2.00 * vpermi2w (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 9 2.00 vpermi2w %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 4 17 2.00 * vpermi2w (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermi2w %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 4 17 2.00 * vpermi2w (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermt2w %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 4 13 2.00 * vpermt2w (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 9 2.00 vpermt2w %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 4 15 2.00 * vpermt2w (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermt2w %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 15 2.00 * vpermt2w (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 7 2.00 vpermt2w %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 4 14 2.00 * vpermt2w (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 9 2.00 vpermt2w %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 4 16 2.00 * vpermt2w (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 9 2.00 vpermt2w %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 4 16 2.00 * vpermt2w (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmaddubsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmaddubsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 7 0.50 vpmaddubsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmaddubsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmaddubsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmaddubsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmaddubsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmaddubsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 7 0.50 vpmaddubsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmaddubsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmaddubsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmaddubsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmaddwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vpmaddwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpmaddwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmaddwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vpmaddwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpmaddwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpmaddwd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmaxsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmaxsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpmaxsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpmaxsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmaxsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmaxsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpmaxsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpmaxsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxub %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmaxub (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmaxub %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxub (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxub %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxub (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxub %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpmaxub (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpmaxub %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxub (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxub %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxub (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmaxuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmaxuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmaxuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpmaxuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpmaxuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmaxuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmaxuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmaxuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpminsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpminsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpminsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpminsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpminsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpminsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpminsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpminsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminub %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpminub (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpminub %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminub (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminub %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminub (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminub %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpminub (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpminub %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminub (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminub %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminub (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpminuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpminuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpminuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpminuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpminuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpminuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpminuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpminuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovb2m %xmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovw2m %xmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovb2m %ymm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovw2m %ymm0, %k0 +# CHECK-NEXT: 1 3 0.33 vpmovm2b %k0, %xmm0 +# CHECK-NEXT: 1 3 0.33 vpmovm2w %k0, %xmm0 +# CHECK-NEXT: 1 3 0.33 vpmovm2b %k0, %ymm0 +# CHECK-NEXT: 1 3 0.33 vpmovm2w %k0, %ymm0 +# CHECK-NEXT: 1 1 0.50 vpmovsxbw %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbw (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmovsxbw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmovsxbw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmovsxbw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmovsxbw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxbw %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbw (%rax), %ymm19 +# CHECK-NEXT: 1 5 1.00 vpmovsxbw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmovsxbw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmovsxbw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmovsxbw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 2 1.00 vpmovswb %xmm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovswb %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpmovswb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 4 13 1.00 * vpmovswb %xmm16, (%rax) {%k1} +# CHECK-NEXT: 2 4 1.00 vpmovswb %ymm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovswb %ymm16, (%rax) +# CHECK-NEXT: 2 6 1.00 vpmovswb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 4 15 1.00 * vpmovswb %ymm16, (%rax) {%k1} +# CHECK-NEXT: 2 2 1.00 vpmovuswb %xmm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovuswb %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpmovuswb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 4 13 1.00 * vpmovuswb %xmm16, (%rax) {%k1} +# CHECK-NEXT: 2 4 1.00 vpmovuswb %ymm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovuswb %ymm16, (%rax) +# CHECK-NEXT: 2 6 1.00 vpmovuswb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 4 15 1.00 * vpmovuswb %ymm16, (%rax) {%k1} +# CHECK-NEXT: 2 2 1.00 vpmovwb %xmm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovwb %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpmovwb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 4 13 1.00 * vpmovwb %xmm16, (%rax) {%k1} +# CHECK-NEXT: 2 4 1.00 vpmovwb %ymm16, %xmm19 +# CHECK-NEXT: 4 12 1.00 * vpmovwb %ymm16, (%rax) +# CHECK-NEXT: 2 6 1.00 vpmovwb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 4 15 1.00 * vpmovwb %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxbw %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbw (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpmovzxbw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmovzxbw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpmovzxbw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmovzxbw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxbw %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbw (%rax), %ymm19 +# CHECK-NEXT: 1 5 1.00 vpmovzxbw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmovzxbw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmovzxbw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmovzxbw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhrsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhrsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 7 0.50 vpmulhrsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhrsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhrsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhrsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhrsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhrsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 7 0.50 vpmulhrsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhrsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhrsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhrsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 7 0.50 vpmulhuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 7 0.50 vpmulhuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 7 0.50 vpmulhw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmulhw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmulhw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 7 0.50 vpmulhw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmulhw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmulhw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmulhw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmullw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpmullw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 7 0.50 vpmullw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmullw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmullw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmullw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpmullw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpmullw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 7 0.50 vpmullw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 14 0.50 * vpmullw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 7 0.50 vpmullw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 14 0.50 * vpmullw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpsadbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpsadbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 1.00 vpsadbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpsadbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshufb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshufb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpshufb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshufb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshufb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshufb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshufb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshufb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpshufb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshufb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshufb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshufb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshufhw $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshufhw $0, (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpshufhw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshufhw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshufhw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshufhw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshufhw $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshufhw $0, (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpshufhw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshufhw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshufhw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshufhw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshuflw $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshuflw $0, (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpshuflw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshuflw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshuflw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshuflw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshuflw $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshuflw $0, (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpshuflw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshuflw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshuflw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshuflw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpslldq $1, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpslldq $1, (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpslldq $1, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpslldq $1, (%rax), %ymm19 +# CHECK-NEXT: 1 1 0.50 vpsllvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsllvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsllvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsllvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsllvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsllvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsllvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsllvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsllw $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsllw $0, (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsllw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsllw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsllw $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsllw $0, (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsllw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsllw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 2 0.67 vpsllw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsllw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 4 0.67 vpsllw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpsllw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsllw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsllw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 6 1.00 vpsllw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsllw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsllw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsllw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsravw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsravw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsravw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsravw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsravw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsravw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsravw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsravw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsravw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsravw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsravw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsravw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsraw $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsraw $0, (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsraw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsraw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsraw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsraw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsraw $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsraw $0, (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsraw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsraw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsraw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsraw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 2 0.67 vpsraw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsraw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 4 0.67 vpsraw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsraw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpsraw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsraw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsraw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsraw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 6 1.00 vpsraw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsraw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsraw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsraw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsrldq $1, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsrldq $1, (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpsrldq $1, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsrldq $1, (%rax), %ymm19 +# CHECK-NEXT: 1 1 0.50 vpsrlvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsrlvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsrlvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsrlvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsrlvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsrlvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsrlvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsrlvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsrlw $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsrlw $0, (%rax), %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsrlw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsrlw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsrlw $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsrlw $0, (%rax), %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsrlw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsrlw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 2 0.67 vpsrlw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsrlw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 4 0.67 vpsrlw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpsrlw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpsrlw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsrlw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 6 1.00 vpsrlw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsrlw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 6 1.00 vpsrlw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsrlw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpsubb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpsubb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpsubb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpsubb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpsubb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpsubb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpsubb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpsubb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsubsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsubsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsubsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsubsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsubsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsubsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsubsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsubsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubusb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsubusb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsubusb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubusb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubusb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubusb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubusb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsubusb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsubusb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubusb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubusb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubusb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubusw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpsubusw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpsubusw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubusw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubusw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubusw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpsubusw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpsubusw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpsubusw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpsubusw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpsubusw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpsubusw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.33 vpsubw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpsubw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpsubw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpsubw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.33 vpsubw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.33 * vpsubw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.33 vpsubw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.33 * vpsubw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vptestmb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmb %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmb %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmw %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmw %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 1 0.50 vpunpckhbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckhbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpunpckhbw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpckhbw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpckhbw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpckhbw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckhbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckhbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpunpckhbw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpckhbw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpckhbw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpckhbw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckhwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckhwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpunpckhwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpckhwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpckhwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpckhwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckhwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckhwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpunpckhwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpckhwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpckhwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpckhwd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpcklbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpcklbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpunpcklbw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpcklbw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpcklbw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpcklbw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpcklbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpcklbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpunpcklbw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpcklbw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpcklbw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpcklbw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpcklwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpcklwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpunpcklwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpcklwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpcklwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpcklwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpcklwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpcklwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpunpcklwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpunpcklwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpunpcklwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpunpcklwd (%rax), %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 258.67 323.17 144.00 144.00 10.00 420.17 - 10.00 10.00 10.00 - 144.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vdbpsadbw $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vdbpsadbw $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu8 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu8 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu8 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu8 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu8 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu8 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu8 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu8 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu8 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu8 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu8 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu8 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu8 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu8 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu8 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu8 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu16 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu16 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu16 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu16 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu16 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu16 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu16 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu16 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu16 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu16 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu16 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu16 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu16 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsb (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpabsw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpabsw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackssdw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackssdw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpacksswb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpacksswb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackusdw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackusdw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpackuswb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpackuswb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpaddusw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpaddusw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpalignr $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpalignr $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpavgw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpavgw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpblendmw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpblendmw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastb (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastb %eax, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpbroadcastw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastw %eax, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpermw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vpermw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2w %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2w (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2w %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2w (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddubsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddubsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaddwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaddwd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxub %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxub (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmaxuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmaxuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminub %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminub (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpminuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpminuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovb2m %xmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovw2m %xmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovb2m %ymm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovw2m %ymm0, %k0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2b %k0, %xmm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2w %k0, %xmm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2b %k0, %ymm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2w %k0, %ymm0 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbw %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbw (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbw (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovswb %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovswb %xmm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovswb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovswb %xmm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovswb %ymm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovswb %ymm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovswb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovswb %ymm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovuswb %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovuswb %xmm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovuswb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovuswb %xmm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovuswb %ymm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovuswb %ymm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovuswb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovuswb %ymm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovwb %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovwb %xmm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovwb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovwb %xmm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovwb %ymm16, %xmm19 +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovwb %ymm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpmovwb %ymm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - 0.50 1.50 - 0.50 0.50 0.50 - - - vpmovwb %ymm16, (%rax) {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbw %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbw (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbw (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbw (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbw %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbw (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhrsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhrsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhuw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhuw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmulhw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmulhw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmullw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmullw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsadbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsadbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsadbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpsadbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %ymm16, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufhw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufhw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %ymm16, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshuflw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshuflw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpslldq $1, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpslldq $1, (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpslldq $1, %ymm16, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpslldq $1, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsllw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsllw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsllw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsllw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsllw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsllw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsllw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsllw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsravw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsravw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsraw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsraw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsraw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsraw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsraw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsraw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsraw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsraw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpsrldq $1, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpsrldq $1, (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpsrldq $1, %ymm16, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpsrldq $1, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsrlw $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrlw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrlw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - vpsrlw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrlw %xmm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrlw %xmm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vpsrlw %xmm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsrlw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubsw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubsw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpsubusw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpsubusw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmb %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmb (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmw %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmw (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhbw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhbw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhwd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklbw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklbw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpcklwd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpcklwd (%rax), %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cd.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cd.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cd.s @@ -0,0 +1,154 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpbroadcastmb2q %k0, %zmm16 + +vpbroadcastmw2d %k0, %zmm16 + +vpconflictd %zmm16, %zmm19 +vpconflictd (%rax), %zmm19 +vpconflictd (%rax){1to16}, %zmm19 +vpconflictd %zmm16, %zmm19 {k1} +vpconflictd (%rax), %zmm19 {k1} +vpconflictd (%rax){1to16}, %zmm19 {k1} +vpconflictd %zmm16, %zmm19 {z}{k1} +vpconflictd (%rax), %zmm19 {z}{k1} +vpconflictd (%rax){1to16}, %zmm19 {z}{k1} + +vpconflictq %zmm16, %zmm19 +vpconflictq (%rax), %zmm19 +vpconflictq (%rax){1to8}, %zmm19 +vpconflictq %zmm16, %zmm19 {k1} +vpconflictq (%rax), %zmm19 {k1} +vpconflictq (%rax){1to8}, %zmm19 {k1} +vpconflictq %zmm16, %zmm19 {z}{k1} +vpconflictq (%rax), %zmm19 {z}{k1} +vpconflictq (%rax){1to8}, %zmm19 {z}{k1} + +vplzcntd %zmm16, %zmm19 +vplzcntd (%rax), %zmm19 +vplzcntd (%rax){1to16}, %zmm19 +vplzcntd %zmm16, %zmm19 {k1} +vplzcntd (%rax), %zmm19 {k1} +vplzcntd (%rax){1to16}, %zmm19 {k1} +vplzcntd %zmm16, %zmm19 {z}{k1} +vplzcntd (%rax), %zmm19 {z}{k1} +vplzcntd (%rax){1to16}, %zmm19 {z}{k1} + +vplzcntq %zmm16, %zmm19 +vplzcntq (%rax), %zmm19 +vplzcntq (%rax){1to8}, %zmm19 +vplzcntq %zmm16, %zmm19 {k1} +vplzcntq (%rax), %zmm19 {k1} +vplzcntq (%rax){1to8}, %zmm19 {k1} +vplzcntq %zmm16, %zmm19 {z}{k1} +vplzcntq (%rax), %zmm19 {z}{k1} +vplzcntq (%rax){1to8}, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 6 1.00 vpbroadcastmb2q %k0, %zmm16 +# CHECK-NEXT: 2 6 1.00 vpbroadcastmw2d %k0, %zmm16 +# CHECK-NEXT: 37 26 18.50 vpconflictd %zmm16, %zmm19 +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax), %zmm19 +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 37 25 18.50 vpconflictd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 37 26 18.50 vpconflictd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 37 33 18.00 * vpconflictd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 22 17 11.00 vpconflictq %zmm16, %zmm19 +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax), %zmm19 +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 22 16 11.00 vpconflictq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 22 17 11.00 vpconflictq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 22 23 10.50 * vpconflictq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vplzcntd %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vplzcntd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vplzcntd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vplzcntd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vplzcntq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vplzcntq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vplzcntq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vplzcntq (%rax){1to8}, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 243.50 - 8.00 8.00 - 297.50 - - - - - 8.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmb2q %k0, %zmm16 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmw2d %k0, %zmm16 +# CHECK-NEXT: 15.50 - - - - 21.50 - - - - - - - vpconflictd %zmm16, %zmm19 +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax), %zmm19 +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 15.50 - - - - 21.50 - - - - - - - vpconflictd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 15.50 - - - - 21.50 - - - - - - - vpconflictd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 15.00 - 0.33 0.33 - 21.00 - - - - - 0.33 - vpconflictd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 10.00 - - - - 12.00 - - - - - - - vpconflictq %zmm16, %zmm19 +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax), %zmm19 +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 10.00 - - - - 12.00 - - - - - - - vpconflictq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 10.00 - - - - 12.00 - - - - - - - vpconflictq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 9.50 - 0.33 0.33 - 11.50 - - - - - 0.33 - vpconflictq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntd %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vplzcntq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to8}, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cdvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cdvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512cdvl.s @@ -0,0 +1,272 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpbroadcastmb2q %k0, %xmm16 +vpbroadcastmb2q %k0, %ymm16 + +vpbroadcastmw2d %k0, %xmm16 +vpbroadcastmw2d %k0, %ymm16 + +vpconflictd %xmm16, %xmm19 +vpconflictd (%rax), %xmm19 +vpconflictd (%rax){1to4}, %xmm19 +vpconflictd %xmm16, %xmm19 {k1} +vpconflictd (%rax), %xmm19 {k1} +vpconflictd (%rax){1to4}, %xmm19 {k1} +vpconflictd %xmm16, %xmm19 {z}{k1} +vpconflictd (%rax), %xmm19 {z}{k1} +vpconflictd (%rax){1to4}, %xmm19 {z}{k1} + +vpconflictd %ymm16, %ymm19 +vpconflictd (%rax), %ymm19 +vpconflictd (%rax){1to8}, %ymm19 +vpconflictd %ymm16, %ymm19 {k1} +vpconflictd (%rax), %ymm19 {k1} +vpconflictd (%rax){1to8}, %ymm19 {k1} +vpconflictd %ymm16, %ymm19 {z}{k1} +vpconflictd (%rax), %ymm19 {z}{k1} +vpconflictd (%rax){1to8}, %ymm19 {z}{k1} + +vpconflictq %xmm16, %xmm19 +vpconflictq (%rax), %xmm19 +vpconflictq (%rax){1to2}, %xmm19 +vpconflictq %xmm16, %xmm19 {k1} +vpconflictq (%rax), %xmm19 {k1} +vpconflictq (%rax){1to2}, %xmm19 {k1} +vpconflictq %xmm16, %xmm19 {z}{k1} +vpconflictq (%rax), %xmm19 {z}{k1} +vpconflictq (%rax){1to2}, %xmm19 {z}{k1} + +vpconflictq %ymm16, %ymm19 +vpconflictq (%rax), %ymm19 +vpconflictq (%rax){1to4}, %ymm19 +vpconflictq %ymm16, %ymm19 {k1} +vpconflictq (%rax), %ymm19 {k1} +vpconflictq (%rax){1to4}, %ymm19 {k1} +vpconflictq %ymm16, %ymm19 {z}{k1} +vpconflictq (%rax), %ymm19 {z}{k1} +vpconflictq (%rax){1to4}, %ymm19 {z}{k1} + +vplzcntd %xmm16, %xmm19 +vplzcntd (%rax), %xmm19 +vplzcntd (%rax){1to4}, %xmm19 +vplzcntd %xmm16, %xmm19 {k1} +vplzcntd (%rax), %xmm19 {k1} +vplzcntd (%rax){1to4}, %xmm19 {k1} +vplzcntd %xmm16, %xmm19 {z}{k1} +vplzcntd (%rax), %xmm19 {z}{k1} +vplzcntd (%rax){1to4}, %xmm19 {z}{k1} + +vplzcntd %ymm16, %ymm19 +vplzcntd (%rax), %ymm19 +vplzcntd (%rax){1to8}, %ymm19 +vplzcntd %ymm16, %ymm19 {k1} +vplzcntd (%rax), %ymm19 {k1} +vplzcntd (%rax){1to8}, %ymm19 {k1} +vplzcntd %ymm16, %ymm19 {z}{k1} +vplzcntd (%rax), %ymm19 {z}{k1} +vplzcntd (%rax){1to8}, %ymm19 {z}{k1} + +vplzcntq %xmm16, %xmm19 +vplzcntq (%rax), %xmm19 +vplzcntq (%rax){1to2}, %xmm19 +vplzcntq %xmm16, %xmm19 {k1} +vplzcntq (%rax), %xmm19 {k1} +vplzcntq (%rax){1to2}, %xmm19 {k1} +vplzcntq %xmm16, %xmm19 {z}{k1} +vplzcntq (%rax), %xmm19 {z}{k1} +vplzcntq (%rax){1to2}, %xmm19 {z}{k1} + +vplzcntq %ymm16, %ymm19 +vplzcntq (%rax), %ymm19 +vplzcntq (%rax){1to4}, %ymm19 +vplzcntq %ymm16, %ymm19 {k1} +vplzcntq (%rax), %ymm19 {k1} +vplzcntq (%rax){1to4}, %ymm19 {k1} +vplzcntq %ymm16, %ymm19 {z}{k1} +vplzcntq (%rax), %ymm19 {z}{k1} +vplzcntq (%rax){1to4}, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 6 1.00 vpbroadcastmb2q %k0, %xmm16 +# CHECK-NEXT: 2 6 1.00 vpbroadcastmb2q %k0, %ymm16 +# CHECK-NEXT: 2 6 1.00 vpbroadcastmw2d %k0, %xmm16 +# CHECK-NEXT: 2 6 1.00 vpbroadcastmw2d %k0, %ymm16 +# CHECK-NEXT: 15 12 5.00 vpconflictd %xmm16, %xmm19 +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax), %xmm19 +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax){1to4}, %xmm19 +# CHECK-NEXT: 15 12 5.00 vpconflictd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 15 12 5.00 vpconflictd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 15 17 5.00 * vpconflictd (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 23 17 9.00 vpconflictd %ymm16, %ymm19 +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax), %ymm19 +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax){1to8}, %ymm19 +# CHECK-NEXT: 23 17 9.00 vpconflictd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 23 17 9.00 vpconflictd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 23 24 9.00 * vpconflictd (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 4 2.00 vpconflictq %xmm16, %xmm19 +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax), %xmm19 +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 3 4 2.00 vpconflictq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 3 4 2.00 vpconflictq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 4 11 2.00 * vpconflictq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 15 13 5.00 vpconflictq %ymm16, %ymm19 +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax), %ymm19 +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 15 13 5.00 vpconflictq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 15 13 5.00 vpconflictq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 15 20 5.00 * vpconflictq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vplzcntd %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vplzcntd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vplzcntd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vplzcntd (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vplzcntd %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vplzcntd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vplzcntd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vplzcntd (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vplzcntq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vplzcntq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vplzcntq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vplzcntq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vplzcntq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vplzcntq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vplzcntq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vplzcntq (%rax){1to4}, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 148.00 139.50 16.00 16.00 - 238.00 4.50 - - - - 16.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmb2q %k0, %xmm16 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmb2q %k0, %ymm16 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmw2d %k0, %xmm16 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vpbroadcastmw2d %k0, %ymm16 +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictd %xmm16, %xmm19 +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax), %xmm19 +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax){1to4}, %xmm19 +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictd (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 6.00 5.50 - - - 11.00 0.50 - - - - - - vpconflictd %ymm16, %ymm19 +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax), %ymm19 +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax){1to8}, %ymm19 +# CHECK-NEXT: 6.00 5.50 - - - 11.00 0.50 - - - - - - vpconflictd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 6.00 5.50 - - - 11.00 0.50 - - - - - - vpconflictd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 5.67 5.17 0.33 0.33 - 10.67 0.50 - - - - 0.33 - vpconflictd (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpconflictq %xmm16, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax), %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpconflictq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpconflictq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpconflictq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictq %ymm16, %ymm19 +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax), %ymm19 +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 4.17 4.17 - - - 6.67 - - - - - - - vpconflictq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3.83 3.83 0.33 0.33 - 6.33 - - - - - 0.33 - vpconflictq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntd (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vplzcntq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vplzcntq (%rax){1to4}, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dq.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dq.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dq.s @@ -0,0 +1,1267 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +kaddb %k0, %k1, %k2 +kaddw %k0, %k1, %k2 +kandb %k0, %k1, %k2 +kandnb %k0, %k1, %k2 + +kmovb %k0, %k2 +kmovb (%rax), %k2 +kmovb %k0, (%rax) +kmovb %eax, %k2 +kmovb %k0, %eax + +knotb %k0, %k2 + +korb %k0, %k1, %k2 + +kortestb %k0, %k2 + +kshiftlb $2, %k1, %k2 +kshiftrb $2, %k1, %k2 + +ktestb %k0, %k2 +ktestw %k0, %k2 + +kxnorb %k0, %k1, %k2 +kxorb %k0, %k1, %k2 + +vandnpd %zmm16, %zmm17, %zmm19 +vandnpd (%rax), %zmm17, %zmm19 +vandnpd (%rax){1to8}, %zmm17, %zmm19 +vandnpd %zmm16, %zmm17, %zmm19 {k1} +vandnpd (%rax), %zmm17, %zmm19 {k1} +vandnpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vandnpd %zmm16, %zmm17, %zmm19 {z}{k1} +vandnpd (%rax), %zmm17, %zmm19 {z}{k1} +vandnpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vandnps %zmm16, %zmm17, %zmm19 +vandnps (%rax), %zmm17, %zmm19 +vandnps (%rax){1to16}, %zmm17, %zmm19 +vandnps %zmm16, %zmm17, %zmm19 {k1} +vandnps (%rax), %zmm17, %zmm19 {k1} +vandnps (%rax){1to16}, %zmm17, %zmm19 {k1} +vandnps %zmm16, %zmm17, %zmm19 {z}{k1} +vandnps (%rax), %zmm17, %zmm19 {z}{k1} +vandnps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vandpd %zmm16, %zmm17, %zmm19 +vandpd (%rax), %zmm17, %zmm19 +vandpd (%rax){1to8}, %zmm17, %zmm19 +vandpd %zmm16, %zmm17, %zmm19 {k1} +vandpd (%rax), %zmm17, %zmm19 {k1} +vandpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vandpd %zmm16, %zmm17, %zmm19 {z}{k1} +vandpd (%rax), %zmm17, %zmm19 {z}{k1} +vandpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vandps %zmm16, %zmm17, %zmm19 +vandps (%rax), %zmm17, %zmm19 +vandps (%rax){1to16}, %zmm17, %zmm19 +vandps %zmm16, %zmm17, %zmm19 {k1} +vandps (%rax), %zmm17, %zmm19 {k1} +vandps (%rax){1to16}, %zmm17, %zmm19 {k1} +vandps %zmm16, %zmm17, %zmm19 {z}{k1} +vandps (%rax), %zmm17, %zmm19 {z}{k1} +vandps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vbroadcastf32x2 %xmm16, %zmm19 +vbroadcastf32x2 (%rax), %zmm19 +vbroadcastf32x2 %xmm16, %zmm19 {k1} +vbroadcastf32x2 (%rax), %zmm19 {k1} +vbroadcastf32x2 %xmm16, %zmm19 {z}{k1} +vbroadcastf32x2 (%rax), %zmm19 {z}{k1} + +vbroadcastf32x8 (%rax), %zmm19 +vbroadcastf32x8 (%rax), %zmm19 {k1} +vbroadcastf32x8 (%rax), %zmm19 {z}{k1} + +vbroadcastf64x2 (%rax), %zmm19 +vbroadcastf64x2 (%rax), %zmm19 {k1} +vbroadcastf64x2 (%rax), %zmm19 {z}{k1} + +vbroadcasti32x2 %xmm16, %zmm19 +vbroadcasti32x2 (%rax), %zmm19 +vbroadcasti32x2 %xmm16, %zmm19 {k1} +vbroadcasti32x2 (%rax), %zmm19 {k1} +vbroadcasti32x2 %xmm16, %zmm19 {z}{k1} +vbroadcasti32x2 (%rax), %zmm19 {z}{k1} + +vbroadcasti32x8 (%rax), %zmm19 +vbroadcasti32x8 (%rax), %zmm19 {k1} +vbroadcasti32x8 (%rax), %zmm19 {z}{k1} + +vbroadcasti64x2 (%rax), %zmm19 +vbroadcasti64x2 (%rax), %zmm19 {k1} +vbroadcasti64x2 (%rax), %zmm19 {z}{k1} + +vcvtpd2qq %zmm16, %zmm19 +vcvtpd2qq (%rax), %zmm19 +vcvtpd2qq (%rax){1to8}, %zmm19 +vcvtpd2qq %zmm16, %zmm19 {k1} +vcvtpd2qq (%rax), %zmm19 {k1} +vcvtpd2qq (%rax){1to8}, %zmm19 {k1} +vcvtpd2qq %zmm16, %zmm19 {z}{k1} +vcvtpd2qq (%rax), %zmm19 {z}{k1} +vcvtpd2qq (%rax){1to8}, %zmm19 {z}{k1} + +vcvtpd2uqq %zmm16, %zmm19 +vcvtpd2uqq (%rax), %zmm19 +vcvtpd2uqq (%rax){1to8}, %zmm19 +vcvtpd2uqq %zmm16, %zmm19 {k1} +vcvtpd2uqq (%rax), %zmm19 {k1} +vcvtpd2uqq (%rax){1to8}, %zmm19 {k1} +vcvtpd2uqq %zmm16, %zmm19 {z}{k1} +vcvtpd2uqq (%rax), %zmm19 {z}{k1} +vcvtpd2uqq (%rax){1to8}, %zmm19 {z}{k1} + +vcvtps2qq %ymm16, %zmm19 +vcvtps2qq (%rax), %zmm19 +vcvtps2qq (%rax){1to8}, %zmm19 +vcvtps2qq %ymm16, %zmm19 {k1} +vcvtps2qq (%rax), %zmm19 {k1} +vcvtps2qq (%rax){1to8}, %zmm19 {k1} +vcvtps2qq %ymm16, %zmm19 {z}{k1} +vcvtps2qq (%rax), %zmm19 {z}{k1} +vcvtps2qq (%rax){1to8}, %zmm19 {z}{k1} + +vcvtps2uqq %ymm16, %zmm19 +vcvtps2uqq (%rax), %zmm19 +vcvtps2uqq (%rax){1to8}, %zmm19 +vcvtps2uqq %ymm16, %zmm19 {k1} +vcvtps2uqq (%rax), %zmm19 {k1} +vcvtps2uqq (%rax){1to8}, %zmm19 {k1} +vcvtps2uqq %ymm16, %zmm19 {z}{k1} +vcvtps2uqq (%rax), %zmm19 {z}{k1} +vcvtps2uqq (%rax){1to8}, %zmm19 {z}{k1} + +vcvtqq2pd %zmm16, %zmm19 +vcvtqq2pd (%rax), %zmm19 +vcvtqq2pd (%rax){1to8}, %zmm19 +vcvtqq2pd %zmm16, %zmm19 {k1} +vcvtqq2pd (%rax), %zmm19 {k1} +vcvtqq2pd (%rax){1to8}, %zmm19 {k1} +vcvtqq2pd %zmm16, %zmm19 {z}{k1} +vcvtqq2pd (%rax), %zmm19 {z}{k1} +vcvtqq2pd (%rax){1to8}, %zmm19 {z}{k1} + +vcvtqq2ps %zmm16, %ymm19 +vcvtqq2ps (%rax), %ymm19 +vcvtqq2ps (%rax){1to8}, %ymm19 +vcvtqq2ps %zmm16, %ymm19 {k1} +vcvtqq2ps (%rax), %ymm19 {k1} +vcvtqq2ps (%rax){1to8}, %ymm19 {k1} +vcvtqq2ps %zmm16, %ymm19 {z}{k1} +vcvtqq2ps (%rax), %ymm19 {z}{k1} +vcvtqq2ps (%rax){1to8}, %ymm19 {z}{k1} + +vcvttpd2qq %zmm16, %zmm19 +vcvttpd2qq (%rax), %zmm19 +vcvttpd2qq (%rax){1to8}, %zmm19 +vcvttpd2qq %zmm16, %zmm19 {k1} +vcvttpd2qq (%rax), %zmm19 {k1} +vcvttpd2qq (%rax){1to8}, %zmm19 {k1} +vcvttpd2qq %zmm16, %zmm19 {z}{k1} +vcvttpd2qq (%rax), %zmm19 {z}{k1} +vcvttpd2qq (%rax){1to8}, %zmm19 {z}{k1} + +vcvttpd2uqq %zmm16, %zmm19 +vcvttpd2uqq (%rax), %zmm19 +vcvttpd2uqq (%rax){1to8}, %zmm19 +vcvttpd2uqq %zmm16, %zmm19 {k1} +vcvttpd2uqq (%rax), %zmm19 {k1} +vcvttpd2uqq (%rax){1to8}, %zmm19 {k1} +vcvttpd2uqq %zmm16, %zmm19 {z}{k1} +vcvttpd2uqq (%rax), %zmm19 {z}{k1} +vcvttpd2uqq (%rax){1to8}, %zmm19 {z}{k1} + +vcvttps2qq %ymm16, %zmm19 +vcvttps2qq (%rax), %zmm19 +vcvttps2qq (%rax){1to8}, %zmm19 +vcvttps2qq %ymm16, %zmm19 {k1} +vcvttps2qq (%rax), %zmm19 {k1} +vcvttps2qq (%rax){1to8}, %zmm19 {k1} +vcvttps2qq %ymm16, %zmm19 {z}{k1} +vcvttps2qq (%rax), %zmm19 {z}{k1} +vcvttps2qq (%rax){1to8}, %zmm19 {z}{k1} + +vcvttps2uqq %ymm16, %zmm19 +vcvttps2uqq (%rax), %zmm19 +vcvttps2uqq (%rax){1to8}, %zmm19 +vcvttps2uqq %ymm16, %zmm19 {k1} +vcvttps2uqq (%rax), %zmm19 {k1} +vcvttps2uqq (%rax){1to8}, %zmm19 {k1} +vcvttps2uqq %ymm16, %zmm19 {z}{k1} +vcvttps2uqq (%rax), %zmm19 {z}{k1} +vcvttps2uqq (%rax){1to8}, %zmm19 {z}{k1} + +vcvtuqq2pd %zmm16, %zmm19 +vcvtuqq2pd (%rax), %zmm19 +vcvtuqq2pd (%rax){1to8}, %zmm19 +vcvtuqq2pd %zmm16, %zmm19 {k1} +vcvtuqq2pd (%rax), %zmm19 {k1} +vcvtuqq2pd (%rax){1to8}, %zmm19 {k1} +vcvtuqq2pd %zmm16, %zmm19 {z}{k1} +vcvtuqq2pd (%rax), %zmm19 {z}{k1} +vcvtuqq2pd (%rax){1to8}, %zmm19 {z}{k1} + +vcvtuqq2ps %zmm16, %ymm19 +vcvtuqq2ps (%rax), %ymm19 +vcvtuqq2ps (%rax){1to8}, %ymm19 +vcvtuqq2ps %zmm16, %ymm19 {k1} +vcvtuqq2ps (%rax), %ymm19 {k1} +vcvtuqq2ps (%rax){1to8}, %ymm19 {k1} +vcvtuqq2ps %zmm16, %ymm19 {z}{k1} +vcvtuqq2ps (%rax), %ymm19 {z}{k1} +vcvtuqq2ps (%rax){1to8}, %ymm19 {z}{k1} + +vextractf32x8 $1, %zmm16, %ymm19 +vextractf32x8 $1, %zmm16, (%rax) +vextractf32x8 $1, %zmm16, %ymm19 {k1} +vextractf32x8 $1, %zmm16, (%rax) {k1} +vextractf32x8 $1, %zmm16, %ymm19 {z}{k1} + +vextractf64x2 $1, %zmm16, %xmm19 +vextractf64x2 $1, %zmm16, (%rax) +vextractf64x2 $1, %zmm16, %xmm19 {k1} +vextractf64x2 $1, %zmm16, (%rax) {k1} +vextractf64x2 $1, %zmm16, %xmm19 {z}{k1} + +vextracti32x8 $1, %zmm16, %ymm19 +vextracti32x8 $1, %zmm16, (%rax) +vextracti32x8 $1, %zmm16, %ymm19 {k1} +vextracti32x8 $1, %zmm16, (%rax) {k1} +vextracti32x8 $1, %zmm16, %ymm19 {z}{k1} + +vextracti64x2 $1, %zmm16, %xmm19 +vextracti64x2 $1, %zmm16, (%rax) +vextracti64x2 $1, %zmm16, %xmm19 {k1} +vextracti64x2 $1, %zmm16, (%rax) {k1} +vextracti64x2 $1, %zmm16, %xmm19 {z}{k1} + +vfpclasspd $0xab, %zmm16, %k1 +vfpclasspdz $0xab, (%rax), %k1 +vfpclasspdz $0xab, (%rax){1to8}, %k1 +vfpclasspd $0xab, %zmm16, %k1 {k2} +vfpclasspdz $0xab, (%rax), %k1 {k2} +vfpclasspdz $0xab, (%rax){1to8}, %k1 {k2} + +vfpclassps $0xab, %zmm16, %k1 +vfpclasspsz $0xab, (%rax), %k1 +vfpclasspsz $0xab, (%rax){1to16}, %k1 +vfpclassps $0xab, %zmm16, %k1 {k2} +vfpclasspsz $0xab, (%rax), %k1 {k2} +vfpclasspsz $0xab, (%rax){1to16}, %k1 {k2} + +vfpclasssd $0xab, %xmm16, %k1 +vfpclasssd $0xab, (%rax), %k1 +vfpclasssd $0xab, %xmm16, %k1 {k2} +vfpclasssd $0xab, (%rax), %k1 {k2} + +vfpclassss $0xab, %xmm16, %k1 +vfpclassss $0xab, (%rax), %k1 +vfpclassss $0xab, %xmm16, %k1 {k2} +vfpclassss $0xab, (%rax), %k1 {k2} + +vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 +vinsertf32x8 $1, (%rax), %zmm16, %zmm19 +vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {k1} +vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {k1} +vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {z}{k1} +vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {z}{k1} + +vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 +vinsertf64x2 $1, (%rax), %zmm16, %zmm19 +vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {k1} +vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {k1} +vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {z}{k1} +vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {z}{k1} + +vinserti32x8 $1, %ymm16, %zmm16, %zmm19 +vinserti32x8 $1, (%rax), %zmm16, %zmm19 +vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {k1} +vinserti32x8 $1, (%rax), %zmm16, %zmm19 {k1} +vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {z}{k1} +vinserti32x8 $1, (%rax), %zmm16, %zmm19 {z}{k1} + +vinserti64x2 $1, %xmm16, %zmm16, %zmm19 +vinserti64x2 $1, (%rax), %zmm16, %zmm19 +vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {k1} +vinserti64x2 $1, (%rax), %zmm16, %zmm19 {k1} +vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {z}{k1} +vinserti64x2 $1, (%rax), %zmm16, %zmm19 {z}{k1} + +vorpd %zmm16, %zmm17, %zmm19 +vorpd (%rax), %zmm17, %zmm19 +vorpd (%rax){1to8}, %zmm17, %zmm19 +vorpd %zmm16, %zmm17, %zmm19 {k1} +vorpd (%rax), %zmm17, %zmm19 {k1} +vorpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vorpd %zmm16, %zmm17, %zmm19 {z}{k1} +vorpd (%rax), %zmm17, %zmm19 {z}{k1} +vorpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vorps %zmm16, %zmm17, %zmm19 +vorps (%rax), %zmm17, %zmm19 +vorps (%rax){1to16}, %zmm17, %zmm19 +vorps %zmm16, %zmm17, %zmm19 {k1} +vorps (%rax), %zmm17, %zmm19 {k1} +vorps (%rax){1to16}, %zmm17, %zmm19 {k1} +vorps %zmm16, %zmm17, %zmm19 {z}{k1} +vorps (%rax), %zmm17, %zmm19 {z}{k1} +vorps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpextrd $1, %xmm16, %ecx +vpextrd $1, %xmm16, (%rax) + +vpextrq $1, %xmm16, %rcx +vpextrq $1, %xmm16, (%rax) + +vpinsrd $1, %ecx, %xmm16, %xmm19 +vpinsrd $1, (%rax), %xmm16, %xmm19 + +vpinsrq $1, %rcx, %xmm16, %xmm19 +vpinsrq $1, (%rax), %xmm16, %xmm19 + +vpmovm2d %k0, %zmm0 +vpmovm2q %k0, %zmm0 + +vpmovd2m %zmm0, %k0 +vpmovq2m %zmm0, %k0 + +vpmullq %zmm16, %zmm17, %zmm19 +vpmullq (%rax), %zmm17, %zmm19 +vpmullq %zmm16, %zmm17, %zmm19 {k1} +vpmullq (%rax), %zmm17, %zmm19 {k1} +vpmullq %zmm16, %zmm17, %zmm19 {z}{k1} +vpmullq (%rax), %zmm17, %zmm19 {z}{k1} + +vrangepd $ab, %zmm16, %zmm17, %zmm19 +vrangepd $ab, (%rax), %zmm17, %zmm19 +vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 +vrangepd $ab, %zmm16, %zmm17, %zmm19 {k1} +vrangepd $ab, (%rax), %zmm17, %zmm19 {k1} +vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {k1} +vrangepd $ab, %zmm16, %zmm17, %zmm19 {z}{k1} +vrangepd $ab, (%rax), %zmm17, %zmm19 {z}{k1} +vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 +vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {k1} +vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {z}{k1} + +vrangeps $ab, %zmm16, %zmm17, %zmm19 +vrangeps $ab, (%rax), %zmm17, %zmm19 +vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 +vrangeps $ab, %zmm16, %zmm17, %zmm19 {k1} +vrangeps $ab, (%rax), %zmm17, %zmm19 {k1} +vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {k1} +vrangeps $ab, %zmm16, %zmm17, %zmm19 {z}{k1} +vrangeps $ab, (%rax), %zmm17, %zmm19 {z}{k1} +vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 +vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {k1} +vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {z}{k1} + +vrangesd $ab, %xmm16, %xmm17, %xmm19 +vrangesd $ab, (%rax), %xmm17, %xmm19 +vrangesd $ab, %xmm16, %xmm17, %xmm19 {k1} +vrangesd $ab, (%rax), %xmm17, %xmm19 {k1} +vrangesd $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vrangesd $ab, (%rax), %xmm17, %xmm19 {z}{k1} + +vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {k1} +vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {z}{k1} + +vrangess $ab, %xmm16, %xmm17, %xmm19 +vrangess $ab, (%rax), %xmm17, %xmm19 +vrangess $ab, %xmm16, %xmm17, %xmm19 {k1} +vrangess $ab, (%rax), %xmm17, %xmm19 {k1} +vrangess $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vrangess $ab, (%rax), %xmm17, %xmm19 {z}{k1} + +vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 +vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {k1} +vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {z}{k1} + +vreducepd $ab, %zmm16, %zmm19 +vreducepd $ab, (%rax), %zmm19 +vreducepd $ab, (%rax){1to8}, %zmm19 +vreducepd $ab, %zmm16, %zmm19 {k1} +vreducepd $ab, (%rax), %zmm19 {k1} +vreducepd $ab, (%rax){1to8}, %zmm19 {k1} +vreducepd $ab, %zmm16, %zmm19 {z}{k1} +vreducepd $ab, (%rax), %zmm19 {z}{k1} +vreducepd $ab, (%rax){1to8}, %zmm19 {z}{k1} + +vreducepd $ab, {sae}, %zmm16, %zmm19 +vreducepd $ab, {sae}, %zmm16, %zmm19 {k1} +vreducepd $ab, {sae}, %zmm16, %zmm19 {z}{k1} + +vreduceps $ab, %zmm16, %zmm19 +vreduceps $ab, (%rax), %zmm19 +vreduceps $ab, (%rax){1to16}, %zmm19 +vreduceps $ab, %zmm16, %zmm19 {k1} +vreduceps $ab, (%rax), %zmm19 {k1} +vreduceps $ab, (%rax){1to16}, %zmm19 {k1} +vreduceps $ab, %zmm16, %zmm19 {z}{k1} +vreduceps $ab, (%rax), %zmm19 {z}{k1} +vreduceps $ab, (%rax){1to16}, %zmm19 {z}{k1} + +vreduceps $ab, {sae}, %zmm16, %zmm19 +vreduceps $ab, {sae}, %zmm16, %zmm19 {k1} +vreduceps $ab, {sae}, %zmm16, %zmm19 {z}{k1} + +vreducesd $ab, %xmm16, %xmm17, %xmm19 +vreducesd $ab, (%rax), %xmm17, %xmm19 +vreducesd $ab, %xmm16, %xmm17, %xmm19 {k1} +vreducesd $ab, (%rax), %xmm17, %xmm19 {k1} +vreducesd $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vreducesd $ab, (%rax), %xmm17, %xmm19 {z}{k1} + +vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {k1} +vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {z}{k1} + +vreducess $ab, %xmm16, %xmm17, %xmm19 +vreducess $ab, (%rax), %xmm17, %xmm19 +vreducess $ab, %xmm16, %xmm17, %xmm19 {k1} +vreducess $ab, (%rax), %xmm17, %xmm19 {k1} +vreducess $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vreducess $ab, (%rax), %xmm17, %xmm19 {z}{k1} + +vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 +vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {k1} +vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {z}{k1} + +vxorpd %zmm16, %zmm17, %zmm19 +vxorpd (%rax), %zmm17, %zmm19 +vxorpd (%rax){1to8}, %zmm17, %zmm19 +vxorpd %zmm16, %zmm17, %zmm19 {k1} +vxorpd (%rax), %zmm17, %zmm19 {k1} +vxorpd (%rax){1to8}, %zmm17, %zmm19 {k1} +vxorpd %zmm16, %zmm17, %zmm19 {z}{k1} +vxorpd (%rax), %zmm17, %zmm19 {z}{k1} +vxorpd (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vxorps %zmm16, %zmm17, %zmm19 +vxorps (%rax), %zmm17, %zmm19 +vxorps (%rax){1to16}, %zmm17, %zmm19 +vxorps %zmm16, %zmm17, %zmm19 {k1} +vxorps (%rax), %zmm17, %zmm19 {k1} +vxorps (%rax){1to16}, %zmm17, %zmm19 {k1} +vxorps %zmm16, %zmm17, %zmm19 {z}{k1} +vxorps (%rax), %zmm17, %zmm19 {z}{k1} +vxorps (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 4 1.00 kaddb %k0, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kaddw %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandb %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kandnb %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kmovb %k0, %k2 +# CHECK-NEXT: 2 7 1.00 * kmovb (%rax), %k2 +# CHECK-NEXT: 2 13 0.50 * kmovb %k0, (%rax) +# CHECK-NEXT: 1 3 1.00 kmovb %eax, %k2 +# CHECK-NEXT: 1 3 1.00 kmovb %k0, %eax +# CHECK-NEXT: 1 1 1.00 knotb %k0, %k2 +# CHECK-NEXT: 1 1 1.00 korb %k0, %k1, %k2 +# CHECK-NEXT: 1 3 1.00 kortestb %k0, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftlb $2, %k1, %k2 +# CHECK-NEXT: 1 4 1.00 kshiftrb $2, %k1, %k2 +# CHECK-NEXT: 1 3 1.00 ktestb %k0, %k2 +# CHECK-NEXT: 1 3 1.00 ktestw %k0, %k2 +# CHECK-NEXT: 1 1 1.00 kxnorb %k0, %k1, %k2 +# CHECK-NEXT: 1 1 1.00 kxorb %k0, %k1, %k2 +# CHECK-NEXT: 1 1 0.50 vandnpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vandnpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vandnpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandnpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vandnps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vandnps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vandnps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandnps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vandpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vandpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vandpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vandps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vandps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vandps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vandps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vandps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vandps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastf32x2 (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf32x8 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf32x8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf64x2 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcastf64x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcastf64x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %zmm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcasti32x2 (%rax), %zmm19 +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti32x8 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti32x8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti64x2 (%rax), %zmm19 +# CHECK-NEXT: 2 9 0.50 * vbroadcasti64x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vbroadcasti64x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtpd2qq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtpd2qq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtpd2qq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtpd2uqq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtpd2uqq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtpd2uqq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtpd2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %ymm16, %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax), %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %ymm16, %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax), %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvtps2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtqq2pd %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtqq2pd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtqq2pd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtqq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvttpd2qq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvttpd2qq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvttpd2qq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvttpd2uqq %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvttpd2uqq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvttpd2uqq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvttpd2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %ymm16, %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax), %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvttps2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %ymm16, %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax), %zmm19 +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 3 13 1.00 * vcvttps2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vcvtuqq2pd %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vcvtuqq2pd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vcvtuqq2pd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vcvtuqq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %zmm16, %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax), %ymm19 +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextractf32x8 $1, %zmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 vextractf32x8 $1, %zmm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextractf32x8 $1, %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextractf32x8 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextractf32x8 $1, %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %zmm16, %xmm19 +# CHECK-NEXT: 2 12 0.50 vextractf64x2 $1, %zmm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %zmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextractf64x2 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %zmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextracti32x8 $1, %zmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 vextracti32x8 $1, %zmm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextracti32x8 $1, %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextracti32x8 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextracti32x8 $1, %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %zmm16, %xmm19 +# CHECK-NEXT: 2 12 0.50 vextracti64x2 $1, %zmm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %zmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextracti64x2 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %zmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %zmm16, %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclasspdz $171, (%rax), %k1 +# CHECK-NEXT: 2 11 1.00 * vfpclasspd $171, (%rax){1to8}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %zmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspdz $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspd $171, (%rax){1to8}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %zmm16, %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclasspsz $171, (%rax), %k1 +# CHECK-NEXT: 2 11 1.00 * vfpclassps $171, (%rax){1to16}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %zmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspsz $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclassps $171, (%rax){1to16}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclasssd $171, %xmm16, %k1 +# CHECK-NEXT: 2 9 1.00 * vfpclasssd $171, (%rax), %k1 +# CHECK-NEXT: 1 3 1.00 vfpclasssd $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasssd $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclassss $171, %xmm16, %k1 +# CHECK-NEXT: 2 9 1.00 * vfpclassss $171, (%rax), %k1 +# CHECK-NEXT: 1 3 1.00 vfpclassss $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclassss $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vinsertf32x8 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: 1 3 1.00 vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vinsertf64x2 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vinserti32x8 $1, %ymm16, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vinserti32x8 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: 1 3 1.00 vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vinserti32x8 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vinserti32x8 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %zmm16, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vinserti64x2 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vinserti64x2 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vinserti64x2 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vorpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vorpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vorpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vorps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vorps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vorps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vorps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vorps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vorps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vorps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vorps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vorps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 4 1.00 vpextrd $1, %xmm16, %ecx +# CHECK-NEXT: 3 12 0.50 * vpextrd $1, %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpextrq $1, %xmm16, %rcx +# CHECK-NEXT: 3 12 0.50 * vpextrq $1, %xmm16, (%rax) +# CHECK-NEXT: 2 4 1.00 vpinsrd $1, %ecx, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpinsrd $1, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 2 4 1.00 vpinsrq $1, %rcx, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpinsrq $1, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovm2d %k0, %zmm0 +# CHECK-NEXT: 1 1 0.50 vpmovm2q %k0, %zmm0 +# CHECK-NEXT: 1 3 1.00 vpmovd2m %zmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovq2m %zmm0, %k0 +# CHECK-NEXT: 3 15 3.00 vpmullq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 23 3.00 * vpmullq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 15 3.00 vpmullq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 23 3.00 * vpmullq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 15 3.00 vpmullq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 23 3.00 * vpmullq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangesd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangesd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangesd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangess $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangess $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangess $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangess $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangess $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangess $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vreducepd $ab, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, {sae}, %zmm16, %zmm19 +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, {sae}, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vreducepd $ab, {sae}, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, %zmm16, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax), %zmm19 +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vreduceps $ab, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, {sae}, %zmm16, %zmm19 +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, {sae}, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vreduceps $ab, {sae}, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreducesd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreducesd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreducesd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducess $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreducess $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreducess $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreducess $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducess $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreducess $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vxorpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vxorpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vxorpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vxorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vxorps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 0.50 vxorps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vxorps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vxorps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 256.00 22.00 68.00 68.00 5.50 165.00 - 5.50 5.50 5.50 - 68.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kaddb %k0, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kaddw %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandb %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kandnb %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovb %k0, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - kmovb (%rax), %k2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - kmovb %k0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kmovb %eax, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kmovb %k0, %eax +# CHECK-NEXT: 1.00 - - - - - - - - - - - - knotb %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - korb %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kortestb %k0, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftlb $2, %k1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - kshiftrb $2, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ktestb %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ktestw %k0, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxnorb %k0, %k1, %k2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - kxorb %k0, %k1, %k2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandnps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandnps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vandps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vandps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf32x2 (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf32x8 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf32x8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf64x2 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf64x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcastf64x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x2 (%rax), %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x8 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x8 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti32x8 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti64x2 (%rax), %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti64x2 (%rax), %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vbroadcasti64x2 (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2qq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2qq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2qq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2uqq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2uqq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtpd2uqq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2qq %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2qq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2qq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2uqq %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2uqq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtps2uqq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtps2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtqq2pd %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtqq2pd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtqq2pd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtqq2ps %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtqq2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtqq2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2qq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2qq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2qq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2uqq %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2uqq %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvttpd2uqq %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2qq %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2qq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2qq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2qq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2uqq %ymm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2uqq %ymm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvttps2uqq %ymm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttps2uqq (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtuqq2pd %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtuqq2pd %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vcvtuqq2pd %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtuqq2ps %zmm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtuqq2ps %zmm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - vcvtuqq2ps %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf32x8 $1, %zmm16, %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf32x8 $1, %zmm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf32x8 $1, %zmm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf32x8 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf32x8 $1, %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %zmm16, %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf64x2 $1, %zmm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %zmm16, %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf64x2 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %zmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti32x8 $1, %zmm16, %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti32x8 $1, %zmm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti32x8 $1, %zmm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti32x8 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti32x8 $1, %zmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %zmm16, %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti64x2 $1, %zmm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %zmm16, %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti64x2 $1, %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %zmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %zmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdz $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to8}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %zmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdz $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to8}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %zmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsz $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to16}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %zmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsz $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to16}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasssd $171, %xmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasssd $171, (%rax), %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasssd $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasssd $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassss $171, %xmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassss $171, (%rax), %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassss $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassss $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf32x8 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf32x8 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti32x8 $1, %ymm16, %zmm16, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti32x8 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti32x8 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti32x8 $1, %ymm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti32x8 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %zmm16, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti64x2 $1, (%rax), %zmm16, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti64x2 $1, (%rax), %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vinserti64x2 $1, (%rax), %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vorps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vorps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrd $1, %xmm16, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrd $1, %xmm16, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - vpextrq $1, %xmm16, %rcx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - vpextrq $1, %xmm16, (%rax) +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrd $1, %ecx, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrd $1, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - vpinsrq $1, %rcx, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpinsrq $1, (%rax), %xmm16, %xmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpmovm2d %k0, %zmm0 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vpmovm2q %k0, %zmm0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovd2m %zmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovq2m %zmm0, %k0 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - vpmullq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - vpmullq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3.00 - - - - - - - - - - - - vpmullq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangepd $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vrangeps $ab, {sae}, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangesd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangesd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangesd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangess $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangess $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangess $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to8}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to8}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to8}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, {sae}, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, {sae}, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreducepd $ab, {sae}, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to16}, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to16}, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to16}, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, {sae}, %zmm16, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, {sae}, %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vreduceps $ab, {sae}, %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducesd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducesd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducesd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducesd $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducess $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducess $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducess $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducess $ab, {sae}, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorpd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorpd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorpd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorpd (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorps %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorps %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - vxorps %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vxorps (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dqvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dqvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512dqvl.s @@ -0,0 +1,1667 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vandnpd %xmm16, %xmm17, %xmm19 +vandnpd (%rax), %xmm17, %xmm19 +vandnpd (%rax){1to2}, %xmm17, %xmm19 +vandnpd %xmm16, %xmm17, %xmm19 {k1} +vandnpd (%rax), %xmm17, %xmm19 {k1} +vandnpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vandnpd %xmm16, %xmm17, %xmm19 {z}{k1} +vandnpd (%rax), %xmm17, %xmm19 {z}{k1} +vandnpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vandnpd %ymm16, %ymm17, %ymm19 +vandnpd (%rax), %ymm17, %ymm19 +vandnpd (%rax){1to4}, %ymm17, %ymm19 +vandnpd %ymm16, %ymm17, %ymm19 {k1} +vandnpd (%rax), %ymm17, %ymm19 {k1} +vandnpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vandnpd %ymm16, %ymm17, %ymm19 {z}{k1} +vandnpd (%rax), %ymm17, %ymm19 {z}{k1} +vandnpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vandnps %xmm16, %xmm17, %xmm19 +vandnps (%rax), %xmm17, %xmm19 +vandnps (%rax){1to4}, %xmm17, %xmm19 +vandnps %xmm16, %xmm17, %xmm19 {k1} +vandnps (%rax), %xmm17, %xmm19 {k1} +vandnps (%rax){1to4}, %xmm17, %xmm19 {k1} +vandnps %xmm16, %xmm17, %xmm19 {z}{k1} +vandnps (%rax), %xmm17, %xmm19 {z}{k1} +vandnps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vandnps %ymm16, %ymm17, %ymm19 +vandnps (%rax), %ymm17, %ymm19 +vandnps (%rax){1to8}, %ymm17, %ymm19 +vandnps %ymm16, %ymm17, %ymm19 {k1} +vandnps (%rax), %ymm17, %ymm19 {k1} +vandnps (%rax){1to8}, %ymm17, %ymm19 {k1} +vandnps %ymm16, %ymm17, %ymm19 {z}{k1} +vandnps (%rax), %ymm17, %ymm19 {z}{k1} +vandnps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vandpd %xmm16, %xmm17, %xmm19 +vandpd (%rax), %xmm17, %xmm19 +vandpd (%rax){1to2}, %xmm17, %xmm19 +vandpd %xmm16, %xmm17, %xmm19 {k1} +vandpd (%rax), %xmm17, %xmm19 {k1} +vandpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vandpd %xmm16, %xmm17, %xmm19 {z}{k1} +vandpd (%rax), %xmm17, %xmm19 {z}{k1} +vandpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vandpd %ymm16, %ymm17, %ymm19 +vandpd (%rax), %ymm17, %ymm19 +vandpd (%rax){1to4}, %ymm17, %ymm19 +vandpd %ymm16, %ymm17, %ymm19 {k1} +vandpd (%rax), %ymm17, %ymm19 {k1} +vandpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vandpd %ymm16, %ymm17, %ymm19 {z}{k1} +vandpd (%rax), %ymm17, %ymm19 {z}{k1} +vandpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vandps %xmm16, %xmm17, %xmm19 +vandps (%rax), %xmm17, %xmm19 +vandps (%rax){1to4}, %xmm17, %xmm19 +vandps %xmm16, %xmm17, %xmm19 {k1} +vandps (%rax), %xmm17, %xmm19 {k1} +vandps (%rax){1to4}, %xmm17, %xmm19 {k1} +vandps %xmm16, %xmm17, %xmm19 {z}{k1} +vandps (%rax), %xmm17, %xmm19 {z}{k1} +vandps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vandps %ymm16, %ymm17, %ymm19 +vandps (%rax), %ymm17, %ymm19 +vandps (%rax){1to8}, %ymm17, %ymm19 +vandps %ymm16, %ymm17, %ymm19 {k1} +vandps (%rax), %ymm17, %ymm19 {k1} +vandps (%rax){1to8}, %ymm17, %ymm19 {k1} +vandps %ymm16, %ymm17, %ymm19 {z}{k1} +vandps (%rax), %ymm17, %ymm19 {z}{k1} +vandps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vbroadcastf32x2 %xmm16, %ymm19 +vbroadcastf32x2 (%rax), %ymm19 +vbroadcastf32x2 %xmm16, %ymm19 {k1} +vbroadcastf32x2 (%rax), %ymm19 {k1} +vbroadcastf32x2 %xmm16, %ymm19 {z}{k1} +vbroadcastf32x2 (%rax), %ymm19 {z}{k1} + +vbroadcastf64x2 (%rax), %ymm19 +vbroadcastf64x2 (%rax), %ymm19 {k1} +vbroadcastf64x2 (%rax), %ymm19 {z}{k1} + +vbroadcasti32x2 %xmm16, %xmm19 +vbroadcasti32x2 (%rax), %xmm19 +vbroadcasti32x2 %xmm16, %xmm19 {k1} +vbroadcasti32x2 (%rax), %xmm19 {k1} +vbroadcasti32x2 %xmm16, %xmm19 {z}{k1} +vbroadcasti32x2 (%rax), %xmm19 {z}{k1} + +vbroadcasti32x2 %xmm16, %ymm19 +vbroadcasti32x2 (%rax), %ymm19 +vbroadcasti32x2 %xmm16, %ymm19 {k1} +vbroadcasti32x2 (%rax), %ymm19 {k1} +vbroadcasti32x2 %xmm16, %ymm19 {z}{k1} +vbroadcasti32x2 (%rax), %ymm19 {z}{k1} + +vbroadcasti64x2 (%rax), %ymm19 +vbroadcasti64x2 (%rax), %ymm19 {k1} +vbroadcasti64x2 (%rax), %ymm19 {z}{k1} + +vcvtpd2qq %xmm16, %xmm19 +vcvtpd2qq (%rax), %xmm19 +vcvtpd2qq (%rax){1to2}, %xmm19 +vcvtpd2qq %xmm16, %xmm19 {k1} +vcvtpd2qq (%rax), %xmm19 {k1} +vcvtpd2qq (%rax){1to2}, %xmm19 {k1} +vcvtpd2qq %xmm16, %xmm19 {z}{k1} +vcvtpd2qq (%rax), %xmm19 {z}{k1} +vcvtpd2qq (%rax){1to2}, %xmm19 {z}{k1} + +vcvtpd2qq %ymm16, %ymm19 +vcvtpd2qq (%rax), %ymm19 +vcvtpd2qq (%rax){1to4}, %ymm19 +vcvtpd2qq %ymm16, %ymm19 {k1} +vcvtpd2qq (%rax), %ymm19 {k1} +vcvtpd2qq (%rax){1to4}, %ymm19 {k1} +vcvtpd2qq %ymm16, %ymm19 {z}{k1} +vcvtpd2qq (%rax), %ymm19 {z}{k1} +vcvtpd2qq (%rax){1to4}, %ymm19 {z}{k1} + +vcvtpd2uqq %xmm16, %xmm19 +vcvtpd2uqq (%rax), %xmm19 +vcvtpd2uqq (%rax){1to2}, %xmm19 +vcvtpd2uqq %xmm16, %xmm19 {k1} +vcvtpd2uqq (%rax), %xmm19 {k1} +vcvtpd2uqq (%rax){1to2}, %xmm19 {k1} +vcvtpd2uqq %xmm16, %xmm19 {z}{k1} +vcvtpd2uqq (%rax), %xmm19 {z}{k1} +vcvtpd2uqq (%rax){1to2}, %xmm19 {z}{k1} + +vcvtpd2uqq %ymm16, %ymm19 +vcvtpd2uqq (%rax), %ymm19 +vcvtpd2uqq (%rax){1to4}, %ymm19 +vcvtpd2uqq %ymm16, %ymm19 {k1} +vcvtpd2uqq (%rax), %ymm19 {k1} +vcvtpd2uqq (%rax){1to4}, %ymm19 {k1} +vcvtpd2uqq %ymm16, %ymm19 {z}{k1} +vcvtpd2uqq (%rax), %ymm19 {z}{k1} +vcvtpd2uqq (%rax){1to4}, %ymm19 {z}{k1} + +vcvtps2qq %xmm16, %xmm19 +vcvtps2qq (%rax), %xmm19 +vcvtps2qq (%rax){1to2}, %xmm19 +vcvtps2qq %xmm16, %xmm19 {k1} +vcvtps2qq (%rax), %xmm19 {k1} +vcvtps2qq (%rax){1to2}, %xmm19 {k1} +vcvtps2qq %xmm16, %xmm19 {z}{k1} +vcvtps2qq (%rax), %xmm19 {z}{k1} +vcvtps2qq (%rax){1to2}, %xmm19 {z}{k1} + +vcvtps2qq %xmm16, %ymm19 +vcvtps2qq (%rax), %ymm19 +vcvtps2qq (%rax){1to4}, %ymm19 +vcvtps2qq %xmm16, %ymm19 {k1} +vcvtps2qq (%rax), %ymm19 {k1} +vcvtps2qq (%rax){1to4}, %ymm19 {k1} +vcvtps2qq %xmm16, %ymm19 {z}{k1} +vcvtps2qq (%rax), %ymm19 {z}{k1} +vcvtps2qq (%rax){1to4}, %ymm19 {z}{k1} + +vcvtps2uqq %xmm16, %xmm19 +vcvtps2uqq (%rax), %xmm19 +vcvtps2uqq (%rax){1to2}, %xmm19 +vcvtps2uqq %xmm16, %xmm19 {k1} +vcvtps2uqq (%rax), %xmm19 {k1} +vcvtps2uqq (%rax){1to2}, %xmm19 {k1} +vcvtps2uqq %xmm16, %xmm19 {z}{k1} +vcvtps2uqq (%rax), %xmm19 {z}{k1} +vcvtps2uqq (%rax){1to2}, %xmm19 {z}{k1} + +vcvtps2uqq %xmm16, %ymm19 +vcvtps2uqq (%rax), %ymm19 +vcvtps2uqq (%rax){1to4}, %ymm19 +vcvtps2uqq %xmm16, %ymm19 {k1} +vcvtps2uqq (%rax), %ymm19 {k1} +vcvtps2uqq (%rax){1to4}, %ymm19 {k1} +vcvtps2uqq %xmm16, %ymm19 {z}{k1} +vcvtps2uqq (%rax), %ymm19 {z}{k1} +vcvtps2uqq (%rax){1to4}, %ymm19 {z}{k1} + +vcvtqq2pd %xmm16, %xmm19 +vcvtqq2pd (%rax), %xmm19 +vcvtqq2pd (%rax){1to2}, %xmm19 +vcvtqq2pd %xmm16, %xmm19 {k1} +vcvtqq2pd (%rax), %xmm19 {k1} +vcvtqq2pd (%rax){1to2}, %xmm19 {k1} +vcvtqq2pd %xmm16, %xmm19 {z}{k1} +vcvtqq2pd (%rax), %xmm19 {z}{k1} +vcvtqq2pd (%rax){1to2}, %xmm19 {z}{k1} + +vcvtqq2pd %ymm16, %ymm19 +vcvtqq2pd (%rax), %ymm19 +vcvtqq2pd (%rax){1to4}, %ymm19 +vcvtqq2pd %ymm16, %ymm19 {k1} +vcvtqq2pd (%rax), %ymm19 {k1} +vcvtqq2pd (%rax){1to4}, %ymm19 {k1} +vcvtqq2pd %ymm16, %ymm19 {z}{k1} +vcvtqq2pd (%rax), %ymm19 {z}{k1} +vcvtqq2pd (%rax){1to4}, %ymm19 {z}{k1} + +vcvtqq2ps %xmm16, %xmm19 +vcvtqq2psx (%rax), %xmm19 +vcvtqq2ps (%rax){1to2}, %xmm19 +vcvtqq2ps %xmm16, %xmm19 {k1} +vcvtqq2psx (%rax), %xmm19 {k1} +vcvtqq2ps (%rax){1to2}, %xmm19 {k1} +vcvtqq2ps %xmm16, %xmm19 {z}{k1} +vcvtqq2psx (%rax), %xmm19 {z}{k1} +vcvtqq2ps (%rax){1to2}, %xmm19 {z}{k1} + +vcvtqq2ps %ymm16, %xmm19 +vcvtqq2psx (%rax), %xmm19 +vcvtqq2ps (%rax){1to4}, %xmm19 +vcvtqq2ps %ymm16, %xmm19 {k1} +vcvtqq2psx (%rax), %xmm19 {k1} +vcvtqq2ps (%rax){1to4}, %xmm19 {k1} +vcvtqq2ps %ymm16, %xmm19 {z}{k1} +vcvtqq2psx (%rax), %xmm19 {z}{k1} +vcvtqq2ps (%rax){1to4}, %xmm19 {z}{k1} + +vcvttpd2qq %xmm16, %xmm19 +vcvttpd2qq (%rax), %xmm19 +vcvttpd2qq (%rax){1to2}, %xmm19 +vcvttpd2qq %xmm16, %xmm19 {k1} +vcvttpd2qq (%rax), %xmm19 {k1} +vcvttpd2qq (%rax){1to2}, %xmm19 {k1} +vcvttpd2qq %xmm16, %xmm19 {z}{k1} +vcvttpd2qq (%rax), %xmm19 {z}{k1} +vcvttpd2qq (%rax){1to2}, %xmm19 {z}{k1} + +vcvttpd2qq %ymm16, %ymm19 +vcvttpd2qq (%rax), %ymm19 +vcvttpd2qq (%rax){1to4}, %ymm19 +vcvttpd2qq %ymm16, %ymm19 {k1} +vcvttpd2qq (%rax), %ymm19 {k1} +vcvttpd2qq (%rax){1to4}, %ymm19 {k1} +vcvttpd2qq %ymm16, %ymm19 {z}{k1} +vcvttpd2qq (%rax), %ymm19 {z}{k1} +vcvttpd2qq (%rax){1to4}, %ymm19 {z}{k1} + +vcvttpd2uqq %xmm16, %xmm19 +vcvttpd2uqq (%rax), %xmm19 +vcvttpd2uqq (%rax){1to2}, %xmm19 +vcvttpd2uqq %xmm16, %xmm19 {k1} +vcvttpd2uqq (%rax), %xmm19 {k1} +vcvttpd2uqq (%rax){1to2}, %xmm19 {k1} +vcvttpd2uqq %xmm16, %xmm19 {z}{k1} +vcvttpd2uqq (%rax), %xmm19 {z}{k1} +vcvttpd2uqq (%rax){1to2}, %xmm19 {z}{k1} + +vcvttpd2uqq %ymm16, %ymm19 +vcvttpd2uqq (%rax), %ymm19 +vcvttpd2uqq (%rax){1to4}, %ymm19 +vcvttpd2uqq %ymm16, %ymm19 {k1} +vcvttpd2uqq (%rax), %ymm19 {k1} +vcvttpd2uqq (%rax){1to4}, %ymm19 {k1} +vcvttpd2uqq %ymm16, %ymm19 {z}{k1} +vcvttpd2uqq (%rax), %ymm19 {z}{k1} +vcvttpd2uqq (%rax){1to4}, %ymm19 {z}{k1} + +vcvttps2qq %xmm16, %xmm19 +vcvttps2qq (%rax), %xmm19 +vcvttps2qq (%rax){1to2}, %xmm19 +vcvttps2qq %xmm16, %xmm19 {k1} +vcvttps2qq (%rax), %xmm19 {k1} +vcvttps2qq (%rax){1to2}, %xmm19 {k1} +vcvttps2qq %xmm16, %xmm19 {z}{k1} +vcvttps2qq (%rax), %xmm19 {z}{k1} +vcvttps2qq (%rax){1to2}, %xmm19 {z}{k1} + +vcvttps2qq %xmm16, %ymm19 +vcvttps2qq (%rax), %ymm19 +vcvttps2qq (%rax){1to4}, %ymm19 +vcvttps2qq %xmm16, %ymm19 {k1} +vcvttps2qq (%rax), %ymm19 {k1} +vcvttps2qq (%rax){1to4}, %ymm19 {k1} +vcvttps2qq %xmm16, %ymm19 {z}{k1} +vcvttps2qq (%rax), %ymm19 {z}{k1} +vcvttps2qq (%rax){1to4}, %ymm19 {z}{k1} + +vcvttps2uqq %xmm16, %xmm19 +vcvttps2uqq (%rax), %xmm19 +vcvttps2uqq (%rax){1to2}, %xmm19 +vcvttps2uqq %xmm16, %xmm19 {k1} +vcvttps2uqq (%rax), %xmm19 {k1} +vcvttps2uqq (%rax){1to2}, %xmm19 {k1} +vcvttps2uqq %xmm16, %xmm19 {z}{k1} +vcvttps2uqq (%rax), %xmm19 {z}{k1} +vcvttps2uqq (%rax){1to2}, %xmm19 {z}{k1} + +vcvttps2uqq %xmm16, %ymm19 +vcvttps2uqq (%rax), %ymm19 +vcvttps2uqq (%rax){1to4}, %ymm19 +vcvttps2uqq %xmm16, %ymm19 {k1} +vcvttps2uqq (%rax), %ymm19 {k1} +vcvttps2uqq (%rax){1to4}, %ymm19 {k1} +vcvttps2uqq %xmm16, %ymm19 {z}{k1} +vcvttps2uqq (%rax), %ymm19 {z}{k1} +vcvttps2uqq (%rax){1to4}, %ymm19 {z}{k1} + +vcvtuqq2pd %xmm16, %xmm19 +vcvtuqq2pd (%rax), %xmm19 +vcvtuqq2pd (%rax){1to2}, %xmm19 +vcvtuqq2pd %xmm16, %xmm19 {k1} +vcvtuqq2pd (%rax), %xmm19 {k1} +vcvtuqq2pd (%rax){1to2}, %xmm19 {k1} +vcvtuqq2pd %xmm16, %xmm19 {z}{k1} +vcvtuqq2pd (%rax), %xmm19 {z}{k1} +vcvtuqq2pd (%rax){1to2}, %xmm19 {z}{k1} + +vcvtuqq2pd %ymm16, %ymm19 +vcvtuqq2pd (%rax), %ymm19 +vcvtuqq2pd (%rax){1to4}, %ymm19 +vcvtuqq2pd %ymm16, %ymm19 {k1} +vcvtuqq2pd (%rax), %ymm19 {k1} +vcvtuqq2pd (%rax){1to4}, %ymm19 {k1} +vcvtuqq2pd %ymm16, %ymm19 {z}{k1} +vcvtuqq2pd (%rax), %ymm19 {z}{k1} +vcvtuqq2pd (%rax){1to4}, %ymm19 {z}{k1} + +vcvtuqq2ps %xmm16, %xmm19 +vcvtuqq2psx (%rax), %xmm19 +vcvtuqq2ps (%rax){1to2}, %xmm19 +vcvtuqq2ps %xmm16, %xmm19 {k1} +vcvtuqq2psx (%rax), %xmm19 {k1} +vcvtuqq2ps (%rax){1to2}, %xmm19 {k1} +vcvtuqq2ps %xmm16, %xmm19 {z}{k1} +vcvtuqq2psx (%rax), %xmm19 {z}{k1} +vcvtuqq2ps (%rax){1to2}, %xmm19 {z}{k1} + +vcvtuqq2ps %ymm16, %xmm19 +vcvtuqq2psx (%rax), %xmm19 +vcvtuqq2ps (%rax){1to4}, %xmm19 +vcvtuqq2ps %ymm16, %xmm19 {k1} +vcvtuqq2psx (%rax), %xmm19 {k1} +vcvtuqq2ps (%rax){1to4}, %xmm19 {k1} +vcvtuqq2ps %ymm16, %xmm19 {z}{k1} +vcvtuqq2psx (%rax), %xmm19 {z}{k1} +vcvtuqq2ps (%rax){1to4}, %xmm19 {z}{k1} + +vextractf64x2 $1, %ymm16, %xmm19 +vextractf64x2 $1, %ymm16, (%rax) +vextractf64x2 $1, %ymm16, %xmm19 {k1} +vextractf64x2 $1, %ymm16, (%rax) {k1} +vextractf64x2 $1, %ymm16, %xmm19 {z}{k1} + +vextracti64x2 $1, %ymm16, %xmm19 +vextracti64x2 $1, %ymm16, (%rax) +vextracti64x2 $1, %ymm16, %xmm19 {k1} +vextracti64x2 $1, %ymm16, (%rax) {k1} +vextracti64x2 $1, %ymm16, %xmm19 {z}{k1} + +vfpclasspd $0xab, %xmm16, %k1 +vfpclasspdx $0xab, (%rax), %k1 +vfpclasspdx $0xab, (%rax){1to2}, %k1 +vfpclasspd $0xab, %xmm16, %k1 {k2} +vfpclasspdx $0xab, (%rax), %k1 {k2} +vfpclasspdx $0xab, (%rax){1to2}, %k1 {k2} + +vfpclasspd $0xab, %ymm16, %k1 +vfpclasspdy $0xab, (%rax), %k1 +vfpclasspdy $0xab, (%rax){1to4}, %k1 +vfpclasspd $0xab, %ymm16, %k1 {k2} +vfpclasspdy $0xab, (%rax), %k1 {k2} +vfpclasspdy $0xab, (%rax){1to4}, %k1 {k2} + +vfpclassps $0xab, %xmm16, %k1 +vfpclasspsx $0xab, (%rax), %k1 +vfpclasspsx $0xab, (%rax){1to4}, %k1 +vfpclassps $0xab, %xmm16, %k1 {k2} +vfpclasspsx $0xab, (%rax), %k1 {k2} +vfpclasspsx $0xab, (%rax){1to4}, %k1 {k2} + +vfpclassps $0xab, %ymm16, %k1 +vfpclasspsy $0xab, (%rax), %k1 +vfpclasspsy $0xab, (%rax){1to8}, %k1 +vfpclassps $0xab, %ymm16, %k1 {k2} +vfpclasspsy $0xab, (%rax), %k1 {k2} +vfpclasspsy $0xab, (%rax){1to8}, %k1 {k2} + +vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 +vinsertf64x2 $1, (%rax), %ymm16, %ymm19 +vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {k1} +vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {k1} +vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {z}{k1} +vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {z}{k1} + +vinserti64x2 $1, %xmm16, %ymm16, %ymm19 +vinserti64x2 $1, (%rax), %ymm16, %ymm19 +vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {k1} +vinserti64x2 $1, (%rax), %ymm16, %ymm19 {k1} +vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {z}{k1} +vinserti64x2 $1, (%rax), %ymm16, %ymm19 {z}{k1} + +vpmovm2d %k0, %xmm0 +vpmovm2q %k0, %xmm0 + +vpmovm2d %k0, %ymm0 +vpmovm2q %k0, %ymm0 + +vpmovd2m %xmm0, %k0 +vpmovq2m %xmm0, %k0 + +vpmovd2m %ymm0, %k0 +vpmovq2m %ymm0, %k0 + +vorpd %xmm16, %xmm17, %xmm19 +vorpd (%rax), %xmm17, %xmm19 +vorpd (%rax){1to2}, %xmm17, %xmm19 +vorpd %xmm16, %xmm17, %xmm19 {k1} +vorpd (%rax), %xmm17, %xmm19 {k1} +vorpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vorpd %xmm16, %xmm17, %xmm19 {z}{k1} +vorpd (%rax), %xmm17, %xmm19 {z}{k1} +vorpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vorpd %ymm16, %ymm17, %ymm19 +vorpd (%rax), %ymm17, %ymm19 +vorpd (%rax){1to4}, %ymm17, %ymm19 +vorpd %ymm16, %ymm17, %ymm19 {k1} +vorpd (%rax), %ymm17, %ymm19 {k1} +vorpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vorpd %ymm16, %ymm17, %ymm19 {z}{k1} +vorpd (%rax), %ymm17, %ymm19 {z}{k1} +vorpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vorps %xmm16, %xmm17, %xmm19 +vorps (%rax), %xmm17, %xmm19 +vorps (%rax){1to4}, %xmm17, %xmm19 +vorps %xmm16, %xmm17, %xmm19 {k1} +vorps (%rax), %xmm17, %xmm19 {k1} +vorps (%rax){1to4}, %xmm17, %xmm19 {k1} +vorps %xmm16, %xmm17, %xmm19 {z}{k1} +vorps (%rax), %xmm17, %xmm19 {z}{k1} +vorps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vorps %ymm16, %ymm17, %ymm19 +vorps (%rax), %ymm17, %ymm19 +vorps (%rax){1to8}, %ymm17, %ymm19 +vorps %ymm16, %ymm17, %ymm19 {k1} +vorps (%rax), %ymm17, %ymm19 {k1} +vorps (%rax){1to8}, %ymm17, %ymm19 {k1} +vorps %ymm16, %ymm17, %ymm19 {z}{k1} +vorps (%rax), %ymm17, %ymm19 {z}{k1} +vorps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpmullq %xmm16, %xmm17, %xmm19 +vpmullq (%rax), %xmm17, %xmm19 +vpmullq %xmm16, %xmm17, %xmm19 {k1} +vpmullq (%rax), %xmm17, %xmm19 {k1} +vpmullq %xmm16, %xmm17, %xmm19 {z}{k1} +vpmullq (%rax), %xmm17, %xmm19 {z}{k1} + +vpmullq %ymm16, %ymm17, %ymm19 +vpmullq (%rax), %ymm17, %ymm19 +vpmullq %ymm16, %ymm17, %ymm19 {k1} +vpmullq (%rax), %ymm17, %ymm19 {k1} +vpmullq %ymm16, %ymm17, %ymm19 {z}{k1} +vpmullq (%rax), %ymm17, %ymm19 {z}{k1} + +vrangepd $ab, %xmm16, %xmm17, %xmm19 +vrangepd $ab, (%rax), %xmm17, %xmm19 +vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 +vrangepd $ab, %xmm16, %xmm17, %xmm19 {k1} +vrangepd $ab, (%rax), %xmm17, %xmm19 {k1} +vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {k1} +vrangepd $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vrangepd $ab, (%rax), %xmm17, %xmm19 {z}{k1} +vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vrangepd $ab, %ymm16, %ymm17, %ymm19 +vrangepd $ab, (%rax), %ymm17, %ymm19 +vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 +vrangepd $ab, %ymm16, %ymm17, %ymm19 {k1} +vrangepd $ab, (%rax), %ymm17, %ymm19 {k1} +vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {k1} +vrangepd $ab, %ymm16, %ymm17, %ymm19 {z}{k1} +vrangepd $ab, (%rax), %ymm17, %ymm19 {z}{k1} +vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vrangeps $ab, %xmm16, %xmm17, %xmm19 +vrangeps $ab, (%rax), %xmm17, %xmm19 +vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 +vrangeps $ab, %xmm16, %xmm17, %xmm19 {k1} +vrangeps $ab, (%rax), %xmm17, %xmm19 {k1} +vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {k1} +vrangeps $ab, %xmm16, %xmm17, %xmm19 {z}{k1} +vrangeps $ab, (%rax), %xmm17, %xmm19 {z}{k1} +vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vrangeps $ab, %ymm16, %ymm17, %ymm19 +vrangeps $ab, (%rax), %ymm17, %ymm19 +vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 +vrangeps $ab, %ymm16, %ymm17, %ymm19 {k1} +vrangeps $ab, (%rax), %ymm17, %ymm19 {k1} +vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {k1} +vrangeps $ab, %ymm16, %ymm17, %ymm19 {z}{k1} +vrangeps $ab, (%rax), %ymm17, %ymm19 {z}{k1} +vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vreducepd $ab, %xmm16, %xmm19 +vreducepd $ab, (%rax), %xmm19 +vreducepd $ab, (%rax){1to2}, %xmm19 +vreducepd $ab, %xmm16, %xmm19 {k1} +vreducepd $ab, (%rax), %xmm19 {k1} +vreducepd $ab, (%rax){1to2}, %xmm19 {k1} +vreducepd $ab, %xmm16, %xmm19 {z}{k1} +vreducepd $ab, (%rax), %xmm19 {z}{k1} +vreducepd $ab, (%rax){1to2}, %xmm19 {z}{k1} + +vreducepd $ab, %ymm16, %ymm19 +vreducepd $ab, (%rax), %ymm19 +vreducepd $ab, (%rax){1to4}, %ymm19 +vreducepd $ab, %ymm16, %ymm19 {k1} +vreducepd $ab, (%rax), %ymm19 {k1} +vreducepd $ab, (%rax){1to4}, %ymm19 {k1} +vreducepd $ab, %ymm16, %ymm19 {z}{k1} +vreducepd $ab, (%rax), %ymm19 {z}{k1} +vreducepd $ab, (%rax){1to4}, %ymm19 {z}{k1} + +vreduceps $ab, %xmm16, %xmm19 +vreduceps $ab, (%rax), %xmm19 +vreduceps $ab, (%rax){1to4}, %xmm19 +vreduceps $ab, %xmm16, %xmm19 {k1} +vreduceps $ab, (%rax), %xmm19 {k1} +vreduceps $ab, (%rax){1to4}, %xmm19 {k1} +vreduceps $ab, %xmm16, %xmm19 {z}{k1} +vreduceps $ab, (%rax), %xmm19 {z}{k1} +vreduceps $ab, (%rax){1to4}, %xmm19 {z}{k1} + +vreduceps $ab, %ymm16, %ymm19 +vreduceps $ab, (%rax), %ymm19 +vreduceps $ab, (%rax){1to8}, %ymm19 +vreduceps $ab, %ymm16, %ymm19 {k1} +vreduceps $ab, (%rax), %ymm19 {k1} +vreduceps $ab, (%rax){1to8}, %ymm19 {k1} +vreduceps $ab, %ymm16, %ymm19 {z}{k1} +vreduceps $ab, (%rax), %ymm19 {z}{k1} +vreduceps $ab, (%rax){1to8}, %ymm19 {z}{k1} + +vxorpd %xmm16, %xmm17, %xmm19 +vxorpd (%rax), %xmm17, %xmm19 +vxorpd (%rax){1to2}, %xmm17, %xmm19 +vxorpd %xmm16, %xmm17, %xmm19 {k1} +vxorpd (%rax), %xmm17, %xmm19 {k1} +vxorpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vxorpd %xmm16, %xmm17, %xmm19 {z}{k1} +vxorpd (%rax), %xmm17, %xmm19 {z}{k1} +vxorpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vxorpd %ymm16, %ymm17, %ymm19 +vxorpd (%rax), %ymm17, %ymm19 +vxorpd (%rax){1to4}, %ymm17, %ymm19 +vxorpd %ymm16, %ymm17, %ymm19 {k1} +vxorpd (%rax), %ymm17, %ymm19 {k1} +vxorpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vxorpd %ymm16, %ymm17, %ymm19 {z}{k1} +vxorpd (%rax), %ymm17, %ymm19 {z}{k1} +vxorpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vxorps %xmm16, %xmm17, %xmm19 +vxorps (%rax), %xmm17, %xmm19 +vxorps (%rax){1to4}, %xmm17, %xmm19 +vxorps %xmm16, %xmm17, %xmm19 {k1} +vxorps (%rax), %xmm17, %xmm19 {k1} +vxorps (%rax){1to4}, %xmm17, %xmm19 {k1} +vxorps %xmm16, %xmm17, %xmm19 {z}{k1} +vxorps (%rax), %xmm17, %xmm19 {z}{k1} +vxorps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vxorps %ymm16, %ymm17, %ymm19 +vxorps (%rax), %ymm17, %ymm19 +vxorps (%rax){1to8}, %ymm17, %ymm19 +vxorps %ymm16, %ymm17, %ymm19 {k1} +vxorps (%rax), %ymm17, %ymm19 {k1} +vxorps (%rax){1to8}, %ymm17, %ymm19 {k1} +vxorps %ymm16, %ymm17, %ymm19 {z}{k1} +vxorps (%rax), %ymm17, %ymm19 {z}{k1} +vxorps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandnpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandnpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandnps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vandnps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandnps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandnps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandnps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vandnps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandnps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandnps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vandpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vandpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vandps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vandps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vandps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vandps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vandps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vandps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vandps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vandps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vandps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vandps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastf32x2 (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcastf32x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastf32x2 %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vbroadcastf32x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf64x2 (%rax), %ymm19 +# CHECK-NEXT: 2 9 0.33 * vbroadcastf64x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcastf64x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vbroadcasti32x2 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vbroadcasti32x2 (%rax), %xmm19 +# CHECK-NEXT: 1 1 1.00 vbroadcasti32x2 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vbroadcasti32x2 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vbroadcasti32x2 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vbroadcasti32x2 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcasti32x2 (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcasti32x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcasti32x2 %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vbroadcasti32x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti64x2 (%rax), %ymm19 +# CHECK-NEXT: 2 9 0.33 * vbroadcasti64x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcasti64x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtpd2qq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtpd2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtpd2uqq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtpd2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtps2qq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtps2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtps2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2qq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtps2uqq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtps2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtps2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2uqq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtqq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtqq2pd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtqq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtqq2ps %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtqq2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtqq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtqq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %ymm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtqq2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtqq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttpd2qq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttpd2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttpd2uqq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttpd2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvttps2qq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvttps2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvttps2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttps2qq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvttps2uqq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvttps2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvttps2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttps2uqq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtuqq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtuqq2pd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtuqq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtuqq2ps %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtuqq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtuqq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %ymm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtuqq2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtuqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtuqq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %ymm16, %xmm19 +# CHECK-NEXT: 2 12 0.50 vextractf64x2 $1, %ymm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextractf64x2 $1, %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextractf64x2 $1, %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %ymm16, %xmm19 +# CHECK-NEXT: 2 12 0.50 vextracti64x2 $1, %ymm16, (%rax) +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vextracti64x2 $1, %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 3 1.00 vextracti64x2 $1, %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %xmm16, %k1 +# CHECK-NEXT: 2 9 1.00 * vfpclasspdx $171, (%rax), %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclasspd $171, (%rax){1to2}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspdx $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspd $171, (%rax){1to2}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %ymm16, %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclasspdy $171, (%rax), %k1 +# CHECK-NEXT: 2 11 1.00 * vfpclasspd $171, (%rax){1to4}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclasspd $171, %ymm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspdy $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspd $171, (%rax){1to4}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %xmm16, %k1 +# CHECK-NEXT: 2 9 1.00 * vfpclasspsx $171, (%rax), %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclassps $171, (%rax){1to4}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspsx $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclassps $171, (%rax){1to4}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %ymm16, %k1 +# CHECK-NEXT: 2 10 1.00 * vfpclasspsy $171, (%rax), %k1 +# CHECK-NEXT: 2 11 1.00 * vfpclassps $171, (%rax){1to8}, %k1 +# CHECK-NEXT: 1 3 1.00 vfpclassps $171, %ymm16, %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclasspsy $171, (%rax), %k1 {%k2} +# CHECK-NEXT: 2 3 1.00 * vfpclassps $171, (%rax){1to8}, %k1 {%k2} +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vinsertf64x2 $1, (%rax), %ymm16, %ymm19 +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vinserti64x2 $1, (%rax), %ymm16, %ymm19 +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vinserti64x2 $1, (%rax), %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vinserti64x2 $1, (%rax), %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpmovm2d %k0, %xmm0 +# CHECK-NEXT: 1 1 0.33 vpmovm2q %k0, %xmm0 +# CHECK-NEXT: 1 1 0.33 vpmovm2d %k0, %ymm0 +# CHECK-NEXT: 1 1 0.33 vpmovm2q %k0, %ymm0 +# CHECK-NEXT: 1 3 1.00 vpmovd2m %xmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovq2m %xmm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovd2m %ymm0, %k0 +# CHECK-NEXT: 1 3 1.00 vpmovq2m %ymm0, %k0 +# CHECK-NEXT: 1 1 0.33 vorpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vorpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vorpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vorpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vorpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vorpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vorps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vorps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vorps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vorps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vorps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vorps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vorps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vorps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vorps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vorps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vorps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vorps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vorps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vorps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vorps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vorps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vorps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vorps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.50 vpmullq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 15 1.50 vpmullq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.50 vpmullq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.50 vpmullq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 15 1.50 vpmullq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 15 1.50 vpmullq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 4 23 1.50 * vpmullq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangepd $ab, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vrangeps $ab, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreducepd $ab, (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreducepd $ab, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vreducepd $ab, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vreduceps $ab, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vreduceps $ab, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vreduceps $ab, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vxorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vxorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vxorps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vxorps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vxorps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vxorps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vxorps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vxorps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vxorps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vxorps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 220.67 216.67 110.33 110.33 2.00 159.67 - 2.00 2.00 2.00 - 110.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandnps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandnps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vandps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vandps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf32x2 (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf32x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastf32x2 %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf32x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf64x2 (%rax), %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf64x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf64x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x2 (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x2 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x2 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x2 (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcasti32x2 %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti64x2 (%rax), %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti64x2 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti64x2 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2qq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtpd2uqq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtpd2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2qq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2uqq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtqq2pd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtqq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtqq2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtqq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2qq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttpd2uqq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttpd2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2qq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2qq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttps2uqq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2uqq (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtuqq2pd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtuqq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtuqq2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtuqq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %ymm16, %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf64x2 $1, %ymm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %ymm16, %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextractf64x2 $1, %ymm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextractf64x2 $1, %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %ymm16, %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti64x2 $1, %ymm16, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %ymm16, %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vextracti64x2 $1, %ymm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vextracti64x2 $1, %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %xmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdx $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to2}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdx $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to2}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %ymm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdy $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to4}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclasspd $171, %ymm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspdy $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspd $171, (%rax){1to4}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %xmm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsx $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to4}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %xmm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsx $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to4}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %ymm16, %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsy $171, (%rax), %k1 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to8}, %k1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vfpclassps $171, %ymm16, %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclasspsy $171, (%rax), %k1 {%k2} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vfpclassps $171, (%rax){1to8}, %k1 {%k2} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %ymm16, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinsertf64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinsertf64x2 $1, (%rax), %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %ymm16, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinserti64x2 $1, (%rax), %ymm16, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinserti64x2 $1, (%rax), %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vinserti64x2 $1, %xmm16, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vinserti64x2 $1, (%rax), %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2d %k0, %xmm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2q %k0, %xmm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2d %k0, %ymm0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpmovm2q %k0, %ymm0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovd2m %xmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovq2m %xmm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovd2m %ymm0, %k0 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmovq2m %ymm0, %k0 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vorps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vorps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.50 1.50 - - - - - - - - - - - vpmullq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.50 1.50 0.33 0.33 - - - - - - - 0.33 - vpmullq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangepd $ab, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangepd $ab, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vrangeps $ab, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vrangeps $ab, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreducepd $ab, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreducepd $ab, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vreduceps $ab, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vreduceps $ab, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vxorps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vxorps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfni.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfni.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfni.s @@ -0,0 +1,109 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 +vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 +vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 +vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {k1} +vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {k1} +vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {k1} +vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 {z}{k1} +vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 {z}{k1} +vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 {z}{k1} + +vgf2p8mulb %zmm16, %zmm17, %zmm19 +vgf2p8mulb (%rax), %zmm17, %zmm19 +vgf2p8mulb %zmm16, %zmm17, %zmm19 {k1} +vgf2p8mulb (%rax), %zmm17, %zmm19 {k1} +vgf2p8mulb %zmm16, %zmm17, %zmm19 {z}{k1} +vgf2p8mulb (%rax), %zmm17, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 1.00 vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 9 1.00 vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 10 1.00 vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 10 1.00 vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 15 1.00 * vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vgf2p8mulb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vgf2p8mulb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 9 1.00 vgf2p8mulb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 15 1.00 * vgf2p8mulb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 10 1.00 vgf2p8mulb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 15 1.00 * vgf2p8mulb (%rax), %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 24.00 - 5.00 5.00 - - - - - - - 5.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineinvqb $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8affineqb $0, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8mulb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8mulb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vgf2p8mulb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfnivl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfnivl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512gfnivl.s @@ -0,0 +1,184 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 +vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 +vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 +vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {k1} +vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {k1} +vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {k1} +vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 +vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 +vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 +vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {k1} +vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {k1} +vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {k1} +vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {z}{k1} +vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 {z}{k1} +vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 {z}{k1} +vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 {z}{k1} +vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vgf2p8mulb %xmm16, %xmm17, %xmm19 +vgf2p8mulb (%rax), %xmm17, %xmm19 +vgf2p8mulb %xmm16, %xmm17, %xmm19 {k1} +vgf2p8mulb (%rax), %xmm17, %xmm19 {k1} +vgf2p8mulb %xmm16, %xmm17, %xmm19 {z}{k1} +vgf2p8mulb (%rax), %xmm17, %xmm19 {z}{k1} + +vgf2p8mulb %ymm16, %ymm17, %ymm19 +vgf2p8mulb (%rax), %ymm17, %ymm19 +vgf2p8mulb %ymm16, %ymm17, %ymm19 {k1} +vgf2p8mulb (%rax), %ymm17, %ymm19 {k1} +vgf2p8mulb %ymm16, %ymm17, %ymm19 {z}{k1} +vgf2p8mulb (%rax), %ymm17, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 9 0.50 vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 10 0.50 vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 9 0.50 vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 10 0.50 vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 10 0.50 vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 10 0.50 vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vgf2p8mulb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8mulb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 9 0.50 vgf2p8mulb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8mulb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 10 0.50 vgf2p8mulb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8mulb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vgf2p8mulb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vgf2p8mulb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 9 0.50 vgf2p8mulb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 15 0.50 * vgf2p8mulb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 10 0.50 vgf2p8mulb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 15 0.50 * vgf2p8mulb (%rax), %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 24.00 24.00 10.00 10.00 - - - - - - - 10.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifma.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifma.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifma.s @@ -0,0 +1,90 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpmadd52huq %zmm16, %zmm17, %zmm19 +vpmadd52huq (%rdi), %zmm17, %zmm19 +vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 +vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} +vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} +vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} {z} +vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} {z} +vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} + +vpmadd52luq %zmm16, %zmm17, %zmm19 +vpmadd52luq (%rdi), %zmm17, %zmm19 +vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 +vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} +vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} +vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} {z} +vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} {z} +vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 4 1.00 vpmadd52huq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 4 1.00 vpmadd52luq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi), %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 4 1.00 vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 4 1.00 vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 12 1.00 * vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 18.00 - 4.00 4.00 - - - - - - - 4.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52huq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52huq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52luq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpmadd52luq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to8}, %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifmavl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifmavl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512ifmavl.s @@ -0,0 +1,146 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpmadd52huq %xmm16, %xmm17, %xmm19 +vpmadd52huq (%rdi), %xmm17, %xmm19 +vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 +vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} +vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} +vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} {z} +vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} {z} +vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} + +vpmadd52huq %ymm16, %ymm17, %ymm19 +vpmadd52huq (%rdi), %ymm17, %ymm19 +vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 +vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} +vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} +vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} {z} +vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} {z} +vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} + +vpmadd52luq %xmm16, %xmm17, %xmm19 +vpmadd52luq (%rdi), %xmm17, %xmm19 +vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 +vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} +vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} +vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} {z} +vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} {z} +vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} + +vpmadd52luq %ymm16, %ymm17, %ymm19 +vpmadd52luq (%rdi), %ymm17, %ymm19 +vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 +vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} +vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} +vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} {z} +vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} {z} +vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 18.00 18.00 8.00 8.00 - - - - - - - 8.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52huq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52huq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpmadd52luq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpmadd52luq (%rdi){1to4}, %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaes.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaes.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaes.s @@ -0,0 +1,62 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vaesdec %zmm16, %zmm17, %zmm19 +vaesdec (%rax), %zmm17, %zmm19 + +vaesdeclast %zmm16, %zmm17, %zmm19 +vaesdeclast (%rax), %zmm17, %zmm19 + +vaesenc %zmm16, %zmm17, %zmm19 +vaesenc (%rax), %zmm17, %zmm19 + +vaesenclast %zmm16, %zmm17, %zmm19 +vaesenclast (%rax), %zmm17, %zmm19 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 1.00 vaesdec %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vaesdec (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vaesdeclast %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vaesdeclast (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vaesenc %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vaesenc (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vaesenclast %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 12 1.00 * vaesenclast (%rax), %zmm17, %zmm19 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 8.00 - 1.33 1.33 - - - - - - - 1.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vaesdec %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vaesdec (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vaesdeclast %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vaesdeclast (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vaesenc %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vaesenc (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vaesenclast %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vaesenclast (%rax), %zmm17, %zmm19 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaesvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaesvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vaesvl.s @@ -0,0 +1,90 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vaesdec %xmm16, %xmm17, %xmm19 +vaesdec (%rax), %xmm17, %xmm19 + +vaesdec %ymm16, %ymm17, %ymm19 +vaesdec (%rax), %ymm17, %ymm19 + +vaesdeclast %xmm16, %xmm17, %xmm19 +vaesdeclast (%rax), %xmm17, %xmm19 + +vaesdeclast %ymm16, %ymm17, %ymm19 +vaesdeclast (%rax), %ymm17, %ymm19 + +vaesenc %xmm16, %xmm17, %xmm19 +vaesenc (%rax), %xmm17, %xmm19 + +vaesenc %ymm16, %ymm17, %ymm19 +vaesenc (%rax), %ymm17, %ymm19 + +vaesenclast %xmm16, %xmm17, %xmm19 +vaesenclast (%rax), %xmm17, %xmm19 + +vaesenclast %ymm16, %ymm17, %ymm19 +vaesenclast (%rax), %ymm17, %ymm19 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vaesdec %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vaesdec (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vaesdec %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vaesdec (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vaesdeclast %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vaesdeclast (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vaesdeclast %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vaesdeclast (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vaesenc %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vaesenc (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vaesenc %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vaesenc (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vaesenclast %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 12 0.50 * vaesenclast (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vaesenclast %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vaesenclast (%rax), %ymm17, %ymm19 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 8.00 8.00 2.67 2.67 - - - - - - - 2.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdec %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdec (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdec %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdec (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdeclast %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdeclast (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdeclast %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdeclast (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenc %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenc (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenc %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenc (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenclast %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenclast (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenclast %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenclast (%rax), %ymm17, %ymm19 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi.s @@ -0,0 +1,119 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpermb %zmm16, %zmm17, %zmm19 +vpermb (%rax), %zmm17, %zmm19 +vpermb %zmm16, %zmm17, %zmm19 {k1} +vpermb (%rax), %zmm17, %zmm19 {k1} +vpermb %zmm16, %zmm17, %zmm19 {k1}{z} +vpermb (%rax), %zmm17, %zmm19 {k1}{z} + +vpermi2b %zmm16, %zmm17, %zmm19 +vpermi2b (%rax), %zmm17, %zmm19 +vpermi2b %zmm16, %zmm17, %zmm19 {k1} +vpermi2b (%rax), %zmm17, %zmm19 {k1} +vpermi2b %zmm16, %zmm17, %zmm19 {k1}{z} +vpermi2b (%rax), %zmm17, %zmm19 {k1}{z} + +vpermt2b %zmm16, %zmm17, %zmm19 +vpermt2b (%rax), %zmm17, %zmm19 +vpermt2b %zmm16, %zmm17, %zmm19 {k1} +vpermt2b (%rax), %zmm17, %zmm19 {k1} +vpermt2b %zmm16, %zmm17, %zmm19 {k1}{z} +vpermt2b (%rax), %zmm17, %zmm19 {k1}{z} + +vpmultishiftqb %zmm16, %zmm17, %zmm19 +vpmultishiftqb (%rax), %zmm17, %zmm19 +vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 +vpmultishiftqb %zmm16, %zmm17, %zmm19 {k1} +vpmultishiftqb (%rax), %zmm17, %zmm19 {k1} +vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {k1} +vpmultishiftqb %zmm16, %zmm17, %zmm19 {k1}{z} +vpmultishiftqb (%rax), %zmm17, %zmm19 {k1}{z} +vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {k1}{z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpermb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpermb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpermb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpermb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermi2b %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 12 2.00 * vpermi2b (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 7 2.00 vpermi2b %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 14 2.00 * vpermi2b (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermi2b %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 14 2.00 * vpermi2b (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermt2b %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 4 12 2.00 * vpermt2b (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 3 7 2.00 vpermt2b %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 4 14 2.00 * vpermt2b (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermt2b %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 4 14 2.00 * vpermt2b (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmultishiftqb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmultishiftqb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 6.00 - 5.00 5.00 - 45.00 - - - - - 5.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2b %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2b (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2b %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2b (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermi2b %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermi2b (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2b %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2b (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2b %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2b (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - vpermt2b %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - vpermt2b (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2.s @@ -0,0 +1,398 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpcompressb %zmm16, %zmm19 +vpcompressb %zmm16, (%rax) +vpcompressb %zmm16, %zmm19 {k1} +vpcompressb %zmm16, (%rax) {k1} +vpcompressb %zmm16, %zmm19 {k1}{z} + +vpcompressw %zmm16, %zmm19 +vpcompressw %zmm16, (%rax) +vpcompressw %zmm16, %zmm19 {k1} +vpcompressw %zmm16, (%rax) {k1} +vpcompressw %zmm16, %zmm19 {k1}{z} + +vpexpandb %zmm16, %zmm19 +vpexpandb (%rax), %zmm19 +vpexpandb %zmm16, %zmm19 {k1} +vpexpandb (%rax), %zmm19 {k1} +vpexpandb %zmm16, %zmm19 {k1}{z} + +vpexpandw %zmm16, %zmm19 +vpexpandw (%rax), %zmm19 +vpexpandw %zmm16, %zmm19 {k1} +vpexpandw (%rax), %zmm19 {k1} +vpexpandw %zmm16, %zmm19 {k1}{z} + +vpshldd $1, %zmm16, %zmm17, %zmm19 +vpshldd $1, (%rax), %zmm17, %zmm19 +vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 +vpshldd $1, %zmm16, %zmm17, %zmm19 {k1} +vpshldd $1, (%rax), %zmm17, %zmm19 {k1} +vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {k1} +vpshldd $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldd $1, (%rax), %zmm17, %zmm19 {k1}{z} +vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {k1}{z} + +vpshldq $1, %zmm16, %zmm17, %zmm19 +vpshldq $1, (%rax), %zmm17, %zmm19 +vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 +vpshldq $1, %zmm16, %zmm17, %zmm19 {k1} +vpshldq $1, (%rax), %zmm17, %zmm19 {k1} +vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {k1} +vpshldq $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldq $1, (%rax), %zmm17, %zmm19 {k1}{z} +vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {k1}{z} + +vpshldvd %zmm16, %zmm17, %zmm19 +vpshldvd (%rax), %zmm17, %zmm19 +vpshldvd (%rax){1to16}, %zmm17, %zmm19 +vpshldvd %zmm16, %zmm17, %zmm19 {k1} +vpshldvd (%rax), %zmm17, %zmm19 {k1} +vpshldvd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpshldvd %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldvd (%rax), %zmm17, %zmm19 {k1}{z} +vpshldvd (%rax){1to16}, %zmm17, %zmm19 {k1}{z} + +vpshldvq %zmm16, %zmm17, %zmm19 +vpshldvq (%rax), %zmm17, %zmm19 +vpshldvq (%rax){1to8}, %zmm17, %zmm19 +vpshldvq %zmm16, %zmm17, %zmm19 {k1} +vpshldvq (%rax), %zmm17, %zmm19 {k1} +vpshldvq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpshldvq %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldvq (%rax), %zmm17, %zmm19 {k1}{z} +vpshldvq (%rax){1to8}, %zmm17, %zmm19 {k1}{z} + +vpshldvw %zmm16, %zmm17, %zmm19 +vpshldvw (%rax), %zmm17, %zmm19 +vpshldvw %zmm16, %zmm17, %zmm19 {k1} +vpshldvw (%rax), %zmm17, %zmm19 {k1} +vpshldvw %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldvw (%rax), %zmm17, %zmm19 {k1}{z} + +vpshldw $1, %zmm16, %zmm17, %zmm19 +vpshldw $1, (%rax), %zmm17, %zmm19 +vpshldw $1, %zmm16, %zmm17, %zmm19 {k1} +vpshldw $1, (%rax), %zmm17, %zmm19 {k1} +vpshldw $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshldw $1, (%rax), %zmm17, %zmm19 {k1}{z} + +vpshrdd $1, %zmm16, %zmm17, %zmm19 +vpshrdd $1, (%rax), %zmm17, %zmm19 +vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 +vpshrdd $1, %zmm16, %zmm17, %zmm19 {k1} +vpshrdd $1, (%rax), %zmm17, %zmm19 {k1} +vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {k1} +vpshrdd $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdd $1, (%rax), %zmm17, %zmm19 {k1}{z} +vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {k1}{z} + +vpshrdq $1, %zmm16, %zmm17, %zmm19 +vpshrdq $1, (%rax), %zmm17, %zmm19 +vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 +vpshrdq $1, %zmm16, %zmm17, %zmm19 {k1} +vpshrdq $1, (%rax), %zmm17, %zmm19 {k1} +vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {k1} +vpshrdq $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdq $1, (%rax), %zmm17, %zmm19 {k1}{z} +vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {k1}{z} + +vpshrdvd %zmm16, %zmm17, %zmm19 +vpshrdvd (%rax), %zmm17, %zmm19 +vpshrdvd (%rax){1to16}, %zmm17, %zmm19 +vpshrdvd %zmm16, %zmm17, %zmm19 {k1} +vpshrdvd (%rax), %zmm17, %zmm19 {k1} +vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpshrdvd %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdvd (%rax), %zmm17, %zmm19 {k1}{z} +vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {k1}{z} + +vpshrdvq %zmm16, %zmm17, %zmm19 +vpshrdvq (%rax), %zmm17, %zmm19 +vpshrdvq (%rax){1to8}, %zmm17, %zmm19 +vpshrdvq %zmm16, %zmm17, %zmm19 {k1} +vpshrdvq (%rax), %zmm17, %zmm19 {k1} +vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {k1} +vpshrdvq %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdvq (%rax), %zmm17, %zmm19 {k1}{z} +vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {k1}{z} + +vpshrdvw %zmm16, %zmm17, %zmm19 +vpshrdvw (%rax), %zmm17, %zmm19 +vpshrdvw %zmm16, %zmm17, %zmm19 {k1} +vpshrdvw (%rax), %zmm17, %zmm19 {k1} +vpshrdvw %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdvw (%rax), %zmm17, %zmm19 {k1}{z} + +vpshrdw $1, %zmm16, %zmm17, %zmm19 +vpshrdw $1, (%rax), %zmm17, %zmm19 +vpshrdw $1, %zmm16, %zmm17, %zmm19 {k1} +vpshrdw $1, (%rax), %zmm17, %zmm19 {k1} +vpshrdw $1, %zmm16, %zmm17, %zmm19 {k1}{z} +vpshrdw $1, (%rax), %zmm17, %zmm19 {k1}{z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 3 2.00 U vpcompressb %zmm16, %zmm19 +# CHECK-NEXT: 8 12 2.00 * vpcompressb %zmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 8 14 2.00 * vpcompressb %zmm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpcompressw %zmm16, %zmm19 +# CHECK-NEXT: 6 12 2.00 * vpcompressw %zmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 6 14 2.00 * vpcompressw %zmm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandb %zmm16, %zmm19 +# CHECK-NEXT: 3 11 2.00 U vpexpandb (%rax), %zmm19 +# CHECK-NEXT: 2 8 2.00 vpexpandb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandb (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandw %zmm16, %zmm19 +# CHECK-NEXT: 3 11 2.00 U vpexpandw (%rax), %zmm19 +# CHECK-NEXT: 2 8 2.00 vpexpandw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandw (%rax), %zmm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 2 2 1.00 vpshldd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshldd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 2 1.00 vpshldd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshldd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 2 2 1.00 vpshldq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshldq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 2 1.00 vpshldq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshldq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldvd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshldvd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpshldvd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshldvd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldvq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshldvq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpshldvq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshldvq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpshldvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpshldvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpshldvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpshldvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshldw $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshldw $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 4 1.00 vpshldw $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vpshldw $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 4 1.00 vpshldw $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vpshldw $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 2 2 1.00 vpshrdd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshrdd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 2 1.00 vpshrdd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshrdd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 2 2 1.00 vpshrdq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshrdq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 10 1.00 * vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 2 1.00 vpshrdq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshrdq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 10 1.00 * vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdvd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshrdvd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpshrdvd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdvq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1 1 1.00 vpshrdvq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpshrdvq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1 3 1.00 vpshrdvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpshrdvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpshrdvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpshrdvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpshrdw $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 9 1.00 * vpshrdw $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 4 1.00 vpshrdw $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vpshrdw $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 4 1.00 vpshrdw $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vpshrdw $1, (%rax), %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 117.40 0.40 21.33 21.33 3.00 56.40 1.40 3.00 3.00 3.00 0.40 21.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %zmm16, %zmm19 +# CHECK-NEXT: 1.20 0.20 - - 1.00 2.20 0.20 1.00 1.00 1.00 0.20 - - vpcompressb %zmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.20 0.20 - - 1.00 2.20 0.20 1.00 1.00 1.00 0.20 - - vpcompressb %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %zmm16, %zmm19 +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %zmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %zmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %zmm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %zmm16, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %zmm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %zmm16, %zmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %zmm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %zmm16, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshldw $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshldw $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldw $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldw $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshldw $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshldw $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdd $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdd $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdd $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdd $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdd $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdd $1, (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdq $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdq $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdq $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdq $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdq $1, (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdq $1, (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvq %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to8}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvq %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvq %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to8}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvw %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvw %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdvw %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpshrdw $1, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpshrdw $1, (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdw $1, %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdw $1, (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.50 - - - - 0.50 - - - - - - - vpshrdw $1, %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - vpshrdw $1, (%rax), %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2vl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2vl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmi2vl.s @@ -0,0 +1,762 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpcompressb %xmm16, %xmm19 +vpcompressb %xmm16, (%rax) +vpcompressb %xmm16, %xmm19 {k1} +vpcompressb %xmm16, (%rax) {k1} +vpcompressb %xmm16, %xmm19 {k1}{z} + +vpcompressb %ymm16, %ymm19 +vpcompressb %ymm16, (%rax) +vpcompressb %ymm16, %ymm19 {k1} +vpcompressb %ymm16, (%rax) {k1} +vpcompressb %ymm16, %ymm19 {k1}{z} + +vpcompressw %xmm16, %xmm19 +vpcompressw %xmm16, (%rax) +vpcompressw %xmm16, %xmm19 {k1} +vpcompressw %xmm16, (%rax) {k1} +vpcompressw %xmm16, %xmm19 {k1}{z} + +vpcompressw %ymm16, %ymm19 +vpcompressw %ymm16, (%rax) +vpcompressw %ymm16, %ymm19 {k1} +vpcompressw %ymm16, (%rax) {k1} +vpcompressw %ymm16, %ymm19 {k1}{z} + +vpexpandb %xmm16, %xmm19 +vpexpandb (%rax), %xmm19 +vpexpandb %xmm16, %xmm19 {k1} +vpexpandb (%rax), %xmm19 {k1} +vpexpandb %xmm16, %xmm19 {k1}{z} + +vpexpandb %ymm16, %ymm19 +vpexpandb (%rax), %ymm19 +vpexpandb %ymm16, %ymm19 {k1} +vpexpandb (%rax), %ymm19 {k1} +vpexpandb %ymm16, %ymm19 {k1}{z} + +vpexpandw %xmm16, %xmm19 +vpexpandw (%rax), %xmm19 +vpexpandw %xmm16, %xmm19 {k1} +vpexpandw (%rax), %xmm19 {k1} +vpexpandw %xmm16, %xmm19 {k1}{z} + +vpexpandw %ymm16, %ymm19 +vpexpandw (%rax), %ymm19 +vpexpandw %ymm16, %ymm19 {k1} +vpexpandw (%rax), %ymm19 {k1} +vpexpandw %ymm16, %ymm19 {k1}{z} + +vpshldd $1, %xmm16, %xmm17, %xmm19 +vpshldd $1, (%rax), %xmm17, %xmm19 +vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 +vpshldd $1, %xmm16, %xmm17, %xmm19 {k1} +vpshldd $1, (%rax), %xmm17, %xmm19 {k1} +vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {k1} +vpshldd $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldd $1, (%rax), %xmm17, %xmm19 {k1}{z} +vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {k1}{z} + +vpshldd $1, %ymm16, %ymm17, %ymm19 +vpshldd $1, (%rax), %ymm17, %ymm19 +vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 +vpshldd $1, %ymm16, %ymm17, %ymm19 {k1} +vpshldd $1, (%rax), %ymm17, %ymm19 {k1} +vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {k1} +vpshldd $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldd $1, (%rax), %ymm17, %ymm19 {k1}{z} +vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {k1}{z} + +vpshldq $1, %xmm16, %xmm17, %xmm19 +vpshldq $1, (%rax), %xmm17, %xmm19 +vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 +vpshldq $1, %xmm16, %xmm17, %xmm19 {k1} +vpshldq $1, (%rax), %xmm17, %xmm19 {k1} +vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {k1} +vpshldq $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldq $1, (%rax), %xmm17, %xmm19 {k1}{z} +vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {k1}{z} + +vpshldq $1, %ymm16, %ymm17, %ymm19 +vpshldq $1, (%rax), %ymm17, %ymm19 +vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 +vpshldq $1, %ymm16, %ymm17, %ymm19 {k1} +vpshldq $1, (%rax), %ymm17, %ymm19 {k1} +vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {k1} +vpshldq $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldq $1, (%rax), %ymm17, %ymm19 {k1}{z} +vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {k1}{z} + +vpshldvd %xmm16, %xmm17, %xmm19 +vpshldvd (%rax), %xmm17, %xmm19 +vpshldvd (%rax){1to4}, %xmm17, %xmm19 +vpshldvd %xmm16, %xmm17, %xmm19 {k1} +vpshldvd (%rax), %xmm17, %xmm19 {k1} +vpshldvd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpshldvd %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldvd (%rax), %xmm17, %xmm19 {k1}{z} +vpshldvd (%rax){1to4}, %xmm17, %xmm19 {k1}{z} + +vpshldvd %ymm16, %ymm17, %ymm19 +vpshldvd (%rax), %ymm17, %ymm19 +vpshldvd (%rax){1to8}, %ymm17, %ymm19 +vpshldvd %ymm16, %ymm17, %ymm19 {k1} +vpshldvd (%rax), %ymm17, %ymm19 {k1} +vpshldvd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpshldvd %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldvd (%rax), %ymm17, %ymm19 {k1}{z} +vpshldvd (%rax){1to8}, %ymm17, %ymm19 {k1}{z} + +vpshldvq %xmm16, %xmm17, %xmm19 +vpshldvq (%rax), %xmm17, %xmm19 +vpshldvq (%rax){1to2}, %xmm17, %xmm19 +vpshldvq %xmm16, %xmm17, %xmm19 {k1} +vpshldvq (%rax), %xmm17, %xmm19 {k1} +vpshldvq (%rax){1to2}, %xmm17, %xmm19 {k1} +vpshldvq %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldvq (%rax), %xmm17, %xmm19 {k1}{z} +vpshldvq (%rax){1to2}, %xmm17, %xmm19 {k1}{z} + +vpshldvq %ymm16, %ymm17, %ymm19 +vpshldvq (%rax), %ymm17, %ymm19 +vpshldvq (%rax){1to4}, %ymm17, %ymm19 +vpshldvq %ymm16, %ymm17, %ymm19 {k1} +vpshldvq (%rax), %ymm17, %ymm19 {k1} +vpshldvq (%rax){1to4}, %ymm17, %ymm19 {k1} +vpshldvq %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldvq (%rax), %ymm17, %ymm19 {k1}{z} +vpshldvq (%rax){1to4}, %ymm17, %ymm19 {k1}{z} + +vpshldvw %xmm16, %xmm17, %xmm19 +vpshldvw (%rax), %xmm17, %xmm19 +vpshldvw %xmm16, %xmm17, %xmm19 {k1} +vpshldvw (%rax), %xmm17, %xmm19 {k1} +vpshldvw %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldvw (%rax), %xmm17, %xmm19 {k1}{z} + +vpshldvw %ymm16, %ymm17, %ymm19 +vpshldvw (%rax), %ymm17, %ymm19 +vpshldvw %ymm16, %ymm17, %ymm19 {k1} +vpshldvw (%rax), %ymm17, %ymm19 {k1} +vpshldvw %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldvw (%rax), %ymm17, %ymm19 {k1}{z} + +vpshldw $1, %xmm16, %xmm17, %xmm19 +vpshldw $1, (%rax), %xmm17, %xmm19 +vpshldw $1, %xmm16, %xmm17, %xmm19 {k1} +vpshldw $1, (%rax), %xmm17, %xmm19 {k1} +vpshldw $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshldw $1, (%rax), %xmm17, %xmm19 {k1}{z} + +vpshldw $1, %ymm16, %ymm17, %ymm19 +vpshldw $1, (%rax), %ymm17, %ymm19 +vpshldw $1, %ymm16, %ymm17, %ymm19 {k1} +vpshldw $1, (%rax), %ymm17, %ymm19 {k1} +vpshldw $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshldw $1, (%rax), %ymm17, %ymm19 {k1}{z} + +vpshrdd $1, %xmm16, %xmm17, %xmm19 +vpshrdd $1, (%rax), %xmm17, %xmm19 +vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 +vpshrdd $1, %xmm16, %xmm17, %xmm19 {k1} +vpshrdd $1, (%rax), %xmm17, %xmm19 {k1} +vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {k1} +vpshrdd $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdd $1, (%rax), %xmm17, %xmm19 {k1}{z} +vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {k1}{z} + +vpshrdd $1, %ymm16, %ymm17, %ymm19 +vpshrdd $1, (%rax), %ymm17, %ymm19 +vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 +vpshrdd $1, %ymm16, %ymm17, %ymm19 {k1} +vpshrdd $1, (%rax), %ymm17, %ymm19 {k1} +vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {k1} +vpshrdd $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdd $1, (%rax), %ymm17, %ymm19 {k1}{z} +vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {k1}{z} + +vpshrdq $1, %xmm16, %xmm17, %xmm19 +vpshrdq $1, (%rax), %xmm17, %xmm19 +vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 +vpshrdq $1, %xmm16, %xmm17, %xmm19 {k1} +vpshrdq $1, (%rax), %xmm17, %xmm19 {k1} +vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {k1} +vpshrdq $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdq $1, (%rax), %xmm17, %xmm19 {k1}{z} +vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {k1}{z} + +vpshrdq $1, %ymm16, %ymm17, %ymm19 +vpshrdq $1, (%rax), %ymm17, %ymm19 +vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 +vpshrdq $1, %ymm16, %ymm17, %ymm19 {k1} +vpshrdq $1, (%rax), %ymm17, %ymm19 {k1} +vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {k1} +vpshrdq $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdq $1, (%rax), %ymm17, %ymm19 {k1}{z} +vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {k1}{z} + +vpshrdvd %xmm16, %xmm17, %xmm19 +vpshrdvd (%rax), %xmm17, %xmm19 +vpshrdvd (%rax){1to4}, %xmm17, %xmm19 +vpshrdvd %xmm16, %xmm17, %xmm19 {k1} +vpshrdvd (%rax), %xmm17, %xmm19 {k1} +vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpshrdvd %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdvd (%rax), %xmm17, %xmm19 {k1}{z} +vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {k1}{z} + +vpshrdvd %ymm16, %ymm17, %ymm19 +vpshrdvd (%rax), %ymm17, %ymm19 +vpshrdvd (%rax){1to8}, %ymm17, %ymm19 +vpshrdvd %ymm16, %ymm17, %ymm19 {k1} +vpshrdvd (%rax), %ymm17, %ymm19 {k1} +vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpshrdvd %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdvd (%rax), %ymm17, %ymm19 {k1}{z} +vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {k1}{z} + +vpshrdvq %xmm16, %xmm17, %xmm19 +vpshrdvq (%rax), %xmm17, %xmm19 +vpshrdvq (%rax){1to2}, %xmm17, %xmm19 +vpshrdvq %xmm16, %xmm17, %xmm19 {k1} +vpshrdvq (%rax), %xmm17, %xmm19 {k1} +vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {k1} +vpshrdvq %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdvq (%rax), %xmm17, %xmm19 {k1}{z} +vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {k1}{z} + +vpshrdvq %ymm16, %ymm17, %ymm19 +vpshrdvq (%rax), %ymm17, %ymm19 +vpshrdvq (%rax){1to4}, %ymm17, %ymm19 +vpshrdvq %ymm16, %ymm17, %ymm19 {k1} +vpshrdvq (%rax), %ymm17, %ymm19 {k1} +vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {k1} +vpshrdvq %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdvq (%rax), %ymm17, %ymm19 {k1}{z} +vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {k1}{z} + +vpshrdvw %xmm16, %xmm17, %xmm19 +vpshrdvw (%rax), %xmm17, %xmm19 +vpshrdvw %xmm16, %xmm17, %xmm19 {k1} +vpshrdvw (%rax), %xmm17, %xmm19 {k1} +vpshrdvw %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdvw (%rax), %xmm17, %xmm19 {k1}{z} + +vpshrdvw %ymm16, %ymm17, %ymm19 +vpshrdvw (%rax), %ymm17, %ymm19 +vpshrdvw %ymm16, %ymm17, %ymm19 {k1} +vpshrdvw (%rax), %ymm17, %ymm19 {k1} +vpshrdvw %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdvw (%rax), %ymm17, %ymm19 {k1}{z} + +vpshrdw $1, %xmm16, %xmm17, %xmm19 +vpshrdw $1, (%rax), %xmm17, %xmm19 +vpshrdw $1, %xmm16, %xmm17, %xmm19 {k1} +vpshrdw $1, (%rax), %xmm17, %xmm19 {k1} +vpshrdw $1, %xmm16, %xmm17, %xmm19 {k1}{z} +vpshrdw $1, (%rax), %xmm17, %xmm19 {k1}{z} + +vpshrdw $1, %ymm16, %ymm17, %ymm19 +vpshrdw $1, (%rax), %ymm17, %ymm19 +vpshrdw $1, %ymm16, %ymm17, %ymm19 {k1} +vpshrdw $1, (%rax), %ymm17, %ymm19 {k1} +vpshrdw $1, %ymm16, %ymm17, %ymm19 {k1}{z} +vpshrdw $1, (%rax), %ymm17, %ymm19 {k1}{z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 3 2.00 U vpcompressb %xmm16, %xmm19 +# CHECK-NEXT: 6 12 2.00 * vpcompressb %xmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 6 14 2.00 * vpcompressb %xmm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpcompressb %ymm16, %ymm19 +# CHECK-NEXT: 6 12 2.00 * vpcompressb %ymm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 6 14 2.00 * vpcompressb %ymm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpcompressw %xmm16, %xmm19 +# CHECK-NEXT: 6 12 2.00 * vpcompressw %xmm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 6 14 2.00 * vpcompressw %xmm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpcompressw %ymm16, %ymm19 +# CHECK-NEXT: 6 12 2.00 * vpcompressw %ymm16, (%rax) +# CHECK-NEXT: 2 6 2.00 vpcompressw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 6 14 2.00 * vpcompressw %ymm16, (%rax) {%k1} +# CHECK-NEXT: 2 6 2.00 vpcompressw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandb %xmm16, %xmm19 +# CHECK-NEXT: 3 10 2.00 U vpexpandb (%rax), %xmm19 +# CHECK-NEXT: 2 8 2.00 vpexpandb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandb (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandb %ymm16, %ymm19 +# CHECK-NEXT: 3 11 2.00 U vpexpandb (%rax), %ymm19 +# CHECK-NEXT: 2 8 2.00 vpexpandb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandb (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandw %xmm16, %xmm19 +# CHECK-NEXT: 3 10 2.00 U vpexpandw (%rax), %xmm19 +# CHECK-NEXT: 2 8 2.00 vpexpandw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandw (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 3 2.00 U vpexpandw %ymm16, %ymm19 +# CHECK-NEXT: 3 11 2.00 U vpexpandw (%rax), %ymm19 +# CHECK-NEXT: 2 8 2.00 vpexpandw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 3 13 2.00 * vpexpandw (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 8 2.00 vpexpandw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 2 2 0.67 vpshldd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshldd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshldd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshldd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 2 2 0.67 vpshldd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshldd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshldd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshldd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 2 2 0.67 vpshldq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshldq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshldq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshldq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 2 2 0.67 vpshldq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshldq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshldq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshldq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpshldvd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshldvd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshldvd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshldvd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshldvd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshldvd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpshldvq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshldvq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshldvq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshldvq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshldvq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshldvq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpshldvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshldvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshldvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshldvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpshldvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshldvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshldvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshldvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldw $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshldw $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 4 0.67 vpshldw $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 11 0.67 * vpshldw $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpshldw $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 11 0.67 * vpshldw $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshldw $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshldw $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 4 0.67 vpshldw $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 12 0.67 * vpshldw $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpshldw $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 12 0.67 * vpshldw $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 2 2 0.67 vpshrdd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshrdd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshrdd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshrdd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 2 2 0.67 vpshrdd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshrdd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshrdd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshrdd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 2 2 0.67 vpshrdq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshrdq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 9 0.67 * vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshrdq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshrdq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 9 0.67 * vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 2 2 0.67 vpshrdq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshrdq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 10 0.67 * vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 2 0.67 vpshrdq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshrdq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 10 0.67 * vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpshrdvd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshrdvd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshrdvd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshrdvd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpshrdvq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshrdvq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshrdvq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshrdvq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vpshrdvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshrdvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshrdvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshrdvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vpshrdvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vpshrdvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 0.50 vpshrdvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vpshrdvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdw $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshrdw $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 4 0.67 vpshrdw $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 11 0.67 * vpshrdw $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpshrdw $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 11 0.67 * vpshrdw $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshrdw $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshrdw $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 4 0.67 vpshrdw $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 12 0.67 * vpshrdw $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 4 0.67 vpshrdw $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 12 0.67 * vpshrdw $1, (%rax), %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 129.33 117.33 42.67 42.67 4.00 101.33 4.00 4.00 4.00 4.00 - 42.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %xmm16, %xmm19 +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressb %xmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressb %xmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %ymm16, %ymm19 +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressb %ymm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressb %ymm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %xmm16, %xmm19 +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %xmm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %xmm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %ymm16, %ymm19 +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %ymm16, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1.50 - - - 0.50 2.00 0.50 0.50 0.50 0.50 - - - vpcompressw %ymm16, (%rax) {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpcompressw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %xmm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %ymm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandb (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandb %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %xmm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %ymm19 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - vpexpandw (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 2.00 - - - - - - - vpexpandw %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldw $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldw $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldw $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldw $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldw $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldw $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshldw $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshldw $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldw $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldw $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshldw $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshldw $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdvw %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdvw (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdw $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdw $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdw $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdw $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdw $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdw $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpshrdw $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpshrdw $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdw $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdw $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.83 0.83 - - - 0.33 - - - - - - - vpshrdw $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.83 0.83 0.33 0.33 - 0.33 - - - - - 0.33 - vpshrdw $1, (%rax), %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmivl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmivl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vbmivl.s @@ -0,0 +1,204 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpermb %xmm16, %xmm17, %xmm19 +vpermb (%rax), %xmm17, %xmm19 +vpermb %xmm16, %xmm17, %xmm19 {k1} +vpermb (%rax), %xmm17, %xmm19 {k1} +vpermb %xmm16, %xmm17, %xmm19 {k1}{z} +vpermb (%rax), %xmm17, %xmm19 {k1}{z} + +vpermb %ymm16, %ymm17, %ymm19 +vpermb (%rax), %ymm17, %ymm19 +vpermb %ymm16, %ymm17, %ymm19 {k1} +vpermb (%rax), %ymm17, %ymm19 {k1} +vpermb %ymm16, %ymm17, %ymm19 {k1}{z} +vpermb (%rax), %ymm17, %ymm19 {k1}{z} + +vpermi2b %xmm16, %xmm17, %xmm19 +vpermi2b (%rax), %xmm17, %xmm19 +vpermi2b %xmm16, %xmm17, %xmm19 {k1} +vpermi2b (%rax), %xmm17, %xmm19 {k1} +vpermi2b %xmm16, %xmm17, %xmm19 {k1}{z} +vpermi2b (%rax), %xmm17, %xmm19 {k1}{z} + +vpermi2b %ymm16, %ymm17, %ymm19 +vpermi2b (%rax), %ymm17, %ymm19 +vpermi2b %ymm16, %ymm17, %ymm19 {k1} +vpermi2b (%rax), %ymm17, %ymm19 {k1} +vpermi2b %ymm16, %ymm17, %ymm19 {k1}{z} +vpermi2b (%rax), %ymm17, %ymm19 {k1}{z} + +vpermt2b %xmm16, %xmm17, %xmm19 +vpermt2b (%rax), %xmm17, %xmm19 +vpermt2b %xmm16, %xmm17, %xmm19 {k1} +vpermt2b (%rax), %xmm17, %xmm19 {k1} +vpermt2b %xmm16, %xmm17, %xmm19 {k1}{z} +vpermt2b (%rax), %xmm17, %xmm19 {k1}{z} + +vpermt2b %ymm16, %ymm17, %ymm19 +vpermt2b (%rax), %ymm17, %ymm19 +vpermt2b %ymm16, %ymm17, %ymm19 {k1} +vpermt2b (%rax), %ymm17, %ymm19 {k1} +vpermt2b %ymm16, %ymm17, %ymm19 {k1}{z} +vpermt2b (%rax), %ymm17, %ymm19 {k1}{z} + +vpmultishiftqb %xmm16, %xmm17, %xmm19 +vpmultishiftqb (%rax), %xmm17, %xmm19 +vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 +vpmultishiftqb %xmm16, %xmm17, %xmm19 {k1} +vpmultishiftqb (%rax), %xmm17, %xmm19 {k1} +vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {k1} +vpmultishiftqb %xmm16, %xmm17, %xmm19 {k1}{z} +vpmultishiftqb (%rax), %xmm17, %xmm19 {k1}{z} +vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {k1}{z} + +vpmultishiftqb %ymm16, %ymm17, %ymm19 +vpmultishiftqb (%rax), %ymm17, %ymm19 +vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 +vpmultishiftqb %ymm16, %ymm17, %ymm19 {k1} +vpmultishiftqb (%rax), %ymm17, %ymm19 {k1} +vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {k1} +vpmultishiftqb %ymm16, %ymm17, %ymm19 {k1}{z} +vpmultishiftqb (%rax), %ymm17, %ymm19 {k1}{z} +vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {k1}{z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpermb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpermb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpermb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpermb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpermb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpermb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpermb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermi2b %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 4 11 2.00 * vpermi2b (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 7 2.00 vpermi2b %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 4 13 2.00 * vpermi2b (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermi2b %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 13 2.00 * vpermi2b (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermi2b %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 4 12 2.00 * vpermi2b (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 7 2.00 vpermi2b %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 4 14 2.00 * vpermi2b (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermi2b %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 4 14 2.00 * vpermi2b (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermt2b %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 4 11 2.00 * vpermt2b (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 7 2.00 vpermt2b %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 4 13 2.00 * vpermt2b (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermt2b %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 4 13 2.00 * vpermt2b (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 5 2.00 vpermt2b %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 4 12 2.00 * vpermt2b (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 7 2.00 vpermt2b %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 4 14 2.00 * vpermt2b (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 7 2.00 vpermt2b %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 4 14 2.00 * vpermt2b (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmultishiftqb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpmultishiftqb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmultishiftqb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmultishiftqb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpmultishiftqb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 8.00 8.00 10.00 10.00 - 86.00 - - - - - 10.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermi2b %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermi2b (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 2.33 - - - - - - - vpermt2b %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 2.33 - - - - - 0.33 - vpermt2b (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmultishiftqb %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmultishiftqb (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vl.s @@ -0,0 +1,4409 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vaddpd %xmm16, %xmm17, %xmm19 +vaddpd (%rax), %xmm17, %xmm19 +vaddpd (%rax){1to2}, %xmm17, %xmm19 +vaddpd %xmm16, %xmm17, %xmm19 {k1} +vaddpd (%rax), %xmm17, %xmm19 {k1} +vaddpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vaddpd %xmm16, %xmm17, %xmm19 {z}{k1} +vaddpd (%rax), %xmm17, %xmm19 {z}{k1} +vaddpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vaddpd %ymm16, %ymm17, %ymm19 +vaddpd (%rax), %ymm17, %ymm19 +vaddpd (%rax){1to4}, %ymm17, %ymm19 +vaddpd %ymm16, %ymm17, %ymm19 {k1} +vaddpd (%rax), %ymm17, %ymm19 {k1} +vaddpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vaddpd %ymm16, %ymm17, %ymm19 {z}{k1} +vaddpd (%rax), %ymm17, %ymm19 {z}{k1} +vaddpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vaddps %xmm16, %xmm17, %xmm19 +vaddps (%rax), %xmm17, %xmm19 +vaddps (%rax){1to4}, %xmm17, %xmm19 +vaddps %xmm16, %xmm17, %xmm19 {k1} +vaddps (%rax), %xmm17, %xmm19 {k1} +vaddps (%rax){1to4}, %xmm17, %xmm19 {k1} +vaddps %xmm16, %xmm17, %xmm19 {z}{k1} +vaddps (%rax), %xmm17, %xmm19 {z}{k1} +vaddps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vaddps %ymm16, %ymm17, %ymm19 +vaddps (%rax), %ymm17, %ymm19 +vaddps (%rax){1to8}, %ymm17, %ymm19 +vaddps %ymm16, %ymm17, %ymm19 {k1} +vaddps (%rax), %ymm17, %ymm19 {k1} +vaddps (%rax){1to8}, %ymm17, %ymm19 {k1} +vaddps %ymm16, %ymm17, %ymm19 {z}{k1} +vaddps (%rax), %ymm17, %ymm19 {z}{k1} +vaddps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +valignd $1, %xmm16, %xmm17, %xmm19 +valignd $1, (%rax), %xmm17, %xmm19 +valignd $1, (%rax){1to4}, %xmm17, %xmm19 +valignd $1, %xmm16, %xmm17, %xmm19 {k1} +valignd $1, (%rax), %xmm17, %xmm19 {k1} +valignd $1, (%rax){1to4}, %xmm17, %xmm19 {k1} +valignd $1, %xmm16, %xmm17, %xmm19 {z}{k1} +valignd $1, (%rax), %xmm17, %xmm19 {z}{k1} +valignd $1, (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +valignd $1, %ymm16, %ymm17, %ymm19 +valignd $1, (%rax), %ymm17, %ymm19 +valignd $1, (%rax){1to8}, %ymm17, %ymm19 +valignd $1, %ymm16, %ymm17, %ymm19 {k1} +valignd $1, (%rax), %ymm17, %ymm19 {k1} +valignd $1, (%rax){1to8}, %ymm17, %ymm19 {k1} +valignd $1, %ymm16, %ymm17, %ymm19 {z}{k1} +valignd $1, (%rax), %ymm17, %ymm19 {z}{k1} +valignd $1, (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +valignq $1, %xmm16, %xmm17, %xmm19 +valignq $1, (%rax), %xmm17, %xmm19 +valignq $1, (%rax){1to2}, %xmm17, %xmm19 +valignq $1, %xmm16, %xmm17, %xmm19 {k1} +valignq $1, (%rax), %xmm17, %xmm19 {k1} +valignq $1, (%rax){1to2}, %xmm17, %xmm19 {k1} +valignq $1, %xmm16, %xmm17, %xmm19 {z}{k1} +valignq $1, (%rax), %xmm17, %xmm19 {z}{k1} +valignq $1, (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +valignq $1, %ymm16, %ymm17, %ymm19 +valignq $1, (%rax), %ymm17, %ymm19 +valignq $1, (%rax){1to4}, %ymm17, %ymm19 +valignq $1, %ymm16, %ymm17, %ymm19 {k1} +valignq $1, (%rax), %ymm17, %ymm19 {k1} +valignq $1, (%rax){1to4}, %ymm17, %ymm19 {k1} +valignq $1, %ymm16, %ymm17, %ymm19 {z}{k1} +valignq $1, (%rax), %ymm17, %ymm19 {z}{k1} +valignq $1, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vbroadcastf32x4 (%rax), %ymm19 +vbroadcastf32x4 (%rax), %ymm19 {k1} +vbroadcastf32x4 (%rax), %ymm19 {z}{k1} + +vbroadcasti32x4 (%rax), %ymm19 +vbroadcasti32x4 (%rax), %ymm19 {k1} +vbroadcasti32x4 (%rax), %ymm19 {z}{k1} + +vbroadcastsd %xmm16, %ymm19 +vbroadcastsd (%rax), %ymm19 +vbroadcastsd %xmm16, %ymm19 {k1} +vbroadcastsd (%rax), %ymm19 {k1} +vbroadcastsd %xmm16, %ymm19 {z}{k1} +vbroadcastsd (%rax), %ymm19 {z}{k1} + +vbroadcastss %xmm16, %xmm19 +vbroadcastss (%rax), %xmm19 +vbroadcastss %xmm16, %xmm19 {k1} +vbroadcastss (%rax), %xmm19 {k1} +vbroadcastss %xmm16, %xmm19 {z}{k1} +vbroadcastss (%rax), %xmm19 {z}{k1} + +vbroadcastss %xmm16, %ymm19 +vbroadcastss (%rax), %ymm19 +vbroadcastss %xmm16, %ymm19 {k1} +vbroadcastss (%rax), %ymm19 {k1} +vbroadcastss %xmm16, %ymm19 {z}{k1} +vbroadcastss (%rax), %ymm19 {z}{k1} + +vcmppd $0, %xmm0, %xmm1, %k2 +vcmppd $0, (%rax), %xmm1, %k2 +vcmppd $0, (%rax){1to2}, %xmm1, %k2 +vcmppd $0, %xmm0, %xmm1, %k2 {k3} +vcmppd $0, (%rax), %xmm1, %k2 {k3} +vcmppd $0, (%rax){1to2}, %xmm1, %k2 {k3} + +vcmppd $0, %ymm0, %ymm1, %k2 +vcmppd $0, (%rax), %ymm1, %k2 +vcmppd $0, (%rax){1to4}, %ymm1, %k2 +vcmppd $0, %ymm0, %ymm1, %k2 {k3} +vcmppd $0, (%rax), %ymm1, %k2 {k3} +vcmppd $0, (%rax){1to4}, %ymm1, %k2 {k3} + +vcmpps $0, %xmm0, %xmm1, %k2 +vcmpps $0, (%rax), %xmm1, %k2 +vcmpps $0, (%rax){1to4}, %xmm1, %k2 +vcmpps $0, %xmm0, %xmm1, %k2 {k3} +vcmpps $0, (%rax), %xmm1, %k2 {k3} +vcmpps $0, (%rax){1to4}, %xmm1, %k2 {k3} + +vcmpps $0, %ymm0, %ymm1, %k2 +vcmpps $0, (%rax), %ymm1, %k2 +vcmpps $0, (%rax){1to8}, %ymm1, %k2 +vcmpps $0, %ymm0, %ymm1, %k2 {k3} +vcmpps $0, (%rax), %ymm1, %k2 {k3} +vcmpps $0, (%rax){1to8}, %ymm1, %k2 {k3} + +vcvtdq2pd %xmm16, %xmm19 +vcvtdq2pd (%rax), %xmm19 +vcvtdq2pd (%rax){1to2}, %xmm19 +vcvtdq2pd %xmm16, %xmm19 {k1} +vcvtdq2pd (%rax), %xmm19 {k1} +vcvtdq2pd (%rax){1to2}, %xmm19 {k1} +vcvtdq2pd %xmm16, %xmm19 {z}{k1} +vcvtdq2pd (%rax), %xmm19 {z}{k1} +vcvtdq2pd (%rax){1to2}, %xmm19 {z}{k1} + +vcvtdq2pd %xmm16, %ymm19 +vcvtdq2pd (%rax), %ymm19 +vcvtdq2pd (%rax){1to4}, %ymm19 +vcvtdq2pd %xmm16, %ymm19 {k1} +vcvtdq2pd (%rax), %ymm19 {k1} +vcvtdq2pd (%rax){1to4}, %ymm19 {k1} +vcvtdq2pd %xmm16, %ymm19 {z}{k1} +vcvtdq2pd (%rax), %ymm19 {z}{k1} +vcvtdq2pd (%rax){1to4}, %ymm19 {z}{k1} + +vcvtdq2ps %xmm16, %xmm19 +vcvtdq2ps (%rax), %xmm19 +vcvtdq2ps (%rax){1to4}, %xmm19 +vcvtdq2ps %xmm16, %xmm19 {k1} +vcvtdq2ps (%rax), %xmm19 {k1} +vcvtdq2ps (%rax){1to4},%xmm19 {k1} +vcvtdq2ps %xmm16, %xmm19 {z}{k1} +vcvtdq2ps (%rax), %xmm19 {z}{k1} +vcvtdq2ps (%rax){1to4}, %xmm19 {z}{k1} + +vcvtdq2ps %ymm16, %ymm19 +vcvtdq2ps (%rax), %ymm19 +vcvtdq2ps (%rax){1to8}, %ymm19 +vcvtdq2ps %ymm16,%ymm19 {k1} +vcvtdq2ps (%rax),%ymm19 {k1} +vcvtdq2ps (%rax){1to8}, %ymm19 {k1} +vcvtdq2ps %ymm16, %ymm19 {z}{k1} +vcvtdq2ps (%rax), %ymm19 {z}{k1} +vcvtdq2ps (%rax){1to8}, %ymm19 {z}{k1} + +vcvtpd2dqy %ymm16, %xmm19 +vcvtpd2dqy (%rax), %xmm19 +vcvtpd2dqy (%rax){1to4}, %xmm19 +vcvtpd2dqy %ymm16, %xmm19 {k1} +vcvtpd2dqy (%rax), %xmm19 {k1} +vcvtpd2dqy (%rax){1to4}, %xmm19 {k1} +vcvtpd2dqy %ymm16, %xmm19 {z}{k1} +vcvtpd2dqy (%rax), %xmm19 {z}{k1} +vcvtpd2dqy (%rax){1to4}, %xmm19 {z}{k1} + +vcvtpd2dqx %xmm16, %xmm19 +vcvtpd2dqx (%rax), %xmm19 +vcvtpd2dqx (%rax){1to2}, %xmm19 +vcvtpd2dqx %xmm16, %xmm19 {k1} +vcvtpd2dqx (%rax), %xmm19 {k1} +vcvtpd2dqx (%rax){1to2},%xmm19 {k1} +vcvtpd2dqx %xmm16, %xmm19 {z}{k1} +vcvtpd2dqx (%rax), %xmm19 {z}{k1} +vcvtpd2dqx (%rax){1to2}, %xmm19 {z}{k1} + +vcvtpd2psy %ymm16, %xmm19 +vcvtpd2psy (%rax), %xmm19 +vcvtpd2psy (%rax){1to4}, %xmm19 +vcvtpd2psy %ymm16, %xmm19 {k1} +vcvtpd2psy (%rax), %xmm19 {k1} +vcvtpd2psy (%rax){1to4}, %xmm19 {k1} +vcvtpd2psy %ymm16, %xmm19 {z}{k1} +vcvtpd2psy (%rax), %xmm19 {z}{k1} +vcvtpd2psy (%rax){1to4}, %xmm19 {z}{k1} + +vcvtpd2psx %xmm16, %xmm19 +vcvtpd2psx (%rax), %xmm19 +vcvtpd2psx (%rax){1to2}, %xmm19 +vcvtpd2psx %xmm16, %xmm19 {k1} +vcvtpd2psx (%rax), %xmm19 {k1} +vcvtpd2psx (%rax){1to2},%xmm19 {k1} +vcvtpd2psx %xmm16, %xmm19 {z}{k1} +vcvtpd2psx (%rax), %xmm19 {z}{k1} +vcvtpd2psx (%rax){1to2}, %xmm19 {z}{k1} + +vcvtpd2udqy %ymm16, %xmm19 +vcvtpd2udqy (%rax), %xmm19 +vcvtpd2udqy (%rax){1to4}, %xmm19 +vcvtpd2udqy %ymm16, %xmm19 {k1} +vcvtpd2udqy (%rax), %xmm19 {k1} +vcvtpd2udqy (%rax){1to4}, %xmm19 {k1} +vcvtpd2udqy %ymm16, %xmm19 {z}{k1} +vcvtpd2udqy (%rax), %xmm19 {z}{k1} +vcvtpd2udqy (%rax){1to4}, %xmm19 {z}{k1} + +vcvtpd2udqx %xmm16, %xmm19 +vcvtpd2udqx (%rax), %xmm19 +vcvtpd2udqx (%rax){1to2}, %xmm19 +vcvtpd2udqx %xmm16, %xmm19 {k1} +vcvtpd2udqx (%rax), %xmm19 {k1} +vcvtpd2udqx (%rax){1to2},%xmm19 {k1} +vcvtpd2udqx %xmm16, %xmm19 {z}{k1} +vcvtpd2udqx (%rax), %xmm19 {z}{k1} +vcvtpd2udqx (%rax){1to2}, %xmm19 {z}{k1} + +vcvtps2dq %xmm16, %xmm19 +vcvtps2dq (%rax), %xmm19 +vcvtps2dq (%rax){1to4}, %xmm19 +vcvtps2dq %xmm16, %xmm19 {k1} +vcvtps2dq (%rax), %xmm19 {k1} +vcvtps2dq (%rax){1to4},%xmm19 {k1} +vcvtps2dq %xmm16, %xmm19 {z}{k1} +vcvtps2dq (%rax), %xmm19 {z}{k1} +vcvtps2dq (%rax){1to4}, %xmm19 {z}{k1} + +vcvtps2dq %ymm16, %ymm19 +vcvtps2dq (%rax), %ymm19 +vcvtps2dq (%rax){1to8}, %ymm19 +vcvtps2dq %ymm16,%ymm19 {k1} +vcvtps2dq (%rax),%ymm19 {k1} +vcvtps2dq (%rax){1to8}, %ymm19 {k1} +vcvtps2dq %ymm16, %ymm19 {z}{k1} +vcvtps2dq (%rax), %ymm19 {z}{k1} +vcvtps2dq (%rax){1to8}, %ymm19 {z}{k1} + +vcvtps2pd %xmm16, %xmm19 +vcvtps2pd (%rax), %xmm19 +vcvtps2pd (%rax){1to2}, %xmm19 +vcvtps2pd %xmm16, %xmm19 {k1} +vcvtps2pd (%rax), %xmm19 {k1} +vcvtps2pd (%rax){1to2},%xmm19 {k1} +vcvtps2pd %xmm16, %xmm19 {z}{k1} +vcvtps2pd (%rax), %xmm19 {z}{k1} +vcvtps2pd (%rax){1to2}, %xmm19 {z}{k1} + +vcvtps2pd %xmm16, %ymm19 +vcvtps2pd (%rax), %ymm19 +vcvtps2pd (%rax){1to4}, %ymm19 +vcvtps2pd %xmm16,%ymm19 {k1} +vcvtps2pd (%rax),%ymm19 {k1} +vcvtps2pd (%rax){1to4}, %ymm19 {k1} +vcvtps2pd %xmm16, %ymm19 {z}{k1} +vcvtps2pd (%rax), %ymm19 {z}{k1} +vcvtps2pd (%rax){1to4}, %ymm19 {z}{k1} + +vcvtps2udq %xmm16, %xmm19 +vcvtps2udq (%rax), %xmm19 +vcvtps2udq (%rax){1to4}, %xmm19 +vcvtps2udq %xmm16, %xmm19 {k1} +vcvtps2udq (%rax), %xmm19 {k1} +vcvtps2udq (%rax){1to4},%xmm19 {k1} +vcvtps2udq %xmm16, %xmm19 {z}{k1} +vcvtps2udq (%rax), %xmm19 {z}{k1} +vcvtps2udq (%rax){1to4}, %xmm19 {z}{k1} + +vcvtps2udq %ymm16, %ymm19 +vcvtps2udq (%rax), %ymm19 +vcvtps2udq (%rax){1to8}, %ymm19 +vcvtps2udq %ymm16,%ymm19 {k1} +vcvtps2udq (%rax),%ymm19 {k1} +vcvtps2udq (%rax){1to8}, %ymm19 {k1} +vcvtps2udq %ymm16, %ymm19 {z}{k1} +vcvtps2udq (%rax), %ymm19 {z}{k1} +vcvtps2udq (%rax){1to8}, %ymm19 {z}{k1} + +vcvttpd2dqy %ymm16, %xmm19 +vcvttpd2dqy (%rax), %xmm19 +vcvttpd2dqy (%rax){1to4}, %xmm19 +vcvttpd2dqy %ymm16, %xmm19 {k1} +vcvttpd2dqy (%rax), %xmm19 {k1} +vcvttpd2dqy (%rax){1to4}, %xmm19 {k1} +vcvttpd2dqy %ymm16, %xmm19 {z}{k1} +vcvttpd2dqy (%rax), %xmm19 {z}{k1} +vcvttpd2dqy (%rax){1to4}, %xmm19 {z}{k1} + +vcvttpd2dqx %xmm16, %xmm19 +vcvttpd2dqx (%rax), %xmm19 +vcvttpd2dqx (%rax){1to2}, %xmm19 +vcvttpd2dqx %xmm16, %xmm19 {k1} +vcvttpd2dqx (%rax), %xmm19 {k1} +vcvttpd2dqx (%rax){1to2},%xmm19 {k1} +vcvttpd2dqx %xmm16, %xmm19 {z}{k1} +vcvttpd2dqx (%rax), %xmm19 {z}{k1} +vcvttpd2dqx (%rax){1to2}, %xmm19 {z}{k1} + +vcvttps2dq %xmm16, %xmm19 +vcvttps2dq (%rax), %xmm19 +vcvttps2dq (%rax){1to4}, %xmm19 +vcvttps2dq %xmm16, %xmm19 {k1} +vcvttps2dq (%rax), %xmm19 {k1} +vcvttps2dq (%rax){1to4},%xmm19 {k1} +vcvttps2dq %xmm16, %xmm19 {z}{k1} +vcvttps2dq (%rax), %xmm19 {z}{k1} +vcvttps2dq (%rax){1to4}, %xmm19 {z}{k1} + +vcvttps2dq %ymm16, %ymm19 +vcvttps2dq (%rax), %ymm19 +vcvttps2dq (%rax){1to8}, %ymm19 +vcvttps2dq %ymm16,%ymm19 {k1} +vcvttps2dq (%rax),%ymm19 {k1} +vcvttps2dq (%rax){1to8}, %ymm19 {k1} +vcvttps2dq %ymm16, %ymm19 {z}{k1} +vcvttps2dq (%rax), %ymm19 {z}{k1} +vcvttps2dq (%rax){1to8}, %ymm19 {z}{k1} + +vcvttpd2udqy %ymm16, %xmm19 +vcvttpd2udqy (%rax), %xmm19 +vcvttpd2udqy (%rax){1to4}, %xmm19 +vcvttpd2udqy %ymm16, %xmm19 {k1} +vcvttpd2udqy (%rax), %xmm19 {k1} +vcvttpd2udqy (%rax){1to4}, %xmm19 {k1} +vcvttpd2udqy %ymm16, %xmm19 {z}{k1} +vcvttpd2udqy (%rax), %xmm19 {z}{k1} +vcvttpd2udqy (%rax){1to4}, %xmm19 {z}{k1} + +vcvttpd2udqx %xmm16, %xmm19 +vcvttpd2udqx (%rax), %xmm19 +vcvttpd2udqx (%rax){1to2}, %xmm19 +vcvttpd2udqx %xmm16, %xmm19 {k1} +vcvttpd2udqx (%rax), %xmm19 {k1} +vcvttpd2udqx (%rax){1to2},%xmm19 {k1} +vcvttpd2udqx %xmm16, %xmm19 {z}{k1} +vcvttpd2udqx (%rax), %xmm19 {z}{k1} +vcvttpd2udqx (%rax){1to2}, %xmm19 {z}{k1} + +vcvttps2udq %xmm16, %xmm19 +vcvttps2udq (%rax), %xmm19 +vcvttps2udq (%rax){1to4}, %xmm19 +vcvttps2udq %xmm16, %xmm19 {k1} +vcvttps2udq (%rax), %xmm19 {k1} +vcvttps2udq (%rax){1to4},%xmm19 {k1} +vcvttps2udq %xmm16, %xmm19 {z}{k1} +vcvttps2udq (%rax), %xmm19 {z}{k1} +vcvttps2udq (%rax){1to4}, %xmm19 {z}{k1} + +vcvttps2udq %ymm16, %ymm19 +vcvttps2udq (%rax), %ymm19 +vcvttps2udq (%rax){1to8}, %ymm19 +vcvttps2udq %ymm16,%ymm19 {k1} +vcvttps2udq (%rax),%ymm19 {k1} +vcvttps2udq (%rax){1to8}, %ymm19 {k1} +vcvttps2udq %ymm16, %ymm19 {z}{k1} +vcvttps2udq (%rax), %ymm19 {z}{k1} +vcvttps2udq (%rax){1to8}, %ymm19 {z}{k1} + +vdivpd %xmm16, %xmm17, %xmm19 +vdivpd (%rax), %xmm17, %xmm19 +vdivpd (%rax){1to2}, %xmm17, %xmm19 +vdivpd %xmm16, %xmm17, %xmm19 {k1} +vdivpd (%rax), %xmm17, %xmm19 {k1} +vdivpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vdivpd %xmm16, %xmm17, %xmm19 {z}{k1} +vdivpd (%rax), %xmm17, %xmm19 {z}{k1} +vdivpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vdivpd %ymm16, %ymm17, %ymm19 +vdivpd (%rax), %ymm17, %ymm19 +vdivpd (%rax){1to4}, %ymm17, %ymm19 +vdivpd %ymm16, %ymm17, %ymm19 {k1} +vdivpd (%rax), %ymm17, %ymm19 {k1} +vdivpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vdivpd %ymm16, %ymm17, %ymm19 {z}{k1} +vdivpd (%rax), %ymm17, %ymm19 {z}{k1} +vdivpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vdivps %xmm16, %xmm17, %xmm19 +vdivps (%rax), %xmm17, %xmm19 +vdivps (%rax){1to4}, %xmm17, %xmm19 +vdivps %xmm16, %xmm17, %xmm19 {k1} +vdivps (%rax), %xmm17, %xmm19 {k1} +vdivps (%rax){1to4}, %xmm17, %xmm19 {k1} +vdivps %xmm16, %xmm17, %xmm19 {z}{k1} +vdivps (%rax), %xmm17, %xmm19 {z}{k1} +vdivps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vdivps %ymm16, %ymm17, %ymm19 +vdivps (%rax), %ymm17, %ymm19 +vdivps (%rax){1to8}, %ymm17, %ymm19 +vdivps %ymm16, %ymm17, %ymm19 {k1} +vdivps (%rax), %ymm17, %ymm19 {k1} +vdivps (%rax){1to8}, %ymm17, %ymm19 {k1} +vdivps %ymm16, %ymm17, %ymm19 {z}{k1} +vdivps (%rax), %ymm17, %ymm19 {z}{k1} +vdivps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vgatherdpd (%rax,%xmm1,2), %ymm2 {k1} +vgatherdps (%rax,%ymm1,2), %ymm2 {k1} +vgatherqpd (%rax,%ymm1,2), %ymm2 {k1} +vgatherqps (%rax,%ymm1,2), %xmm2 {k1} + +vgatherdpd (%rax,%xmm1,2), %xmm2 {k1} +vgatherdps (%rax,%xmm1,2), %xmm2 {k1} +vgatherqpd (%rax,%xmm1,2), %xmm2 {k1} +vgatherqps (%rax,%xmm1,2), %xmm2 {k1} + +vmaxpd %xmm16, %xmm17, %xmm19 +vmaxpd (%rax), %xmm17, %xmm19 +vmaxpd (%rax){1to2}, %xmm17, %xmm19 +vmaxpd %xmm16, %xmm17, %xmm19 {k1} +vmaxpd (%rax), %xmm17, %xmm19 {k1} +vmaxpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vmaxpd %xmm16, %xmm17, %xmm19 {z}{k1} +vmaxpd (%rax), %xmm17, %xmm19 {z}{k1} +vmaxpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vmaxpd %ymm16, %ymm17, %ymm19 +vmaxpd (%rax), %ymm17, %ymm19 +vmaxpd (%rax){1to4}, %ymm17, %ymm19 +vmaxpd %ymm16, %ymm17, %ymm19 {k1} +vmaxpd (%rax), %ymm17, %ymm19 {k1} +vmaxpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vmaxpd %ymm16, %ymm17, %ymm19 {z}{k1} +vmaxpd (%rax), %ymm17, %ymm19 {z}{k1} +vmaxpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vmaxps %xmm16, %xmm17, %xmm19 +vmaxps (%rax), %xmm17, %xmm19 +vmaxps (%rax){1to4}, %xmm17, %xmm19 +vmaxps %xmm16, %xmm17, %xmm19 {k1} +vmaxps (%rax), %xmm17, %xmm19 {k1} +vmaxps (%rax){1to4}, %xmm17, %xmm19 {k1} +vmaxps %xmm16, %xmm17, %xmm19 {z}{k1} +vmaxps (%rax), %xmm17, %xmm19 {z}{k1} +vmaxps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vmaxps %ymm16, %ymm17, %ymm19 +vmaxps (%rax), %ymm17, %ymm19 +vmaxps (%rax){1to8}, %ymm17, %ymm19 +vmaxps %ymm16, %ymm17, %ymm19 {k1} +vmaxps (%rax), %ymm17, %ymm19 {k1} +vmaxps (%rax){1to8}, %ymm17, %ymm19 {k1} +vmaxps %ymm16, %ymm17, %ymm19 {z}{k1} +vmaxps (%rax), %ymm17, %ymm19 {z}{k1} +vmaxps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vminpd %xmm16, %xmm17, %xmm19 +vminpd (%rax), %xmm17, %xmm19 +vminpd (%rax){1to2}, %xmm17, %xmm19 +vminpd %xmm16, %xmm17, %xmm19 {k1} +vminpd (%rax), %xmm17, %xmm19 {k1} +vminpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vminpd %xmm16, %xmm17, %xmm19 {z}{k1} +vminpd (%rax), %xmm17, %xmm19 {z}{k1} +vminpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vminpd %ymm16, %ymm17, %ymm19 +vminpd (%rax), %ymm17, %ymm19 +vminpd (%rax){1to4}, %ymm17, %ymm19 +vminpd %ymm16, %ymm17, %ymm19 {k1} +vminpd (%rax), %ymm17, %ymm19 {k1} +vminpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vminpd %ymm16, %ymm17, %ymm19 {z}{k1} +vminpd (%rax), %ymm17, %ymm19 {z}{k1} +vminpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vminps %xmm16, %xmm17, %xmm19 +vminps (%rax), %xmm17, %xmm19 +vminps (%rax){1to4}, %xmm17, %xmm19 +vminps %xmm16, %xmm17, %xmm19 {k1} +vminps (%rax), %xmm17, %xmm19 {k1} +vminps (%rax){1to4}, %xmm17, %xmm19 {k1} +vminps %xmm16, %xmm17, %xmm19 {z}{k1} +vminps (%rax), %xmm17, %xmm19 {z}{k1} +vminps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vminps %ymm16, %ymm17, %ymm19 +vminps (%rax), %ymm17, %ymm19 +vminps (%rax){1to8}, %ymm17, %ymm19 +vminps %ymm16, %ymm17, %ymm19 {k1} +vminps (%rax), %ymm17, %ymm19 {k1} +vminps (%rax){1to8}, %ymm17, %ymm19 {k1} +vminps %ymm16, %ymm17, %ymm19 {z}{k1} +vminps (%rax), %ymm17, %ymm19 {z}{k1} +vminps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vmovapd %xmm16, %xmm19 +vmovapd (%rax), %xmm19 +vmovapd %xmm16, (%rax) +vmovapd %xmm16, %xmm19 {k1} +vmovapd (%rax), %xmm19 {k1} +vmovapd %xmm16, (%rax) {k1} +vmovapd %xmm16, %xmm19 {z}{k1} +vmovapd (%rax), %xmm19 {z}{k1} + +vmovapd %ymm16, %ymm19 +vmovapd (%rax), %ymm19 +vmovapd %ymm16, (%rax) +vmovapd %ymm16, %ymm19 {k1} +vmovapd (%rax), %ymm19 {k1} +vmovapd %ymm16, (%rax) {k1} +vmovapd %ymm16, %ymm19 {z}{k1} +vmovapd (%rax), %ymm19 {z}{k1} + +vmovaps %xmm16, %xmm19 +vmovaps (%rax), %xmm19 +vmovaps %xmm16, (%rax) +vmovaps %xmm16, %xmm19 {k1} +vmovaps (%rax), %xmm19 {k1} +vmovaps %xmm16, (%rax) {k1} +vmovaps %xmm16, %xmm19 {z}{k1} +vmovaps (%rax), %xmm19 {z}{k1} + +vmovaps %ymm16, %ymm19 +vmovaps (%rax), %ymm19 +vmovaps %ymm16, (%rax) +vmovaps %ymm16, %ymm19 {k1} +vmovaps (%rax), %ymm19 {k1} +vmovaps %ymm16, (%rax) {k1} +vmovaps %ymm16, %ymm19 {z}{k1} +vmovaps (%rax), %ymm19 {z}{k1} + +vmovddup %xmm16, %xmm19 +vmovddup (%rax), %xmm19 +vmovddup %xmm16, %xmm19 {k1} +vmovddup (%rax), %xmm19 {k1} +vmovddup %xmm16, %xmm19 {z}{k1} +vmovddup (%rax), %xmm19 {z}{k1} + +vmovdqa32 %xmm16, %xmm19 +vmovdqa32 (%rax), %xmm19 +vmovdqa32 %xmm16, (%rax) +vmovdqa32 %xmm16, %xmm19 {k1} +vmovdqa32 (%rax), %xmm19 {k1} +vmovdqa32 %xmm16, (%rax) {k1} +vmovdqa32 %xmm16, %xmm19 {z}{k1} +vmovdqa32 (%rax), %xmm19 {z}{k1} + +vmovdqa32 %ymm16, %ymm19 +vmovdqa32 (%rax), %ymm19 +vmovdqa32 %ymm16, (%rax) +vmovdqa32 %ymm16, %ymm19 {k1} +vmovdqa32 (%rax), %ymm19 {k1} +vmovdqa32 %ymm16, (%rax) {k1} +vmovdqa32 %ymm16, %ymm19 {z}{k1} +vmovdqa32 (%rax), %ymm19 {z}{k1} + +vmovdqa64 %xmm16, %xmm19 +vmovdqa64 (%rax), %xmm19 +vmovdqa64 %xmm16, (%rax) +vmovdqa64 %xmm16, %xmm19 {k1} +vmovdqa64 (%rax), %xmm19 {k1} +vmovdqa64 %xmm16, (%rax) {k1} +vmovdqa64 %xmm16, %xmm19 {z}{k1} +vmovdqa64 (%rax), %xmm19 {z}{k1} + +vmovdqa64 %ymm16, %ymm19 +vmovdqa64 (%rax), %ymm19 +vmovdqa64 %ymm16, (%rax) +vmovdqa64 %ymm16, %ymm19 {k1} +vmovdqa64 (%rax), %ymm19 {k1} +vmovdqa64 %ymm16, (%rax) {k1} +vmovdqa64 %ymm16, %ymm19 {z}{k1} +vmovdqa64 (%rax), %ymm19 {z}{k1} + +vmovdqu32 %xmm16, %xmm19 +vmovdqu32 (%rax), %xmm19 +vmovdqu32 %xmm16, (%rax) +vmovdqu32 %xmm16, %xmm19 {k1} +vmovdqu32 (%rax), %xmm19 {k1} +vmovdqu32 %xmm16, (%rax) {k1} +vmovdqu32 %xmm16, %xmm19 {z}{k1} +vmovdqu32 (%rax), %xmm19 {z}{k1} + +vmovdqu32 %ymm16, %ymm19 +vmovdqu32 (%rax), %ymm19 +vmovdqu32 %ymm16, (%rax) +vmovdqu32 %ymm16, %ymm19 {k1} +vmovdqu32 (%rax), %ymm19 {k1} +vmovdqu32 %ymm16, (%rax) {k1} +vmovdqu32 %ymm16, %ymm19 {z}{k1} +vmovdqu32 (%rax), %ymm19 {z}{k1} + +vmovdqu64 %xmm16, %xmm19 +vmovdqu64 (%rax), %xmm19 +vmovdqu64 %xmm16, (%rax) +vmovdqu64 %xmm16, %xmm19 {k1} +vmovdqu64 (%rax), %xmm19 {k1} +vmovdqu64 %xmm16, (%rax) {k1} +vmovdqu64 %xmm16, %xmm19 {z}{k1} +vmovdqu64 (%rax), %xmm19 {z}{k1} + +vmovdqu64 %ymm16, %ymm19 +vmovdqu64 (%rax), %ymm19 +vmovdqu64 %ymm16, (%rax) +vmovdqu64 %ymm16, %ymm19 {k1} +vmovdqu64 (%rax), %ymm19 {k1} +vmovdqu64 %ymm16, (%rax) {k1} +vmovdqu64 %ymm16, %ymm19 {z}{k1} +vmovdqu64 (%rax), %ymm19 {z}{k1} + +vmovddup %ymm16, %ymm19 +vmovddup (%rax), %ymm19 +vmovddup %ymm16, %ymm19 {k1} +vmovddup (%rax), %ymm19 {k1} +vmovddup %ymm16, %ymm19 {z}{k1} +vmovddup (%rax), %ymm19 {z}{k1} + +vmovshdup %xmm16, %xmm19 +vmovshdup (%rax), %xmm19 +vmovshdup %xmm16, %xmm19 {k1} +vmovshdup (%rax), %xmm19 {k1} +vmovshdup %xmm16, %xmm19 {z}{k1} +vmovshdup (%rax), %xmm19 {z}{k1} + +vmovshdup %ymm16, %ymm19 +vmovshdup (%rax), %ymm19 +vmovshdup %ymm16, %ymm19 {k1} +vmovshdup (%rax), %ymm19 {k1} +vmovshdup %ymm16, %ymm19 {z}{k1} +vmovshdup (%rax), %ymm19 {z}{k1} + +vmovsldup %xmm16, %xmm19 +vmovsldup (%rax), %xmm19 +vmovsldup %xmm16, %xmm19 {k1} +vmovsldup (%rax), %xmm19 {k1} +vmovsldup %xmm16, %xmm19 {z}{k1} +vmovsldup (%rax), %xmm19 {z}{k1} + +vmovsldup %ymm16, %ymm19 +vmovsldup (%rax), %ymm19 +vmovsldup %ymm16, %ymm19 {k1} +vmovsldup (%rax), %ymm19 {k1} +vmovsldup %ymm16, %ymm19 {z}{k1} +vmovsldup (%rax), %ymm19 {z}{k1} + +vmovupd %xmm16, %xmm19 +vmovupd (%rax), %xmm19 +vmovupd %xmm16, (%rax) +vmovupd %xmm16, %xmm19 {k1} +vmovupd (%rax), %xmm19 {k1} +vmovupd %xmm16, (%rax) {k1} +vmovupd %xmm16, %xmm19 {z}{k1} +vmovupd (%rax), %xmm19 {z}{k1} + +vmovupd %ymm16, %ymm19 +vmovupd (%rax), %ymm19 +vmovupd %ymm16, (%rax) +vmovupd %ymm16, %ymm19 {k1} +vmovupd (%rax), %ymm19 {k1} +vmovupd %ymm16, (%rax) {k1} +vmovupd %ymm16, %ymm19 {z}{k1} +vmovupd (%rax), %ymm19 {z}{k1} + +vmovups %xmm16, %xmm19 +vmovups (%rax), %xmm19 +vmovups %xmm16, (%rax) +vmovups %xmm16, %xmm19 {k1} +vmovups (%rax), %xmm19 {k1} +vmovups %xmm16, (%rax) {k1} +vmovups %xmm16, %xmm19 {z}{k1} +vmovups (%rax), %xmm19 {z}{k1} + +vmovups %ymm16, %ymm19 +vmovups (%rax), %ymm19 +vmovups %ymm16, (%rax) +vmovups %ymm16, %ymm19 {k1} +vmovups (%rax), %ymm19 {k1} +vmovups %ymm16, (%rax) {k1} +vmovups %ymm16, %ymm19 {z}{k1} +vmovups (%rax), %ymm19 {z}{k1} + +vmulpd %xmm16, %xmm17, %xmm19 +vmulpd (%rax), %xmm17, %xmm19 +vmulpd (%rax){1to2}, %xmm17, %xmm19 +vmulpd %xmm16, %xmm17, %xmm19 {k1} +vmulpd (%rax), %xmm17, %xmm19 {k1} +vmulpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vmulpd %xmm16, %xmm17, %xmm19 {z}{k1} +vmulpd (%rax), %xmm17, %xmm19 {z}{k1} +vmulpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vmulpd %ymm16, %ymm17, %ymm19 +vmulpd (%rax), %ymm17, %ymm19 +vmulpd (%rax){1to4}, %ymm17, %ymm19 +vmulpd %ymm16, %ymm17, %ymm19 {k1} +vmulpd (%rax), %ymm17, %ymm19 {k1} +vmulpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vmulpd %ymm16, %ymm17, %ymm19 {z}{k1} +vmulpd (%rax), %ymm17, %ymm19 {z}{k1} +vmulpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vmulps %xmm16, %xmm17, %xmm19 +vmulps (%rax), %xmm17, %xmm19 +vmulps (%rax){1to4}, %xmm17, %xmm19 +vmulps %xmm16, %xmm17, %xmm19 {k1} +vmulps (%rax), %xmm17, %xmm19 {k1} +vmulps (%rax){1to4}, %xmm17, %xmm19 {k1} +vmulps %xmm16, %xmm17, %xmm19 {z}{k1} +vmulps (%rax), %xmm17, %xmm19 {z}{k1} +vmulps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vmulps %ymm16, %ymm17, %ymm19 +vmulps (%rax), %ymm17, %ymm19 +vmulps (%rax){1to8}, %ymm17, %ymm19 +vmulps %ymm16, %ymm17, %ymm19 {k1} +vmulps (%rax), %ymm17, %ymm19 {k1} +vmulps (%rax){1to8}, %ymm17, %ymm19 {k1} +vmulps %ymm16, %ymm17, %ymm19 {z}{k1} +vmulps (%rax), %ymm17, %ymm19 {z}{k1} +vmulps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpaddd %xmm16, %xmm17, %xmm19 +vpaddd (%rax), %xmm17, %xmm19 +vpaddd (%rax){1to4}, %xmm17, %xmm19 +vpaddd %xmm16, %xmm17, %xmm19 {k1} +vpaddd (%rax), %xmm17, %xmm19 {k1} +vpaddd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpaddd %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddd (%rax), %xmm17, %xmm19 {z}{k1} +vpaddd (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpaddd %ymm16, %ymm17, %ymm19 +vpaddd (%rax), %ymm17, %ymm19 +vpaddd (%rax){1to8}, %ymm17, %ymm19 +vpaddd %ymm16, %ymm17, %ymm19 {k1} +vpaddd (%rax), %ymm17, %ymm19 {k1} +vpaddd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpaddd %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddd (%rax), %ymm17, %ymm19 {z}{k1} +vpaddd (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpaddq %xmm16, %xmm17, %xmm19 +vpaddq (%rax), %xmm17, %xmm19 +vpaddq (%rax){1to2}, %xmm17, %xmm19 +vpaddq %xmm16, %xmm17, %xmm19 {k1} +vpaddq (%rax), %xmm17, %xmm19 {k1} +vpaddq (%rax){1to2}, %xmm17, %xmm19 {k1} +vpaddq %xmm16, %xmm17, %xmm19 {z}{k1} +vpaddq (%rax), %xmm17, %xmm19 {z}{k1} +vpaddq (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vpaddq %ymm16, %ymm17, %ymm19 +vpaddq (%rax), %ymm17, %ymm19 +vpaddq (%rax){1to4}, %ymm17, %ymm19 +vpaddq %ymm16, %ymm17, %ymm19 {k1} +vpaddq (%rax), %ymm17, %ymm19 {k1} +vpaddq (%rax){1to4}, %ymm17, %ymm19 {k1} +vpaddq %ymm16, %ymm17, %ymm19 {z}{k1} +vpaddq (%rax), %ymm17, %ymm19 {z}{k1} +vpaddq (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vpbroadcastd %xmm16, %xmm19 +vpbroadcastd (%rax), %xmm19 +vpbroadcastd %xmm16, %xmm19 {k1} +vpbroadcastd (%rax), %xmm19 {k1} +vpbroadcastd %xmm16, %xmm19 {z}{k1} +vpbroadcastd (%rax), %xmm19 {z}{k1} + +vpbroadcastd %xmm16, %ymm19 +vpbroadcastd (%rax), %ymm19 +vpbroadcastd %xmm16, %ymm19 {k1} +vpbroadcastd (%rax), %ymm19 {k1} +vpbroadcastd %xmm16, %ymm19 {z}{k1} +vpbroadcastd (%rax), %ymm19 {z}{k1} + +vpbroadcastq %xmm16, %xmm19 +vpbroadcastq (%rax), %xmm19 +vpbroadcastq %xmm16, %xmm19 {k1} +vpbroadcastq (%rax), %xmm19 {k1} +vpbroadcastq %xmm16, %xmm19 {z}{k1} +vpbroadcastq (%rax), %xmm19 {z}{k1} + +vpbroadcastq %xmm16, %ymm19 +vpbroadcastq (%rax), %ymm19 +vpbroadcastq %xmm16, %ymm19 {k1} +vpbroadcastq (%rax), %ymm19 {k1} +vpbroadcastq %xmm16, %ymm19 {z}{k1} +vpbroadcastq (%rax), %ymm19 {z}{k1} + +vpcmpd $0, %xmm0, %xmm1, %k2 +vpcmpd $0, (%rax), %xmm1, %k2 +vpcmpd $0, (%rax){1to4}, %xmm1, %k2 +vpcmpd $0, %xmm0, %xmm1, %k2 {k3} +vpcmpd $0, (%rax), %xmm1, %k2 {k3} +vpcmpd $0, (%rax){1to4}, %xmm1, %k2 {k3} + +vpcmpd $0, %ymm0, %ymm1, %k2 +vpcmpd $0, (%rax), %ymm1, %k2 +vpcmpd $0, (%rax){1to8}, %ymm1, %k2 +vpcmpd $0, %ymm0, %ymm1, %k2 {k3} +vpcmpd $0, (%rax), %ymm1, %k2 {k3} +vpcmpd $0, (%rax){1to8}, %ymm1, %k2 {k3} + +vpcmpeqd %xmm0, %xmm1, %k2 +vpcmpeqd (%rax), %xmm1, %k2 +vpcmpeqd (%rax){1to4}, %xmm1, %k2 +vpcmpeqd %xmm0, %xmm1, %k2 {k3} +vpcmpeqd (%rax), %xmm1, %k2 {k3} +vpcmpeqd (%rax){1to4}, %xmm1, %k2 {k3} + +vpcmpeqd %ymm0, %ymm1, %k2 +vpcmpeqd (%rax), %ymm1, %k2 +vpcmpeqd (%rax){1to8}, %ymm1, %k2 +vpcmpeqd %ymm0, %ymm1, %k2 {k3} +vpcmpeqd (%rax), %ymm1, %k2 {k3} +vpcmpeqd (%rax){1to8}, %ymm1, %k2 {k3} + +vpcmpeqq %xmm0, %xmm1, %k2 +vpcmpeqq (%rax), %xmm1, %k2 +vpcmpeqq (%rax){1to2}, %xmm1, %k2 +vpcmpeqq %xmm0, %xmm1, %k2 {k3} +vpcmpeqq (%rax), %xmm1, %k2 {k3} +vpcmpeqq (%rax){1to2}, %xmm1, %k2 {k3} + +vpcmpeqq %ymm0, %ymm1, %k2 +vpcmpeqq (%rax), %ymm1, %k2 +vpcmpeqq (%rax){1to4}, %ymm1, %k2 +vpcmpeqq %ymm0, %ymm1, %k2 {k3} +vpcmpeqq (%rax), %ymm1, %k2 {k3} +vpcmpeqq (%rax){1to4}, %ymm1, %k2 {k3} + +vpcmpgtd %xmm0, %xmm1, %k2 +vpcmpgtd (%rax), %xmm1, %k2 +vpcmpgtd (%rax){1to4}, %xmm1, %k2 +vpcmpgtd %xmm0, %xmm1, %k2 {k3} +vpcmpgtd (%rax), %xmm1, %k2 {k3} +vpcmpgtd (%rax){1to4}, %xmm1, %k2 {k3} + +vpcmpgtd %ymm0, %ymm1, %k2 +vpcmpgtd (%rax), %ymm1, %k2 +vpcmpgtd (%rax){1to8}, %ymm1, %k2 +vpcmpgtd %ymm0, %ymm1, %k2 {k3} +vpcmpgtd (%rax), %ymm1, %k2 {k3} +vpcmpgtd (%rax){1to8}, %ymm1, %k2 {k3} + +vpcmpgtq %xmm0, %xmm1, %k2 +vpcmpgtq (%rax), %xmm1, %k2 +vpcmpgtq (%rax){1to2}, %xmm1, %k2 +vpcmpgtq %xmm0, %xmm1, %k2 {k3} +vpcmpgtq (%rax), %xmm1, %k2 {k3} +vpcmpgtq (%rax){1to2}, %xmm1, %k2 {k3} + +vpcmpgtq %ymm0, %ymm1, %k2 +vpcmpgtq (%rax), %ymm1, %k2 +vpcmpgtq (%rax){1to4}, %ymm1, %k2 +vpcmpgtq %ymm0, %ymm1, %k2 {k3} +vpcmpgtq (%rax), %ymm1, %k2 {k3} +vpcmpgtq (%rax){1to4}, %ymm1, %k2 {k3} + +vpcmpq $0, %xmm0, %xmm1, %k2 +vpcmpq $0, (%rax), %xmm1, %k2 +vpcmpq $0, (%rax){1to2}, %xmm1, %k2 +vpcmpq $0, %xmm0, %xmm1, %k2 {k3} +vpcmpq $0, (%rax), %xmm1, %k2 {k3} +vpcmpq $0, (%rax){1to2}, %xmm1, %k2 {k3} + +vpcmpq $0, %ymm0, %ymm1, %k2 +vpcmpq $0, (%rax), %ymm1, %k2 +vpcmpq $0, (%rax){1to4}, %ymm1, %k2 +vpcmpq $0, %ymm0, %ymm1, %k2 {k3} +vpcmpq $0, (%rax), %ymm1, %k2 {k3} +vpcmpq $0, (%rax){1to4}, %ymm1, %k2 {k3} + +vpcmpud $0, %xmm0, %xmm1, %k2 +vpcmpud $0, (%rax), %xmm1, %k2 +vpcmpud $0, (%rax){1to4}, %xmm1, %k2 +vpcmpud $0, %xmm0, %xmm1, %k2 {k3} +vpcmpud $0, (%rax), %xmm1, %k2 {k3} +vpcmpud $0, (%rax){1to4}, %xmm1, %k2 {k3} + +vpcmpud $0, %ymm0, %ymm1, %k2 +vpcmpud $0, (%rax), %ymm1, %k2 +vpcmpud $0, (%rax){1to8}, %ymm1, %k2 +vpcmpud $0, %ymm0, %ymm1, %k2 {k3} +vpcmpud $0, (%rax), %ymm1, %k2 {k3} +vpcmpud $0, (%rax){1to8}, %ymm1, %k2 {k3} + +vpcmpuq $0, %xmm0, %xmm1, %k2 +vpcmpuq $0, (%rax), %xmm1, %k2 +vpcmpuq $0, (%rax){1to2}, %xmm1, %k2 +vpcmpuq $0, %xmm0, %xmm1, %k2 {k3} +vpcmpuq $0, (%rax), %xmm1, %k2 {k3} +vpcmpuq $0, (%rax){1to2}, %xmm1, %k2 {k3} + +vpcmpuq $0, %ymm0, %ymm1, %k2 +vpcmpuq $0, (%rax), %ymm1, %k2 +vpcmpuq $0, (%rax){1to4}, %ymm1, %k2 +vpcmpuq $0, %ymm0, %ymm1, %k2 {k3} +vpcmpuq $0, (%rax), %ymm1, %k2 {k3} +vpcmpuq $0, (%rax){1to4}, %ymm1, %k2 {k3} + +vpermd %ymm16, %ymm17, %ymm19 +vpermd (%rax), %ymm17, %ymm19 +vpermd (%rax){1to8}, %ymm17, %ymm19 +vpermd %ymm16, %ymm17, %ymm19 {k1} +vpermd (%rax), %ymm17, %ymm19 {k1} +vpermd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpermd %ymm16, %ymm17, %ymm19 {z}{k1} +vpermd (%rax), %ymm17, %ymm19 {z}{k1} +vpermd (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpermilpd $0, %xmm16, %xmm19 +vpermilpd $0, (%rax), %xmm19 +vpermilpd $0, (%rax){1to2}, %xmm19 +vpermilpd $0, %xmm16, %xmm19 {k1} +vpermilpd $0, (%rax), %xmm19 {k1} +vpermilpd $0, (%rax){1to2}, %xmm19 {k1} +vpermilpd $0, %xmm16, %xmm19 {z}{k1} +vpermilpd $0, (%rax), %xmm19 {z}{k1} +vpermilpd $0, (%rax){1to2}, %xmm19 {z}{k1} + +vpermilpd $0, %ymm16, %ymm19 +vpermilpd $0, (%rax), %ymm19 +vpermilpd $0, (%rax){1to4}, %ymm19 +vpermilpd $0, %ymm16, %ymm19 {k1} +vpermilpd $0, (%rax), %ymm19 {k1} +vpermilpd $0, (%rax){1to4}, %ymm19 {k1} +vpermilpd $0, %ymm16, %ymm19 {z}{k1} +vpermilpd $0, (%rax), %ymm19 {z}{k1} +vpermilpd $0, (%rax){1to4}, %ymm19 {z}{k1} + +vpermilpd %xmm16, %xmm17, %xmm19 +vpermilpd (%rax), %xmm17, %xmm19 +vpermilpd (%rax){1to2}, %xmm17, %xmm19 +vpermilpd %xmm16, %xmm17, %xmm19 {k1} +vpermilpd (%rax), %xmm17, %xmm19 {k1} +vpermilpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vpermilpd %xmm16, %xmm17, %xmm19 {z}{k1} +vpermilpd (%rax), %xmm17, %xmm19 {z}{k1} +vpermilpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vpermilpd %ymm16, %ymm17, %ymm19 +vpermilpd (%rax), %ymm17, %ymm19 +vpermilpd (%rax){1to4}, %ymm17, %ymm19 +vpermilpd %ymm16, %ymm17, %ymm19 {k1} +vpermilpd (%rax), %ymm17, %ymm19 {k1} +vpermilpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vpermilpd %ymm16, %ymm17, %ymm19 {z}{k1} +vpermilpd (%rax), %ymm17, %ymm19 {z}{k1} +vpermilpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vpermilps $0, %xmm16, %xmm19 +vpermilps $0, (%rax), %xmm19 +vpermilps $0, (%rax){1to4}, %xmm19 +vpermilps $0, %xmm16, %xmm19 {k1} +vpermilps $0, (%rax), %xmm19 {k1} +vpermilps $0, (%rax){1to4}, %xmm19 {k1} +vpermilps $0, %xmm16, %xmm19 {z}{k1} +vpermilps $0, (%rax), %xmm19 {z}{k1} +vpermilps $0, (%rax){1to4}, %xmm19 {z}{k1} + +vpermilps $0, %ymm16, %ymm19 +vpermilps $0, (%rax), %ymm19 +vpermilps $0, (%rax){1to8}, %ymm19 +vpermilps $0, %ymm16, %ymm19 {k1} +vpermilps $0, (%rax), %ymm19 {k1} +vpermilps $0, (%rax){1to8}, %ymm19 {k1} +vpermilps $0, %ymm16, %ymm19 {z}{k1} +vpermilps $0, (%rax), %ymm19 {z}{k1} +vpermilps $0, (%rax){1to8}, %ymm19 {z}{k1} + +vpermilps %xmm16, %xmm17, %xmm19 +vpermilps (%rax), %xmm17, %xmm19 +vpermilps (%rax){1to4}, %xmm17, %xmm19 +vpermilps %xmm16, %xmm17, %xmm19 {k1} +vpermilps (%rax), %xmm17, %xmm19 {k1} +vpermilps (%rax){1to4}, %xmm17, %xmm19 {k1} +vpermilps %xmm16, %xmm17, %xmm19 {z}{k1} +vpermilps (%rax), %xmm17, %xmm19 {z}{k1} +vpermilps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpermilps %ymm16, %ymm17, %ymm19 +vpermilps (%rax), %ymm17, %ymm19 +vpermilps (%rax){1to8}, %ymm17, %ymm19 +vpermilps %ymm16, %ymm17, %ymm19 {k1} +vpermilps (%rax), %ymm17, %ymm19 {k1} +vpermilps (%rax){1to8}, %ymm17, %ymm19 {k1} +vpermilps %ymm16, %ymm17, %ymm19 {z}{k1} +vpermilps (%rax), %ymm17, %ymm19 {z}{k1} +vpermilps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpermpd $0, %ymm16, %ymm19 +vpermpd $0, (%rax), %ymm19 +vpermpd $0, (%rax){1to4}, %ymm19 +vpermpd $0, %ymm16, %ymm19 {k1} +vpermpd $0, (%rax), %ymm19 {k1} +vpermpd $0, (%rax){1to4}, %ymm19 {k1} +vpermpd $0, %ymm16, %ymm19 {z}{k1} +vpermpd $0, (%rax), %ymm19 {z}{k1} +vpermpd $0, (%rax){1to4}, %ymm19 {z}{k1} + +vpermpd %ymm16, %ymm17, %ymm19 +vpermpd (%rax), %ymm17, %ymm19 +vpermpd (%rax){1to4}, %ymm17, %ymm19 +vpermpd %ymm16, %ymm17, %ymm19 {k1} +vpermpd (%rax), %ymm17, %ymm19 {k1} +vpermpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vpermpd %ymm16, %ymm17, %ymm19 {z}{k1} +vpermpd (%rax), %ymm17, %ymm19 {z}{k1} +vpermpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vpermps %ymm16, %ymm17, %ymm19 +vpermps (%rax), %ymm17, %ymm19 +vpermps (%rax){1to8}, %ymm17, %ymm19 +vpermps %ymm16, %ymm17, %ymm19 {k1} +vpermps (%rax), %ymm17, %ymm19 {k1} +vpermps (%rax){1to8}, %ymm17, %ymm19 {k1} +vpermps %ymm16, %ymm17, %ymm19 {z}{k1} +vpermps (%rax), %ymm17, %ymm19 {z}{k1} +vpermps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpermq $0, %ymm16, %ymm19 +vpermq $0, (%rax), %ymm19 +vpermq $0, (%rax){1to4}, %ymm19 +vpermq $0, %ymm16, %ymm19 {k1} +vpermq $0, (%rax), %ymm19 {k1} +vpermq $0, (%rax){1to4}, %ymm19 {k1} +vpermq $0, %ymm16, %ymm19 {z}{k1} +vpermq $0, (%rax), %ymm19 {z}{k1} +vpermq $0, (%rax){1to4}, %ymm19 {z}{k1} + +vpermq %ymm16, %ymm17, %ymm19 +vpermq (%rax), %ymm17, %ymm19 +vpermq (%rax){1to4}, %ymm17, %ymm19 +vpermq %ymm16, %ymm17, %ymm19 {k1} +vpermq (%rax), %ymm17, %ymm19 {k1} +vpermq (%rax){1to4}, %ymm17, %ymm19 {k1} +vpermq %ymm16, %ymm17, %ymm19 {z}{k1} +vpermq (%rax), %ymm17, %ymm19 {z}{k1} +vpermq (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vpgatherdq (%rax,%xmm1,2), %ymm2 {k1} +vpgatherdd (%rax,%ymm1,2), %ymm2 {k1} +vpgatherqq (%rax,%ymm1,2), %ymm2 {k1} +vpgatherqd (%rax,%ymm1,2), %xmm2 {k1} + +vpgatherdq (%rax,%xmm1,2), %xmm2 {k1} +vpgatherdd (%rax,%xmm1,2), %xmm2 {k1} +vpgatherqq (%rax,%xmm1,2), %xmm2 {k1} +vpgatherqd (%rax,%xmm1,2), %xmm2 {k1} + +vpmovsxbd %xmm16, %xmm19 +vpmovsxbd (%rax), %xmm19 +vpmovsxbd %xmm16, %xmm19 {k1} +vpmovsxbd (%rax), %xmm19 {k1} +vpmovsxbd %xmm16, %xmm19 {z}{k1} +vpmovsxbd (%rax), %xmm19 {z}{k1} + +vpmovsxbd %xmm16, %ymm19 +vpmovsxbd (%rax), %ymm19 +vpmovsxbd %xmm16, %ymm19 {k1} +vpmovsxbd (%rax), %ymm19 {k1} +vpmovsxbd %xmm16, %ymm19 {z}{k1} +vpmovsxbd (%rax), %ymm19 {z}{k1} + +vpmovsxbq %xmm16, %xmm19 +vpmovsxbq (%rax), %xmm19 +vpmovsxbq %xmm16, %xmm19 {k1} +vpmovsxbq (%rax), %xmm19 {k1} +vpmovsxbq %xmm16, %xmm19 {z}{k1} +vpmovsxbq (%rax), %xmm19 {z}{k1} + +vpmovsxbq %xmm16, %ymm19 +vpmovsxbq (%rax), %ymm19 +vpmovsxbq %xmm16, %ymm19 {k1} +vpmovsxbq (%rax), %ymm19 {k1} +vpmovsxbq %xmm16, %ymm19 {z}{k1} +vpmovsxbq (%rax), %ymm19 {z}{k1} + +vpmovsxdq %xmm16, %xmm19 +vpmovsxdq (%rax), %xmm19 +vpmovsxdq %xmm16, %xmm19 {k1} +vpmovsxdq (%rax), %xmm19 {k1} +vpmovsxdq %xmm16, %xmm19 {z}{k1} +vpmovsxdq (%rax), %xmm19 {z}{k1} + +vpmovsxdq %xmm16, %ymm19 +vpmovsxdq (%rax), %ymm19 +vpmovsxdq %xmm16, %ymm19 {k1} +vpmovsxdq (%rax), %ymm19 {k1} +vpmovsxdq %xmm16, %ymm19 {z}{k1} +vpmovsxdq (%rax), %ymm19 {z}{k1} + +vpmovsxwd %xmm16, %xmm19 +vpmovsxwd (%rax), %xmm19 +vpmovsxwd %xmm16, %xmm19 {k1} +vpmovsxwd (%rax), %xmm19 {k1} +vpmovsxwd %xmm16, %xmm19 {z}{k1} +vpmovsxwd (%rax), %xmm19 {z}{k1} + +vpmovsxwd %xmm16, %ymm19 +vpmovsxwd (%rax), %ymm19 +vpmovsxwd %xmm16, %ymm19 {k1} +vpmovsxwd (%rax), %ymm19 {k1} +vpmovsxwd %xmm16, %ymm19 {z}{k1} +vpmovsxwd (%rax), %ymm19 {z}{k1} + +vpmovsxwq %xmm16, %xmm19 +vpmovsxwq (%rax), %xmm19 +vpmovsxwq %xmm16, %xmm19 {k1} +vpmovsxwq (%rax), %xmm19 {k1} +vpmovsxwq %xmm16, %xmm19 {z}{k1} +vpmovsxwq (%rax), %xmm19 {z}{k1} + +vpmovsxwq %xmm16, %ymm19 +vpmovsxwq (%rax), %ymm19 +vpmovsxwq %xmm16, %ymm19 {k1} +vpmovsxwq (%rax), %ymm19 {k1} +vpmovsxwq %xmm16, %ymm19 {z}{k1} +vpmovsxwq (%rax), %ymm19 {z}{k1} + +vpmovzxbd %xmm16, %xmm19 +vpmovzxbd (%rax), %xmm19 +vpmovzxbd %xmm16, %xmm19 {k1} +vpmovzxbd (%rax), %xmm19 {k1} +vpmovzxbd %xmm16, %xmm19 {z}{k1} +vpmovzxbd (%rax), %xmm19 {z}{k1} + +vpmovzxbd %xmm16, %ymm19 +vpmovzxbd (%rax), %ymm19 +vpmovzxbd %xmm16, %ymm19 {k1} +vpmovzxbd (%rax), %ymm19 {k1} +vpmovzxbd %xmm16, %ymm19 {z}{k1} +vpmovzxbd (%rax), %ymm19 {z}{k1} + +vpmovzxbq %xmm16, %xmm19 +vpmovzxbq (%rax), %xmm19 +vpmovzxbq %xmm16, %xmm19 {k1} +vpmovzxbq (%rax), %xmm19 {k1} +vpmovzxbq %xmm16, %xmm19 {z}{k1} +vpmovzxbq (%rax), %xmm19 {z}{k1} + +vpmovzxbq %xmm16, %ymm19 +vpmovzxbq (%rax), %ymm19 +vpmovzxbq %xmm16, %ymm19 {k1} +vpmovzxbq (%rax), %ymm19 {k1} +vpmovzxbq %xmm16, %ymm19 {z}{k1} +vpmovzxbq (%rax), %ymm19 {z}{k1} + +vpmovzxdq %xmm16, %xmm19 +vpmovzxdq (%rax), %xmm19 +vpmovzxdq %xmm16, %xmm19 {k1} +vpmovzxdq (%rax), %xmm19 {k1} +vpmovzxdq %xmm16, %xmm19 {z}{k1} +vpmovzxdq (%rax), %xmm19 {z}{k1} + +vpmovzxdq %xmm16, %ymm19 +vpmovzxdq (%rax), %ymm19 +vpmovzxdq %xmm16, %ymm19 {k1} +vpmovzxdq (%rax), %ymm19 {k1} +vpmovzxdq %xmm16, %ymm19 {z}{k1} +vpmovzxdq (%rax), %ymm19 {z}{k1} + +vpmovzxwd %xmm16, %xmm19 +vpmovzxwd (%rax), %xmm19 +vpmovzxwd %xmm16, %xmm19 {k1} +vpmovzxwd (%rax), %xmm19 {k1} +vpmovzxwd %xmm16, %xmm19 {z}{k1} +vpmovzxwd (%rax), %xmm19 {z}{k1} + +vpmovzxwd %xmm16, %ymm19 +vpmovzxwd (%rax), %ymm19 +vpmovzxwd %xmm16, %ymm19 {k1} +vpmovzxwd (%rax), %ymm19 {k1} +vpmovzxwd %xmm16, %ymm19 {z}{k1} +vpmovzxwd (%rax), %ymm19 {z}{k1} + +vpmovzxwq %xmm16, %xmm19 +vpmovzxwq (%rax), %xmm19 +vpmovzxwq %xmm16, %xmm19 {k1} +vpmovzxwq (%rax), %xmm19 {k1} +vpmovzxwq %xmm16, %xmm19 {z}{k1} +vpmovzxwq (%rax), %xmm19 {z}{k1} + +vpmovzxwq %xmm16, %ymm19 +vpmovzxwq (%rax), %ymm19 +vpmovzxwq %xmm16, %ymm19 {k1} +vpmovzxwq (%rax), %ymm19 {k1} +vpmovzxwq %xmm16, %ymm19 {z}{k1} +vpmovzxwq (%rax), %ymm19 {z}{k1} + +vpmulld %xmm16, %xmm17, %xmm19 +vpmulld (%rax), %xmm17, %xmm19 +vpmulld (%rax){1to4}, %xmm17, %xmm19 +vpmulld %xmm16, %xmm17, %xmm19 {k1} +vpmulld (%rax), %xmm17, %xmm19 {k1} +vpmulld (%rax){1to4}, %xmm17, %xmm19 {k1} +vpmulld %xmm16, %xmm17, %xmm19 {z}{k1} +vpmulld (%rax), %xmm17, %xmm19 {z}{k1} +vpmulld (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpmulld %ymm16, %ymm17, %ymm19 +vpmulld (%rax), %ymm17, %ymm19 +vpmulld (%rax){1to8}, %ymm17, %ymm19 +vpmulld %ymm16, %ymm17, %ymm19 {k1} +vpmulld (%rax), %ymm17, %ymm19 {k1} +vpmulld (%rax){1to8}, %ymm17, %ymm19 {k1} +vpmulld %ymm16, %ymm17, %ymm19 {z}{k1} +vpmulld (%rax), %ymm17, %ymm19 {z}{k1} +vpmulld (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpshufd $0, %xmm16, %xmm19 +vpshufd $0, (%rax), %xmm19 +vpshufd $0, (%rax){1to4}, %xmm19 +vpshufd $0, %xmm16, %xmm19 {k1} +vpshufd $0, (%rax), %xmm19 {k1} +vpshufd $0, (%rax){1to4}, %xmm19 {k1} +vpshufd $0, %xmm16, %xmm19 {z}{k1} +vpshufd $0, (%rax), %xmm19 {z}{k1} +vpshufd $0, (%rax){1to4}, %xmm19 {z}{k1} + +vpshufd $0, %ymm16, %ymm19 +vpshufd $0, (%rax), %ymm19 +vpshufd $0, (%rax){1to8}, %ymm19 +vpshufd $0, %ymm16, %ymm19 {k1} +vpshufd $0, (%rax), %ymm19 {k1} +vpshufd $0, (%rax){1to8}, %ymm19 {k1} +vpshufd $0, %ymm16, %ymm19 {z}{k1} +vpshufd $0, (%rax), %ymm19 {z}{k1} +vpshufd $0, (%rax){1to8}, %ymm19 {z}{k1} + +vpsubd %xmm16, %xmm17, %xmm19 +vpsubd (%rax), %xmm17, %xmm19 +vpsubd (%rax){1to4}, %xmm17, %xmm19 +vpsubd %xmm16, %xmm17, %xmm19 {k1} +vpsubd (%rax), %xmm17, %xmm19 {k1} +vpsubd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpsubd %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubd (%rax), %xmm17, %xmm19 {z}{k1} +vpsubd (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpsubd %ymm16, %ymm17, %ymm19 +vpsubd (%rax), %ymm17, %ymm19 +vpsubd (%rax){1to8}, %ymm17, %ymm19 +vpsubd %ymm16, %ymm17, %ymm19 {k1} +vpsubd (%rax), %ymm17, %ymm19 {k1} +vpsubd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpsubd %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubd (%rax), %ymm17, %ymm19 {z}{k1} +vpsubd (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpsubq %xmm16, %xmm17, %xmm19 +vpsubq (%rax), %xmm17, %xmm19 +vpsubq (%rax){1to2}, %xmm17, %xmm19 +vpsubq %xmm16, %xmm17, %xmm19 {k1} +vpsubq (%rax), %xmm17, %xmm19 {k1} +vpsubq (%rax){1to2}, %xmm17, %xmm19 {k1} +vpsubq %xmm16, %xmm17, %xmm19 {z}{k1} +vpsubq (%rax), %xmm17, %xmm19 {z}{k1} +vpsubq (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vpsubq %ymm16, %ymm17, %ymm19 +vpsubq (%rax), %ymm17, %ymm19 +vpsubq (%rax){1to4}, %ymm17, %ymm19 +vpsubq %ymm16, %ymm17, %ymm19 {k1} +vpsubq (%rax), %ymm17, %ymm19 {k1} +vpsubq (%rax){1to4}, %ymm17, %ymm19 {k1} +vpsubq %ymm16, %ymm17, %ymm19 {z}{k1} +vpsubq (%rax), %ymm17, %ymm19 {z}{k1} +vpsubq (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vptestmd %xmm0, %xmm1, %k2 +vptestmd (%rax), %xmm1, %k2 +vptestmd (%rax){1to4}, %xmm1, %k2 +vptestmd %xmm0, %xmm1, %k2 {k3} +vptestmd (%rax), %xmm1, %k2 {k3} +vptestmd (%rax){1to4}, %xmm1, %k2 {k3} + +vptestmd %ymm0, %ymm1, %k2 +vptestmd (%rax), %ymm1, %k2 +vptestmd (%rax){1to8}, %ymm1, %k2 +vptestmd %ymm0, %ymm1, %k2 {k3} +vptestmd (%rax), %ymm1, %k2 {k3} +vptestmd (%rax){1to8}, %ymm1, %k2 {k3} + +vptestmq %xmm0, %xmm1, %k2 +vptestmq (%rax), %xmm1, %k2 +vptestmq (%rax){1to2}, %xmm1, %k2 +vptestmq %xmm0, %xmm1, %k2 {k3} +vptestmq (%rax), %xmm1, %k2 {k3} +vptestmq (%rax){1to2}, %xmm1, %k2 {k3} + +vptestmq %ymm0, %ymm1, %k2 +vptestmq (%rax), %ymm1, %k2 +vptestmq (%rax){1to4}, %ymm1, %k2 +vptestmq %ymm0, %ymm1, %k2 {k3} +vptestmq (%rax), %ymm1, %k2 {k3} +vptestmq (%rax){1to4}, %ymm1, %k2 {k3} + +vptestnmd %xmm0, %xmm1, %k2 +vptestnmd (%rax), %xmm1, %k2 +vptestnmd (%rax){1to4}, %xmm1, %k2 +vptestnmd %xmm0, %xmm1, %k2 {k3} +vptestnmd (%rax), %xmm1, %k2 {k3} +vptestnmd (%rax){1to4}, %xmm1, %k2 {k3} + +vptestnmd %ymm0, %ymm1, %k2 +vptestnmd (%rax), %ymm1, %k2 +vptestnmd (%rax){1to8}, %ymm1, %k2 +vptestnmd %ymm0, %ymm1, %k2 {k3} +vptestnmd (%rax), %ymm1, %k2 {k3} +vptestnmd (%rax){1to8}, %ymm1, %k2 {k3} + +vptestnmq %xmm0, %xmm1, %k2 +vptestnmq (%rax), %xmm1, %k2 +vptestnmq (%rax){1to2}, %xmm1, %k2 +vptestnmq %xmm0, %xmm1, %k2 {k3} +vptestnmq (%rax), %xmm1, %k2 {k3} +vptestnmq (%rax){1to2}, %xmm1, %k2 {k3} + +vptestnmq %ymm0, %ymm1, %k2 +vptestnmq (%rax), %ymm1, %k2 +vptestnmq (%rax){1to4}, %ymm1, %k2 +vptestnmq %ymm0, %ymm1, %k2 {k3} +vptestnmq (%rax), %ymm1, %k2 {k3} +vptestnmq (%rax){1to4}, %ymm1, %k2 {k3} + +vpunpckhdq %xmm16, %xmm17, %xmm19 +vpunpckhdq (%rax), %xmm17, %xmm19 +vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 +vpunpckhdq %xmm16, %xmm17, %xmm19 {k1} +vpunpckhdq (%rax), %xmm17, %xmm19 {k1} +vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {k1} +vpunpckhdq %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpckhdq (%rax), %xmm17, %xmm19 {z}{k1} +vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpunpckhdq %ymm16, %ymm17, %ymm19 +vpunpckhdq (%rax), %ymm17, %ymm19 +vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 +vpunpckhdq %ymm16, %ymm17, %ymm19 {k1} +vpunpckhdq (%rax), %ymm17, %ymm19 {k1} +vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {k1} +vpunpckhdq %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpckhdq (%rax), %ymm17, %ymm19 {z}{k1} +vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpunpckldq %xmm16, %xmm17, %xmm19 +vpunpckldq (%rax), %xmm17, %xmm19 +vpunpckldq (%rax){1to4}, %xmm17, %xmm19 +vpunpckldq %xmm16, %xmm17, %xmm19 {k1} +vpunpckldq (%rax), %xmm17, %xmm19 {k1} +vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {k1} +vpunpckldq %xmm16, %xmm17, %xmm19 {z}{k1} +vpunpckldq (%rax), %xmm17, %xmm19 {z}{k1} +vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpunpckldq %ymm16, %ymm17, %ymm19 +vpunpckldq (%rax), %ymm17, %ymm19 +vpunpckldq (%rax){1to8}, %ymm17, %ymm19 +vpunpckldq %ymm16, %ymm17, %ymm19 {k1} +vpunpckldq (%rax), %ymm17, %ymm19 {k1} +vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {k1} +vpunpckldq %ymm16, %ymm17, %ymm19 {z}{k1} +vpunpckldq (%rax), %ymm17, %ymm19 {z}{k1} +vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vshuff32x4 $0, %ymm16, %ymm17, %ymm19 +vshuff32x4 $0, (%rax), %ymm17, %ymm19 +vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {k1} +vshuff32x4 $0, (%rax), %ymm17, %ymm19 {k1} +vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {k1} +vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vshuff32x4 $0, (%rax), %ymm17, %ymm19 {z}{k1} +vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vshuff64x2 $0, %ymm16, %ymm17, %ymm19 +vshuff64x2 $0, (%rax), %ymm17, %ymm19 +vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {k1} +vshuff64x2 $0, (%rax), %ymm17, %ymm19 {k1} +vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {k1} +vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vshuff64x2 $0, (%rax), %ymm17, %ymm19 {z}{k1} +vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vshufi32x4 $0, %ymm16, %ymm17, %ymm19 +vshufi32x4 $0, (%rax), %ymm17, %ymm19 +vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {k1} +vshufi32x4 $0, (%rax), %ymm17, %ymm19 {k1} +vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {k1} +vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vshufi32x4 $0, (%rax), %ymm17, %ymm19 {z}{k1} +vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vshufi64x2 $0, %ymm16, %ymm17, %ymm19 +vshufi64x2 $0, (%rax), %ymm17, %ymm19 +vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {k1} +vshufi64x2 $0, (%rax), %ymm17, %ymm19 {k1} +vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {k1} +vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {z}{k1} +vshufi64x2 $0, (%rax), %ymm17, %ymm19 {z}{k1} +vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vsqrtpd %xmm16, %xmm19 +vsqrtpd (%rax), %xmm19 +vsqrtpd (%rax){1to2}, %xmm19 +vsqrtpd %xmm16, %xmm19 {k1} +vsqrtpd (%rax), %xmm19 {k1} +vsqrtpd (%rax){1to2}, %xmm19 {k1} +vsqrtpd %xmm16, %xmm19 {z}{k1} +vsqrtpd (%rax), %xmm19 {z}{k1} +vsqrtpd (%rax){1to2}, %xmm19 {z}{k1} + +vsqrtpd %ymm16, %ymm19 +vsqrtpd (%rax), %ymm19 +vsqrtpd (%rax){1to4}, %ymm19 +vsqrtpd %ymm16, %ymm19 {k1} +vsqrtpd (%rax), %ymm19 {k1} +vsqrtpd (%rax){1to4}, %ymm19 {k1} +vsqrtpd %ymm16, %ymm19 {z}{k1} +vsqrtpd (%rax), %ymm19 {z}{k1} +vsqrtpd (%rax){1to4}, %ymm19 {z}{k1} + +vsqrtps %xmm16, %xmm19 +vsqrtps (%rax), %xmm19 +vsqrtps (%rax){1to4}, %xmm19 +vsqrtps %xmm16, %xmm19 {k1} +vsqrtps (%rax), %xmm19 {k1} +vsqrtps (%rax){1to4}, %xmm19 {k1} +vsqrtps %xmm16, %xmm19 {z}{k1} +vsqrtps (%rax), %xmm19 {z}{k1} +vsqrtps (%rax){1to4}, %xmm19 {z}{k1} + +vsqrtps %ymm16, %ymm19 +vsqrtps (%rax), %ymm19 +vsqrtps (%rax){1to8}, %ymm19 +vsqrtps %ymm16, %ymm19 {k1} +vsqrtps (%rax), %ymm19 {k1} +vsqrtps (%rax){1to8}, %ymm19 {k1} +vsqrtps %ymm16, %ymm19 {z}{k1} +vsqrtps (%rax), %ymm19 {z}{k1} +vsqrtps (%rax){1to8}, %ymm19 {z}{k1} + +vsubpd %xmm16, %xmm17, %xmm19 +vsubpd (%rax), %xmm17, %xmm19 +vsubpd (%rax){1to2}, %xmm17, %xmm19 +vsubpd %xmm16, %xmm17, %xmm19 {k1} +vsubpd (%rax), %xmm17, %xmm19 {k1} +vsubpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vsubpd %xmm16, %xmm17, %xmm19 {z}{k1} +vsubpd (%rax), %xmm17, %xmm19 {z}{k1} +vsubpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vsubpd %ymm16, %ymm17, %ymm19 +vsubpd (%rax), %ymm17, %ymm19 +vsubpd (%rax){1to4}, %ymm17, %ymm19 +vsubpd %ymm16, %ymm17, %ymm19 {k1} +vsubpd (%rax), %ymm17, %ymm19 {k1} +vsubpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vsubpd %ymm16, %ymm17, %ymm19 {z}{k1} +vsubpd (%rax), %ymm17, %ymm19 {z}{k1} +vsubpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vsubps %xmm16, %xmm17, %xmm19 +vsubps (%rax), %xmm17, %xmm19 +vsubps (%rax){1to4}, %xmm17, %xmm19 +vsubps %xmm16, %xmm17, %xmm19 {k1} +vsubps (%rax), %xmm17, %xmm19 {k1} +vsubps (%rax){1to4}, %xmm17, %xmm19 {k1} +vsubps %xmm16, %xmm17, %xmm19 {z}{k1} +vsubps (%rax), %xmm17, %xmm19 {z}{k1} +vsubps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vsubps %ymm16, %ymm17, %ymm19 +vsubps (%rax), %ymm17, %ymm19 +vsubps (%rax){1to8}, %ymm17, %ymm19 +vsubps %ymm16, %ymm17, %ymm19 {k1} +vsubps (%rax), %ymm17, %ymm19 {k1} +vsubps (%rax){1to8}, %ymm17, %ymm19 {k1} +vsubps %ymm16, %ymm17, %ymm19 {z}{k1} +vsubps (%rax), %ymm17, %ymm19 {z}{k1} +vsubps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vunpckhpd %xmm16, %xmm17, %xmm19 +vunpckhpd (%rax), %xmm17, %xmm19 +vunpckhpd (%rax){1to2}, %xmm17, %xmm19 +vunpckhpd %xmm16, %xmm17, %xmm19 {k1} +vunpckhpd (%rax), %xmm17, %xmm19 {k1} +vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vunpckhpd %xmm16, %xmm17, %xmm19 {z}{k1} +vunpckhpd (%rax), %xmm17, %xmm19 {z}{k1} +vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vunpckhpd %ymm16, %ymm17, %ymm19 +vunpckhpd (%rax), %ymm17, %ymm19 +vunpckhpd (%rax){1to4}, %ymm17, %ymm19 +vunpckhpd %ymm16, %ymm17, %ymm19 {k1} +vunpckhpd (%rax), %ymm17, %ymm19 {k1} +vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vunpckhpd %ymm16, %ymm17, %ymm19 {z}{k1} +vunpckhpd (%rax), %ymm17, %ymm19 {z}{k1} +vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vunpckhps %xmm16, %xmm17, %xmm19 +vunpckhps (%rax), %xmm17, %xmm19 +vunpckhps (%rax){1to4}, %xmm17, %xmm19 +vunpckhps %xmm16, %xmm17, %xmm19 {k1} +vunpckhps (%rax), %xmm17, %xmm19 {k1} +vunpckhps (%rax){1to4}, %xmm17, %xmm19 {k1} +vunpckhps %xmm16, %xmm17, %xmm19 {z}{k1} +vunpckhps (%rax), %xmm17, %xmm19 {z}{k1} +vunpckhps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vunpckhps %ymm16, %ymm17, %ymm19 +vunpckhps (%rax), %ymm17, %ymm19 +vunpckhps (%rax){1to8}, %ymm17, %ymm19 +vunpckhps %ymm16, %ymm17, %ymm19 {k1} +vunpckhps (%rax), %ymm17, %ymm19 {k1} +vunpckhps (%rax){1to8}, %ymm17, %ymm19 {k1} +vunpckhps %ymm16, %ymm17, %ymm19 {z}{k1} +vunpckhps (%rax), %ymm17, %ymm19 {z}{k1} +vunpckhps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vunpcklpd %xmm16, %xmm17, %xmm19 +vunpcklpd (%rax), %xmm17, %xmm19 +vunpcklpd (%rax){1to2}, %xmm17, %xmm19 +vunpcklpd %xmm16, %xmm17, %xmm19 {k1} +vunpcklpd (%rax), %xmm17, %xmm19 {k1} +vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {k1} +vunpcklpd %xmm16, %xmm17, %xmm19 {z}{k1} +vunpcklpd (%rax), %xmm17, %xmm19 {z}{k1} +vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {z}{k1} + +vunpcklpd %ymm16, %ymm17, %ymm19 +vunpcklpd (%rax), %ymm17, %ymm19 +vunpcklpd (%rax){1to4}, %ymm17, %ymm19 +vunpcklpd %ymm16, %ymm17, %ymm19 {k1} +vunpcklpd (%rax), %ymm17, %ymm19 {k1} +vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {k1} +vunpcklpd %ymm16, %ymm17, %ymm19 {z}{k1} +vunpcklpd (%rax), %ymm17, %ymm19 {z}{k1} +vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {z}{k1} + +vunpcklps %xmm16, %xmm17, %xmm19 +vunpcklps (%rax), %xmm17, %xmm19 +vunpcklps (%rax){1to4}, %xmm17, %xmm19 +vunpcklps %xmm16, %xmm17, %xmm19 {k1} +vunpcklps (%rax), %xmm17, %xmm19 {k1} +vunpcklps (%rax){1to4}, %xmm17, %xmm19 {k1} +vunpcklps %xmm16, %xmm17, %xmm19 {z}{k1} +vunpcklps (%rax), %xmm17, %xmm19 {z}{k1} +vunpcklps (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vunpcklps %ymm16, %ymm17, %ymm19 +vunpcklps (%rax), %ymm17, %ymm19 +vunpcklps (%rax){1to8}, %ymm17, %ymm19 +vunpcklps %ymm16, %ymm17, %ymm19 {k1} +vunpcklps (%rax), %ymm17, %ymm19 {k1} +vunpcklps (%rax){1to8}, %ymm17, %ymm19 {k1} +vunpcklps %ymm16, %ymm17, %ymm19 {z}{k1} +vunpcklps (%rax), %ymm17, %ymm19 {z}{k1} +vunpcklps (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 0.50 vaddpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vaddpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vaddpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vaddpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vaddpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vaddps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vaddps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vaddps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vaddps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vaddps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vaddps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vaddps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 valignd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 valignd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 valignd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * valignd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 valignd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 valignd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 valignd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 valignq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 valignq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 valignq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * valignq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 valignq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 valignq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 valignq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * valignq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcastf32x4 (%rax), %ymm19 +# CHECK-NEXT: 2 9 0.33 * vbroadcastf32x4 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcastf32x4 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 8 0.33 * vbroadcasti32x4 (%rax), %ymm19 +# CHECK-NEXT: 2 9 0.33 * vbroadcasti32x4 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcasti32x4 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastsd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcastsd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastsd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vbroadcastsd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vbroadcastss %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vbroadcastss (%rax), %xmm19 +# CHECK-NEXT: 1 1 1.00 vbroadcastss %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vbroadcastss (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vbroadcastss %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vbroadcastss (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vbroadcastss (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vbroadcastss (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vbroadcastss %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vbroadcastss (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqpd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqpd (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqps %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqps %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vcmpeqps %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vcmpeqps %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vcmpeqps (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 5 1.00 vcvtdq2pd %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtdq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtdq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtdq2pd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtdq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtdq2ps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtdq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %ymm16, %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dqy (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2dq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtpd2dq %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dqx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtpd2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtpd2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2dq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %ymm16, %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2psy (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2psy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2psy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtpd2ps %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2psx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtpd2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtpd2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %ymm16, %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udqy (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtpd2udq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvtpd2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtpd2udq %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udqx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtpd2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtpd2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvtpd2udq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtps2dq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvtps2pd %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvtps2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvtps2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %xmm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvtps2pd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvtps2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvtps2udq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvtps2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %ymm16, %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dqy (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttpd2dq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvttpd2dq %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dqx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvttpd2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvttpd2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2dq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttps2dq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %ymm16, %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udqy (%rax), %xmm19 +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 2 7 1.00 vcvttpd2udq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 15 1.00 * vcvttpd2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 5 1.00 vcvttpd2udq %xmm16, %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udqx (%rax), %xmm19 +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 2 5 1.00 vcvttpd2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 2 5 1.00 vcvttpd2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 3 12 1.00 * vcvttpd2udq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %xmm16, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax), %xmm19 +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vcvttps2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %ymm16, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vcvttps2udq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vcvttps2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 14 1.00 vdivpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 14 1.00 vdivpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 14 1.00 vdivpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vdivpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 14 1.00 vdivpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 14 1.00 vdivpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 14 1.00 vdivpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 21 1.00 * vdivpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 11 1.00 vdivps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 11 1.00 vdivps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 11 1.00 vdivps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 18 1.00 * vdivps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 11 1.00 vdivps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 11 1.00 vdivps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 11 1.00 vdivps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 19 1.00 * vdivps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 7 28 1.33 * vgatherdpd (%rax,%xmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 11 29 2.67 * vgatherdps (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 7 28 1.33 * vgatherqpd (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 7 28 1.33 * vgatherqps (%rax,%ymm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vgatherdpd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 7 27 1.33 * vgatherdps (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vgatherqpd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vgatherqps (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1 4 0.50 vmaxpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vmaxpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmaxpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmaxpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmaxpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vmaxpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmaxpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmaxpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmaxps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vmaxps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmaxps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmaxps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmaxps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vmaxps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmaxps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmaxps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vminpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vminpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vminpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vminpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vminpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vminpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vminpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vminpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vminps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vminps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vminps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vminps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vminps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vminps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vminps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vminps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vminps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vminps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vminps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vminps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vminps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vminps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vminps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vminps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vminps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vminps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovapd %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovapd (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovapd %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovapd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovapd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovapd %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovapd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovapd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovapd %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovapd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovapd %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovapd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovapd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovapd %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovapd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovapd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovaps %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovaps (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovaps %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovaps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovaps (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovaps %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovaps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovaps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovaps %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovaps (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovaps %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovaps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovaps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovaps %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovaps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovaps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vmovddup %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovddup (%rax), %xmm19 +# CHECK-NEXT: 1 1 1.00 vmovddup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovddup (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vmovddup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovddup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa32 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqa32 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqa32 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovdqa32 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqa32 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovdqa32 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa32 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqa32 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqa32 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovdqa32 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa32 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqa32 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovdqa32 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa64 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqa64 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqa64 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovdqa64 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqa64 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovdqa64 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqa64 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqa64 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqa64 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovdqa64 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqa64 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqa64 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovdqa64 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu32 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqu32 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqu32 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovdqu32 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqu32 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovdqu32 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu32 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu32 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqu32 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovdqu32 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu32 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqu32 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovdqu32 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu64 %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovdqu64 (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqu64 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovdqu64 (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqu64 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovdqu64 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovdqu64 %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovdqu64 (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovdqu64 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovdqu64 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovdqu64 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovdqu64 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovdqu64 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vmovddup %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovddup (%rax), %ymm19 +# CHECK-NEXT: 1 1 1.00 vmovddup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovddup (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vmovddup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovddup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vmovshdup %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovshdup (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vmovshdup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovshdup (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vmovshdup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovshdup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vmovshdup %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovshdup (%rax), %ymm19 +# CHECK-NEXT: 1 1 0.50 vmovshdup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovshdup (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vmovshdup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovshdup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vmovsldup %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovsldup (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vmovsldup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovsldup (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vmovsldup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovsldup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vmovsldup %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovsldup (%rax), %ymm19 +# CHECK-NEXT: 1 1 0.50 vmovsldup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovsldup (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vmovsldup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovsldup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovupd %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovupd (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovupd %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovupd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovupd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovupd %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovupd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovupd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovupd %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovupd (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovupd %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovupd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovupd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovupd %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovupd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovupd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovups %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vmovups (%rax), %xmm19 +# CHECK-NEXT: 2 12 0.50 * vmovups %xmm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovups %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vmovups (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovups %xmm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovups %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vmovups (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0 1 0.00 vmovups %ymm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vmovups (%rax), %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmovups %ymm16, (%rax) +# CHECK-NEXT: 1 1 0.33 vmovups %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vmovups (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmovups %ymm16, (%rax) {%k1} +# CHECK-NEXT: 1 1 0.33 vmovups %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vmovups (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmulpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vmulpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmulpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmulpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmulpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vmulpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmulpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmulpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmulps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 4 0.50 vmulps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmulps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vmulps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 4 0.50 vmulps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 4 0.50 vmulps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vmulps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 12 0.50 * vmulps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpaddd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpaddd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpaddd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpaddd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpaddd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpaddd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpaddq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpaddq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpaddq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpaddq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpaddq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpaddq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpaddq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpbroadcastd %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vpbroadcastd (%rax), %xmm19 +# CHECK-NEXT: 1 1 1.00 vpbroadcastd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpbroadcastd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpbroadcastd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpbroadcastd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpbroadcastd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpbroadcastd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpbroadcastq %xmm16, %xmm19 +# CHECK-NEXT: 1 7 0.33 * vpbroadcastq (%rax), %xmm19 +# CHECK-NEXT: 1 1 1.00 vpbroadcastq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpbroadcastq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpbroadcastq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpbroadcastq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %ymm19 +# CHECK-NEXT: 1 8 0.33 * vpbroadcastq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpbroadcastq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpbroadcastq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpbroadcastq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpgtq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpeqq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpeqq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpcmpequq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vpcmpequq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vpcmpequq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vpermd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax), %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilpd $0, (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vpermilpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax), %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilps $0, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps $0, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vpermilps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vpermilps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vpermilps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vpermilps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vpermilps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vpermilps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermpd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermq $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermq $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermq $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpermq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vpermq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpermq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpermq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 7 28 1.33 * vpgatherdq (%rax,%xmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 11 29 2.67 * vpgatherdd (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 7 28 1.33 * vpgatherqq (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 7 28 1.33 * vpgatherqd (%rax,%ymm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vpgatherdq (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 7 27 1.33 * vpgatherdd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vpgatherqq (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 4 20 1.00 * vpgatherqd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxbd %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbd (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovsxbd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovsxbd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxbd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovsxbd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxbd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovsxbq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxbq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovsxbq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovsxbq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxbq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovsxbq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxbq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxbq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovsxdq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxdq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovsxdq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovsxdq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxdq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovsxdq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxdq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxdq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovsxwd %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxwd (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovsxwd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovsxwd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxwd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovsxwd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxwd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovsxwq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovsxwq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovsxwq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovsxwq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovsxwq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovsxwq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovsxwq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovsxwq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovzxbd %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbd (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovzxbd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovzxbd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxbd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovzxbd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxbd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovzxbq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxbq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovzxbq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovzxbq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxbq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovzxbq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxbq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxbq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovzxdq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxdq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovzxdq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovzxdq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxdq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovzxdq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxdq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxdq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovzxwd %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxwd (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovzxwd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovzxwd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxwd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovzxwd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxwd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpmovzxwq %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpmovzxwq (%rax), %xmm19 +# CHECK-NEXT: 1 1 0.50 vpmovzxwq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpmovzxwq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpmovzxwq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpmovzxwq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %ymm19 +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vpmovzxwq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpmovzxwq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 vpmulld %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 vpmulld %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 1.00 vpmulld %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 vpmulld %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 2 10 1.00 vpmulld %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 10 1.00 vpmulld %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 3 18 1.00 * vpmulld (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %xmm16, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax), %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpshufd $0, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %ymm16, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax), %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpshufd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpshufd $0, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpsubd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpsubd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.33 * vpsubq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.33 * vpsubq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vptestmd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestmq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestmq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestmq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmd %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmd %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmq %xmm0, %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %xmm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: 1 3 1.00 vptestnmq %ymm0, %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %ymm1, %k2 +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: 1 3 1.00 vptestnmq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: 2 3 1.00 * vptestnmq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpunpckhdq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckldq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 0.50 vpunpckldq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpunpckldq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 0.50 * vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 0.50 vpunpckldq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpunpckldq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 0.50 vpunpckldq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 0.50 * vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 3 1.00 vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 18 1.00 vsqrtpd %xmm16, %xmm19 +# CHECK-NEXT: 2 24 1.00 * vsqrtpd (%rax), %xmm19 +# CHECK-NEXT: 2 24 1.00 * vsqrtpd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1 18 1.00 vsqrtpd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vsqrtpd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vsqrtpd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1 18 1.00 vsqrtpd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vsqrtpd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vsqrtpd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 18 1.00 vsqrtpd %ymm16, %ymm19 +# CHECK-NEXT: 2 25 1.00 * vsqrtpd (%rax), %ymm19 +# CHECK-NEXT: 2 25 1.00 * vsqrtpd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1 18 1.00 vsqrtpd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 21 1.00 * vsqrtpd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 21 1.00 * vsqrtpd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1 18 1.00 vsqrtpd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 21 1.00 * vsqrtpd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 21 1.00 * vsqrtpd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 12 1.00 vsqrtps %xmm16, %xmm19 +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax), %xmm19 +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1 12 1.00 vsqrtps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax), %xmm19 {%k1} +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1 12 1.00 vsqrtps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 2 19 1.00 * vsqrtps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 12 1.00 vsqrtps %ymm16, %ymm19 +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax), %ymm19 +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1 12 1.00 vsqrtps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1 12 1.00 vsqrtps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 2 20 1.00 * vsqrtps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vsubpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vsubpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vsubpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vsubpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vsubpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vsubps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 3 0.50 vsubps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 10 0.50 * vsubps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 3 0.50 vsubps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 3 0.50 vsubps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 4 0.50 vsubps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 11 0.50 * vsubps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpckhpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpckhpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vunpckhpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpckhps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vunpckhps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpckhps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpckhps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vunpckhps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpckhps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpckhps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vunpcklpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vunpcklpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 1 1.00 vunpcklps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 8 1.00 * vunpcklps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 1 1.00 vunpcklps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 1 1.00 vunpcklps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 1 1.00 vunpcklps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 9 1.00 * vunpcklps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 323.33 347.33 304.33 304.33 16.00 794.33 - 16.00 16.00 16.00 - 304.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vaddps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vaddps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignd $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignd $1, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - valignq $1, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - valignq $1, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastf32x4 (%rax), %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf32x4 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastf32x4 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcasti32x4 (%rax), %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x4 (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcasti32x4 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastsd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastsd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastsd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastsd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastss (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastss (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastss (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vbroadcastss (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastss (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vbroadcastss %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vbroadcastss (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqpd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqpd (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vcmpeqps %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vcmpeqps (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtdq2pd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtdq2ps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtdq2ps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqy (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2dq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psy (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2ps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2psx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2ps (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqy (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtpd2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvtpd2udq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2dq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2pd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2pd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvtps2udq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtps2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqy (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2dq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2dq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2dq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %ymm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqy (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %ymm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqy (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %ymm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqy (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqx (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to2}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqx (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvttpd2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udqx (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - vcvttpd2udq (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %xmm16, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to4}, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %ymm16, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to8}, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vcvttps2udq %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvttps2udq (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vdivps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vdivps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vgatherdpd (%rax,%xmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 2.67 2.67 - 1.00 - - - - - 2.67 - vgatherdps (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vgatherqpd (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vgatherqps (%rax,%ymm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vgatherdpd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vgatherdps (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vgatherqpd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vgatherqps (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmaxps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmaxps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vminps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vminps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovapd %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovapd (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovapd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovapd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovapd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovapd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovapd %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovapd (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovapd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovapd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovapd %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovapd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovapd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovaps %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovaps (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovaps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovaps (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovaps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovaps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovaps %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovaps (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovaps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovaps (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovaps %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovaps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovaps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovddup (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovddup (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovddup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa32 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa32 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa32 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa32 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa32 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa32 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa32 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa32 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa32 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa32 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa32 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa32 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa32 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa64 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa64 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa64 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa64 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa64 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa64 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqa64 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqa64 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa64 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa64 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqa64 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqa64 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqa64 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu32 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu32 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu32 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu32 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu32 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu32 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu32 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu32 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu32 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu32 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu32 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu32 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu32 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu64 %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu64 (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu64 %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu64 (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu64 %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu64 (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovdqu64 %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovdqu64 (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu64 %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu64 (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovdqu64 %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovdqu64 %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovdqu64 (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovddup (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovddup (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vmovddup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovddup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovshdup (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovshdup (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovshdup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovshdup (%rax), %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovshdup (%rax), %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovshdup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovshdup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsldup (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovsldup (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovsldup (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovsldup (%rax), %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovsldup (%rax), %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vmovsldup %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovsldup (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovupd %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovupd (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovupd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovupd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovupd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovupd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovupd %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovupd (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovupd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovupd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovupd %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovupd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovupd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovups %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovups (%rax), %xmm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %xmm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovups %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovups (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %xmm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovups %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovups (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - - - - - - - - - vmovups %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vmovups (%rax), %ymm19 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %ymm16, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovups %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovups (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - vmovups %ymm16, (%rax) {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vmovups %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vmovups (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vmulps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vmulps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpaddq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpaddq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastd (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastq (%rax), %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - vpbroadcastq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpbroadcastq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpbroadcastq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpgtq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpeqq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpeqq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpequq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpcmpequq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to2}, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %xmm16, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to4}, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to8}, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps $0, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermilps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermilps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %ymm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to4}, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq $0, (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpermq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpermq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vpgatherdq (%rax,%xmm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 2.67 2.67 - 1.00 - - - - - 2.67 - vpgatherdd (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vpgatherqq (%rax,%ymm1,2), %ymm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vpgatherqd (%rax,%ymm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vpgatherdq (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 1.00 1.33 1.33 - 1.00 - - - - - 1.33 - vpgatherdd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vpgatherqq (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: 1.00 0.50 0.67 0.67 - 0.50 - - - - - 0.67 - vpgatherqd (%rax,%xmm1,2), %xmm2 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbd %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbd (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxbq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxbq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxbq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxbq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxdq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxdq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxdq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxdq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxdq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxdq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxdq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxdq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwd %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwd (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovsxwq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovsxwq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovsxwq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovsxwq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbd %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbd (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxbq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxbq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxbq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxbq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxdq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxdq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxdq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxdq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxdq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxdq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxdq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxdq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwd %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwd (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwd (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwd %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwq %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwq (%rax), %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwq %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwq (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpmovzxwq %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpmovzxwq (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpmovzxwq %xmm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpmovzxwq (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - vpmulld %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - vpmulld (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %xmm16, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to4}, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %xmm16, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %ymm16, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to8}, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %ymm16, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpshufd $0, %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpshufd $0, (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - vpsubq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - vpsubq (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestmq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestmq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to4}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to4}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to8}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmd %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmd (%rax){1to8}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %xmm0, %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %xmm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to2}, %xmm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %xmm0, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %xmm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to2}, %xmm1, %k2 {%k3} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %ymm0, %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %ymm1, %k2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to4}, %ymm1, %k2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vptestnmq %ymm0, %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax), %ymm1, %k2 {%k3} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vptestnmq (%rax){1to4}, %ymm1, %k2 {%k3} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckhdq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckhdq (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vpunpckldq %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vpunpckldq (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshuff64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshuff64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi32x4 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi32x4 $0, (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vshufi64x2 $0, %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vshufi64x2 $0, (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %xmm16, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to2}, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to2}, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to2}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %ymm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to4}, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to4}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtpd %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtpd (%rax){1to4}, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %xmm16, %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %xmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to4}, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %xmm16, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %xmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to4}, %xmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %xmm16, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to4}, %xmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %ymm16, %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %ymm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to8}, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %ymm16, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %ymm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to8}, %ymm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vsqrtps %ymm16, %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax), %ymm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vsqrtps (%rax){1to8}, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - vsubps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - vsubps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpckhps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpckhps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to2}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to2}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to4}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklpd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklpd (%rax){1to4}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vunpcklps %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vunpcklps (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnni.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnni.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnni.s @@ -0,0 +1,146 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpdpbusd %zmm16, %zmm17, %zmm19 +vpdpbusd (%rax), %zmm17, %zmm19 +vpdpbusd (%rax){1to16}, %zmm17, %zmm19 +vpdpbusd %zmm16, %zmm17, %zmm19 {k1} +vpdpbusd (%rax), %zmm17, %zmm19 {k1} +vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpdpbusd %zmm16, %zmm17, %zmm19 {z}{k1} +vpdpbusd (%rax), %zmm17, %zmm19 {z}{k1} +vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpdpbusds %zmm16, %zmm17, %zmm19 +vpdpbusds (%rax), %zmm17, %zmm19 +vpdpbusds (%rax){1to16}, %zmm17, %zmm19 +vpdpbusds %zmm16, %zmm17, %zmm19 {k1} +vpdpbusds (%rax), %zmm17, %zmm19 {k1} +vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {k1} +vpdpbusds %zmm16, %zmm17, %zmm19 {z}{k1} +vpdpbusds (%rax), %zmm17, %zmm19 {z}{k1} +vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpdpwssd %zmm16, %zmm17, %zmm19 +vpdpwssd (%rax), %zmm17, %zmm19 +vpdpwssd (%rax){1to16}, %zmm17, %zmm19 +vpdpwssd %zmm16, %zmm17, %zmm19 {k1} +vpdpwssd (%rax), %zmm17, %zmm19 {k1} +vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {k1} +vpdpwssd %zmm16, %zmm17, %zmm19 {z}{k1} +vpdpwssd (%rax), %zmm17, %zmm19 {z}{k1} +vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +vpdpwssds %zmm16, %zmm17, %zmm19 +vpdpwssds (%rax), %zmm17, %zmm19 +vpdpwssds (%rax){1to16}, %zmm17, %zmm19 +vpdpwssds %zmm16, %zmm17, %zmm19 {k1} +vpdpwssds (%rax), %zmm17, %zmm19 {k1} +vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {k1} +vpdpwssds %zmm16, %zmm17, %zmm19 {z}{k1} +vpdpwssds (%rax), %zmm17, %zmm19 {z}{k1} +vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 1.00 vpdpbusd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpdpbusd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpdpbusd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpdpbusds %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpdpbusds %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpdpbusds %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpdpwssd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpdpwssd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpdpwssd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1 5 1.00 vpdpwssds %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1 5 1.00 vpdpwssds %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1 5 1.00 vpdpwssds %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 2 13 1.00 * vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 36.00 - 8.00 8.00 - - - - - - - 8.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusds %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusds %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpbusds %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssd %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssd %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssd %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssds %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to16}, %zmm17, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssds %zmm16, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {%k1} +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpdpwssds %zmm16, %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %zmm17, %zmm19 {%k1} {z} +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to16}, %zmm17, %zmm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnnivl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnnivl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vnnivl.s @@ -0,0 +1,258 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpdpbusd %xmm16, %xmm17, %xmm19 +vpdpbusd (%rax), %xmm17, %xmm19 +vpdpbusd (%rax){1to4}, %xmm17, %xmm19 +vpdpbusd %xmm16, %xmm17, %xmm19 {k1} +vpdpbusd (%rax), %xmm17, %xmm19 {k1} +vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpdpbusd %xmm16, %xmm17, %xmm19 {z}{k1} +vpdpbusd (%rax), %xmm17, %xmm19 {z}{k1} +vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpdpbusd %ymm16, %ymm17, %ymm19 +vpdpbusd (%rax), %ymm17, %ymm19 +vpdpbusd (%rax){1to8}, %ymm17, %ymm19 +vpdpbusd %ymm16, %ymm17, %ymm19 {k1} +vpdpbusd (%rax), %ymm17, %ymm19 {k1} +vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpdpbusd %ymm16, %ymm17, %ymm19 {z}{k1} +vpdpbusd (%rax), %ymm17, %ymm19 {z}{k1} +vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpdpbusds %xmm16, %xmm17, %xmm19 +vpdpbusds (%rax), %xmm17, %xmm19 +vpdpbusds (%rax){1to4}, %xmm17, %xmm19 +vpdpbusds %xmm16, %xmm17, %xmm19 {k1} +vpdpbusds (%rax), %xmm17, %xmm19 {k1} +vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {k1} +vpdpbusds %xmm16, %xmm17, %xmm19 {z}{k1} +vpdpbusds (%rax), %xmm17, %xmm19 {z}{k1} +vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpdpbusds %ymm16, %ymm17, %ymm19 +vpdpbusds (%rax), %ymm17, %ymm19 +vpdpbusds (%rax){1to8}, %ymm17, %ymm19 +vpdpbusds %ymm16, %ymm17, %ymm19 {k1} +vpdpbusds (%rax), %ymm17, %ymm19 {k1} +vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {k1} +vpdpbusds %ymm16, %ymm17, %ymm19 {z}{k1} +vpdpbusds (%rax), %ymm17, %ymm19 {z}{k1} +vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpdpwssd %xmm16, %xmm17, %xmm19 +vpdpwssd (%rax), %xmm17, %xmm19 +vpdpwssd (%rax){1to4}, %xmm17, %xmm19 +vpdpwssd %xmm16, %xmm17, %xmm19 {k1} +vpdpwssd (%rax), %xmm17, %xmm19 {k1} +vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {k1} +vpdpwssd %xmm16, %xmm17, %xmm19 {z}{k1} +vpdpwssd (%rax), %xmm17, %xmm19 {z}{k1} +vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpdpwssd %ymm16, %ymm17, %ymm19 +vpdpwssd (%rax), %ymm17, %ymm19 +vpdpwssd (%rax){1to8}, %ymm17, %ymm19 +vpdpwssd %ymm16, %ymm17, %ymm19 {k1} +vpdpwssd (%rax), %ymm17, %ymm19 {k1} +vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {k1} +vpdpwssd %ymm16, %ymm17, %ymm19 {z}{k1} +vpdpwssd (%rax), %ymm17, %ymm19 {z}{k1} +vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +vpdpwssds %xmm16, %xmm17, %xmm19 +vpdpwssds (%rax), %xmm17, %xmm19 +vpdpwssds (%rax){1to4}, %xmm17, %xmm19 +vpdpwssds %xmm16, %xmm17, %xmm19 {k1} +vpdpwssds (%rax), %xmm17, %xmm19 {k1} +vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {k1} +vpdpwssds %xmm16, %xmm17, %xmm19 {z}{k1} +vpdpwssds (%rax), %xmm17, %xmm19 {z}{k1} +vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {z}{k1} + +vpdpwssds %ymm16, %ymm17, %ymm19 +vpdpwssds (%rax), %ymm17, %ymm19 +vpdpwssds (%rax){1to8}, %ymm17, %ymm19 +vpdpwssds %ymm16, %ymm17, %ymm19 {k1} +vpdpwssds (%rax), %ymm17, %ymm19 {k1} +vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {k1} +vpdpwssds %ymm16, %ymm17, %ymm19 {z}{k1} +vpdpwssds (%rax), %ymm17, %ymm19 {z}{k1} +vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {z}{k1} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vpdpbusd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vpdpbusd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpbusd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpbusd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vpdpbusd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpbusd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpbusds %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vpdpbusds %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpbusds %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpbusds %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vpdpbusds %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpbusds %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpwssd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vpdpwssd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpwssd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpwssd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vpdpwssd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpwssd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpwssds %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 1 5 0.50 vpdpwssds %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpwssds %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 1 5 0.50 vpdpwssds %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 1 5 0.50 vpdpwssds %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 1 5 0.50 vpdpwssds %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 36.00 36.00 16.00 16.00 - - - - - - - 16.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to4}, %xmm17, %xmm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %xmm16, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %xmm16, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to4}, %xmm17, %xmm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to8}, %ymm17, %ymm19 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %ymm16, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {%k1} +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %ymm16, %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %ymm17, %ymm19 {%k1} {z} +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax){1to8}, %ymm17, %ymm19 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersect.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersect.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersect.s @@ -0,0 +1,53 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=tigerlake -instruction-tables < %s | FileCheck %s + +vp2intersectd %zmm16, %zmm19, %k0 +vp2intersectd (%rax), %zmm19, %k0 +vp2intersectd (%rax){1to16}, %zmm19, %k0 + +vp2intersectq %zmm16, %zmm19, %k0 +vp2intersectq (%rax), %zmm19, %k0 +vp2intersectq (%rax){1to8}, %zmm19, %k0 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 1.00 vp2intersectd %zmm16, %zmm19, %k0 +# CHECK-NEXT: 2 8 1.00 * vp2intersectd (%rax), %zmm19, %k0 +# CHECK-NEXT: 2 8 1.00 * vp2intersectd (%rax){1to16}, %zmm19, %k0 +# CHECK-NEXT: 1 1 1.00 vp2intersectq %zmm16, %zmm19, %k0 +# CHECK-NEXT: 2 8 1.00 * vp2intersectq (%rax), %zmm19, %k0 +# CHECK-NEXT: 2 8 1.00 * vp2intersectq (%rax){1to8}, %zmm19, %k0 + +# CHECK: Resources: +# CHECK-NEXT: [0] - ICXDivider +# CHECK-NEXT: [1] - ICXFPDivider +# CHECK-NEXT: [2] - ICXPort0 +# CHECK-NEXT: [3] - ICXPort1 +# CHECK-NEXT: [4] - ICXPort2 +# CHECK-NEXT: [5] - ICXPort3 +# CHECK-NEXT: [6] - ICXPort4 +# CHECK-NEXT: [7] - ICXPort5 +# CHECK-NEXT: [8] - ICXPort6 +# CHECK-NEXT: [9] - ICXPort7 +# CHECK-NEXT: [10] - ICXPort8 +# CHECK-NEXT: [11] - ICXPort9 + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] +# CHECK-NEXT: - - 6.00 - 2.00 2.00 - - - - - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] Instructions: +# CHECK-NEXT: - - 1.00 - - - - - - - - - vp2intersectd %zmm16, %zmm19, %k0 +# CHECK-NEXT: - - 1.00 - 0.50 0.50 - - - - - - vp2intersectd (%rax), %zmm19, %k0 +# CHECK-NEXT: - - 1.00 - 0.50 0.50 - - - - - - vp2intersectd (%rax){1to16}, %zmm19, %k0 +# CHECK-NEXT: - - 1.00 - - - - - - - - - vp2intersectq %zmm16, %zmm19, %k0 +# CHECK-NEXT: - - 1.00 - 0.50 0.50 - - - - - - vp2intersectq (%rax), %zmm19, %k0 +# CHECK-NEXT: - - 1.00 - 0.50 0.50 - - - - - - vp2intersectq (%rax){1to8}, %zmm19, %k0 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersectvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersectvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vp2intersectvl.s @@ -0,0 +1,73 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=tigerlake -instruction-tables < %s | FileCheck %s + +vp2intersectd %xmm16, %xmm19, %k0 +vp2intersectd (%rax), %xmm19, %k0 +vp2intersectd (%rax){1to4}, %xmm19, %k0 + +vp2intersectd %ymm16, %ymm19, %k0 +vp2intersectd (%rax), %ymm19, %k0 +vp2intersectd (%rax){1to8}, %ymm19, %k0 + +vp2intersectq %xmm16, %xmm19, %k0 +vp2intersectq (%rax), %xmm19, %k0 +vp2intersectq (%rax){1to2}, %xmm19, %k0 + +vp2intersectq %ymm16, %ymm19, %k0 +vp2intersectq (%rax), %ymm19, %k0 +vp2intersectq (%rax){1to4}, %ymm19, %k0 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.50 vp2intersectd %xmm16, %xmm19, %k0 +# CHECK-NEXT: 2 7 0.50 * vp2intersectd (%rax), %xmm19, %k0 +# CHECK-NEXT: 2 7 0.50 * vp2intersectd (%rax){1to4}, %xmm19, %k0 +# CHECK-NEXT: 1 1 0.50 vp2intersectd %ymm16, %ymm19, %k0 +# CHECK-NEXT: 2 8 0.50 * vp2intersectd (%rax), %ymm19, %k0 +# CHECK-NEXT: 2 8 0.50 * vp2intersectd (%rax){1to8}, %ymm19, %k0 +# CHECK-NEXT: 1 1 0.50 vp2intersectq %xmm16, %xmm19, %k0 +# CHECK-NEXT: 2 7 0.50 * vp2intersectq (%rax), %xmm19, %k0 +# CHECK-NEXT: 2 7 0.50 * vp2intersectq (%rax){1to2}, %xmm19, %k0 +# CHECK-NEXT: 1 1 0.50 vp2intersectq %ymm16, %ymm19, %k0 +# CHECK-NEXT: 2 8 0.50 * vp2intersectq (%rax), %ymm19, %k0 +# CHECK-NEXT: 2 8 0.50 * vp2intersectq (%rax){1to4}, %ymm19, %k0 + +# CHECK: Resources: +# CHECK-NEXT: [0] - ICXDivider +# CHECK-NEXT: [1] - ICXFPDivider +# CHECK-NEXT: [2] - ICXPort0 +# CHECK-NEXT: [3] - ICXPort1 +# CHECK-NEXT: [4] - ICXPort2 +# CHECK-NEXT: [5] - ICXPort3 +# CHECK-NEXT: [6] - ICXPort4 +# CHECK-NEXT: [7] - ICXPort5 +# CHECK-NEXT: [8] - ICXPort6 +# CHECK-NEXT: [9] - ICXPort7 +# CHECK-NEXT: [10] - ICXPort8 +# CHECK-NEXT: [11] - ICXPort9 + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] +# CHECK-NEXT: - - 6.00 6.00 4.00 4.00 - - - - - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] Instructions: +# CHECK-NEXT: - - 0.50 0.50 - - - - - - - - vp2intersectd %xmm16, %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectd (%rax), %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectd (%rax){1to4}, %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 - - - - - - - - vp2intersectd %ymm16, %ymm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectd (%rax), %ymm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectd (%rax){1to8}, %ymm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 - - - - - - - - vp2intersectq %xmm16, %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectq (%rax), %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectq (%rax){1to2}, %xmm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 - - - - - - - - vp2intersectq %ymm16, %ymm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectq (%rax), %ymm19, %k0 +# CHECK-NEXT: - - 0.50 0.50 0.50 0.50 - - - - - - vp2intersectq (%rax){1to4}, %ymm19, %k0 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdq.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdq.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdq.s @@ -0,0 +1,41 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpclmulqdq $11, %zmm16, %zmm17, %zmm19 +vpclmulqdq $11, (%rax), %zmm17, %zmm19 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpclmulqdq $11, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: 2 11 1.00 * vpclmulqdq $11, (%rax), %zmm17, %zmm19 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpclmulqdq $11, %zmm16, %zmm17, %zmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpclmulqdq $11, (%rax), %zmm17, %zmm19 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdqvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdqvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpclmulqdqvl.s @@ -0,0 +1,48 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpclmulqdq $11, %xmm16, %xmm17, %xmm19 +vpclmulqdq $11, (%rax), %xmm17, %xmm19 + +vpclmulqdq $11, %ymm16, %ymm17, %ymm19 +vpclmulqdq $11, (%rax), %ymm17, %ymm19 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpclmulqdq $11, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: 2 10 1.00 * vpclmulqdq $11, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: 1 3 1.00 vpclmulqdq $11, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: 2 11 1.00 * vpclmulqdq $11, (%rax), %ymm17, %ymm19 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 0.67 0.67 - 4.00 - - - - - 0.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpclmulqdq $11, %xmm16, %xmm17, %xmm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpclmulqdq $11, (%rax), %xmm17, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpclmulqdq $11, %ymm16, %ymm17, %ymm19 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpclmulqdq $11, (%rax), %ymm17, %ymm19 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdq.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdq.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdq.s @@ -0,0 +1,94 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpopcntd %zmm1, %zmm0 +vpopcntd (%rdi), %zmm0 +vpopcntd (%rdi){1to16}, %zmm0 + +vpopcntd %zmm1, %zmm0 {%k1} +vpopcntd (%rdi), %zmm0 {%k1} +vpopcntd (%rdi){1to16}, %zmm0 {%k1} + +vpopcntd %zmm1, %zmm0 {%k1} {z} +vpopcntd (%rdi), %zmm0 {%k1} {z} +vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z} + +vpopcntq %zmm1, %zmm0 +vpopcntq (%rdi), %zmm0 +vpopcntq (%rdi){1to8}, %zmm0 + +vpopcntq %zmm1, %zmm0 {%k1} +vpopcntq (%rdi), %zmm0 {%k1} +vpopcntq (%rdi){1to8}, %zmm0 {%k1} + +vpopcntq %zmm1, %zmm0 {%k1} {z} +vpopcntq (%rdi), %zmm0 {%k1} {z} +vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpopcntd %zmm1, %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to16}, %zmm0 +# CHECK-NEXT: 1 3 1.00 vpopcntd %zmm1, %zmm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %zmm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to16}, %zmm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntd %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntq %zmm1, %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %zmm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to8}, %zmm0 +# CHECK-NEXT: 1 3 1.00 vpopcntq %zmm1, %zmm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %zmm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to8}, %zmm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntq %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 4.00 4.00 - 18.00 - - - - - 4.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %zmm1, %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to16}, %zmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %zmm1, %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to16}, %zmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %zmm1, %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %zmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to8}, %zmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %zmm1, %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %zmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to8}, %zmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %zmm1, %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %zmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdqvl.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdqvl.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avx512vpopcntdqvl.s @@ -0,0 +1,154 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpopcntd %xmm1, %xmm0 +vpopcntd (%rdi), %xmm0 +vpopcntd (%rdi){1to4}, %xmm0 + +vpopcntd %xmm1, %xmm0 {%k1} +vpopcntd (%rdi), %xmm0 {%k1} +vpopcntd (%rdi){1to4}, %xmm0 {%k1} + +vpopcntd %xmm1, %xmm0 {%k1} {z} +vpopcntd (%rdi), %xmm0 {%k1} {z} +vpopcntd (%rdi){1to4}, %xmm0 {%k1} {z} + +vpopcntd %ymm1, %ymm0 +vpopcntd (%rdi), %ymm0 +vpopcntd (%rdi){1to8}, %ymm0 + +vpopcntd %ymm1, %ymm0 {%k1} +vpopcntd (%rdi), %ymm0 {%k1} +vpopcntd (%rdi){1to8}, %ymm0 {%k1} + +vpopcntd %ymm1, %ymm0 {%k1} {z} +vpopcntd (%rdi), %ymm0 {%k1} {z} +vpopcntd (%rdi){1to8}, %ymm0 {%k1} {z} + +vpopcntq %xmm1, %xmm0 +vpopcntq (%rdi), %xmm0 +vpopcntq (%rdi){1to2}, %xmm0 + +vpopcntq %xmm1, %xmm0 {%k1} +vpopcntq (%rdi), %xmm0 {%k1} +vpopcntq (%rdi){1to2}, %xmm0 {%k1} + +vpopcntq %xmm1, %xmm0 {%k1} {z} +vpopcntq (%rdi), %xmm0 {%k1} {z} +vpopcntq (%rdi){1to2}, %xmm0 {%k1} {z} + +vpopcntq %ymm1, %ymm0 +vpopcntq (%rdi), %ymm0 +vpopcntq (%rdi){1to4}, %ymm0 + +vpopcntq %ymm1, %ymm0 {%k1} +vpopcntq (%rdi), %ymm0 {%k1} +vpopcntq (%rdi){1to4}, %ymm0 {%k1} + +vpopcntq %ymm1, %ymm0 {%k1} {z} +vpopcntq (%rdi), %ymm0 {%k1} {z} +vpopcntq (%rdi){1to4}, %ymm0 {%k1} {z} + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpopcntd %xmm1, %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi), %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi){1to4}, %xmm0 +# CHECK-NEXT: 1 3 1.00 vpopcntd %xmm1, %xmm0 {%k1} +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi), %xmm0 {%k1} +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi){1to4}, %xmm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntd %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 * vpopcntd (%rdi){1to4}, %xmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntd %ymm1, %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to8}, %ymm0 +# CHECK-NEXT: 1 3 1.00 vpopcntd %ymm1, %ymm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %ymm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to8}, %ymm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntd %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntd (%rdi){1to8}, %ymm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntq %xmm1, %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi), %xmm0 +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi){1to2}, %xmm0 +# CHECK-NEXT: 1 3 1.00 vpopcntq %xmm1, %xmm0 {%k1} +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi), %xmm0 {%k1} +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi){1to2}, %xmm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntq %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: 2 10 1.00 * vpopcntq (%rdi){1to2}, %xmm0 {%k1} {z} +# CHECK-NEXT: 1 3 1.00 vpopcntq %ymm1, %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %ymm0 +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to4}, %ymm0 +# CHECK-NEXT: 1 3 1.00 vpopcntq %ymm1, %ymm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %ymm0 {%k1} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to4}, %ymm0 {%k1} +# CHECK-NEXT: 1 3 1.00 vpopcntq %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: 2 11 1.00 * vpopcntq (%rdi){1to4}, %ymm0 {%k1} {z} + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 8.00 8.00 - 36.00 - - - - - 8.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %xmm1, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to4}, %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %xmm1, %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to4}, %xmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to4}, %xmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %ymm1, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to8}, %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %ymm1, %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to8}, %ymm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntd %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntd (%rdi){1to8}, %ymm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %xmm1, %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %xmm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to2}, %xmm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %xmm1, %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %xmm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to2}, %xmm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %xmm1, %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %xmm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to2}, %xmm0 {%k1} {z} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %ymm1, %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %ymm0 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to4}, %ymm0 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %ymm1, %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %ymm0 {%k1} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to4}, %ymm0 {%k1} +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpopcntq %ymm1, %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi), %ymm0 {%k1} {z} +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpopcntq (%rdi){1to4}, %ymm0 {%k1} {z} diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxgfni.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxgfni.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxgfni.s @@ -0,0 +1,76 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vgf2p8affineinvqb $0, %xmm0, %xmm1, %xmm2 +vgf2p8affineinvqb $0, (%rax), %xmm1, %xmm2 + +vgf2p8affineinvqb $0, %ymm0, %ymm1, %ymm2 +vgf2p8affineinvqb $0, (%rax), %ymm1, %ymm2 + +vgf2p8affineqb $0, %xmm0, %xmm1, %xmm2 +vgf2p8affineqb $0, (%rax), %xmm1, %xmm2 + +vgf2p8affineqb $0, %ymm0, %ymm1, %ymm2 +vgf2p8affineqb $0, (%rax), %ymm1, %ymm2 + +vgf2p8mulb %xmm0, %xmm1, %xmm2 +vgf2p8mulb (%rax), %xmm1, %xmm2 + +vgf2p8mulb %ymm0, %ymm1, %ymm2 +vgf2p8mulb (%rax), %ymm1, %ymm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vgf2p8affineinvqb $0, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vgf2p8affineinvqb $0, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineinvqb $0, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vgf2p8affineqb $0, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8affineqb $0, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vgf2p8mulb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8mulb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vgf2p8mulb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vgf2p8mulb (%rax), %ymm1, %ymm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 6.00 6.00 2.00 2.00 - - - - - - - 2.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineinvqb $0, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineinvqb $0, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8affineqb $0, %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8affineqb $0, (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vgf2p8mulb %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vgf2p8mulb (%rax), %ymm1, %ymm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxvnni.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxvnni.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-avxvnni.s @@ -0,0 +1,90 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpdpbusd %xmm0, %xmm1, %xmm2 +vpdpbusd (%rax), %xmm1, %xmm2 + +vpdpbusd %ymm0, %ymm1, %ymm2 +vpdpbusd (%rax), %ymm1, %ymm2 + +vpdpbusds %xmm0, %xmm1, %xmm2 +vpdpbusds (%rax), %xmm1, %xmm2 + +vpdpbusds %ymm0, %ymm1, %ymm2 +vpdpbusds (%rax), %ymm1, %ymm2 + +vpdpwssd %xmm0, %xmm1, %xmm2 +vpdpwssd (%rax), %xmm1, %xmm2 + +vpdpwssd %ymm0, %ymm1, %ymm2 +vpdpwssd (%rax), %ymm1, %ymm2 + +vpdpwssds %xmm0, %xmm1, %xmm2 +vpdpwssds (%rax), %xmm1, %xmm2 + +vpdpwssds %ymm0, %ymm1, %ymm2 +vpdpwssds (%rax), %ymm1, %ymm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vpdpbusd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpdpbusd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpdpbusd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpdpbusds %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpdpbusds %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpdpbusds (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpdpwssd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpdpwssd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpdpwssd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 5 0.50 vpdpwssds %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 5 0.50 vpdpwssds %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 13 0.50 * vpdpwssds (%rax), %ymm1, %ymm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 8.00 8.00 2.67 2.67 - - - - - - - 2.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpbusds %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpbusds (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vpdpwssds %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vpdpwssds (%rax), %ymm1, %ymm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi1.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi1.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi1.s @@ -0,0 +1,125 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +andn %eax, %ebx, %ecx +andn (%rax), %ebx, %ecx + +andn %rax, %rbx, %rcx +andn (%rax), %rbx, %rcx + +bextr %eax, %ebx, %ecx +bextr %eax, (%rbx), %ecx + +bextr %rax, %rbx, %rcx +bextr %rax, (%rbx), %rcx + +blsi %eax, %ecx +blsi (%rax), %ecx + +blsi %rax, %rcx +blsi (%rax), %rcx + +blsmsk %eax, %ecx +blsmsk (%rax), %ecx + +blsmsk %rax, %rcx +blsmsk (%rax), %rcx + +blsr %eax, %ecx +blsr (%rax), %ecx + +blsr %rax, %rcx +blsr (%rax), %rcx + +tzcnt %ax, %cx +tzcnt (%rax), %cx + +tzcnt %eax, %ecx +tzcnt (%rax), %ecx + +tzcnt %rax, %rcx +tzcnt (%rax), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 2 0.33 andnl %eax, %ebx, %ecx +# CHECK-NEXT: 2 7 0.33 * andnl (%rax), %ebx, %ecx +# CHECK-NEXT: 1 2 0.33 andnq %rax, %rbx, %rcx +# CHECK-NEXT: 2 7 0.33 * andnq (%rax), %rbx, %rcx +# CHECK-NEXT: 2 6 1.00 bextrl %eax, %ebx, %ecx +# CHECK-NEXT: 3 11 1.00 * bextrl %eax, (%rbx), %ecx +# CHECK-NEXT: 2 6 1.00 bextrq %rax, %rbx, %rcx +# CHECK-NEXT: 3 11 1.00 * bextrq %rax, (%rbx), %rcx +# CHECK-NEXT: 1 2 0.33 blsil %eax, %ecx +# CHECK-NEXT: 2 7 0.33 * blsil (%rax), %ecx +# CHECK-NEXT: 1 2 0.33 blsiq %rax, %rcx +# CHECK-NEXT: 2 7 0.33 * blsiq (%rax), %rcx +# CHECK-NEXT: 1 2 0.33 blsmskl %eax, %ecx +# CHECK-NEXT: 2 7 0.33 * blsmskl (%rax), %ecx +# CHECK-NEXT: 1 2 0.33 blsmskq %rax, %rcx +# CHECK-NEXT: 2 7 0.33 * blsmskq (%rax), %rcx +# CHECK-NEXT: 1 2 0.33 blsrl %eax, %ecx +# CHECK-NEXT: 2 7 0.33 * blsrl (%rax), %ecx +# CHECK-NEXT: 1 2 0.33 blsrq %rax, %rcx +# CHECK-NEXT: 2 7 0.33 * blsrq (%rax), %rcx +# CHECK-NEXT: 1 3 1.00 tzcntw %ax, %cx +# CHECK-NEXT: 2 8 1.00 * tzcntw (%rax), %cx +# CHECK-NEXT: 1 3 1.00 tzcntl %eax, %ecx +# CHECK-NEXT: 2 8 1.00 * tzcntl (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 tzcntq %rax, %rcx +# CHECK-NEXT: 2 8 1.00 * tzcntq (%rax), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 2.00 15.33 4.33 4.33 - 5.33 2.00 - - - 5.33 4.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - andnl %eax, %ebx, %ecx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - andnl (%rax), %ebx, %ecx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - andnq %rax, %rbx, %rcx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - andnq (%rax), %rbx, %rcx +# CHECK-NEXT: 0.50 1.00 - - - - 0.50 - - - - - - bextrl %eax, %ebx, %ecx +# CHECK-NEXT: 0.50 1.00 0.33 0.33 - - 0.50 - - - - 0.33 - bextrl %eax, (%rbx), %ecx +# CHECK-NEXT: 0.50 1.00 - - - - 0.50 - - - - - - bextrq %rax, %rbx, %rcx +# CHECK-NEXT: 0.50 1.00 0.33 0.33 - - 0.50 - - - - 0.33 - bextrq %rax, (%rbx), %rcx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsil %eax, %ecx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsil (%rax), %ecx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsiq %rax, %rcx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsiq (%rax), %rcx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsmskl %eax, %ecx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsmskl (%rax), %ecx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsmskq %rax, %rcx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsmskq (%rax), %rcx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsrl %eax, %ecx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsrl (%rax), %ecx +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - blsrq %rax, %rcx +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - blsrq (%rax), %rcx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - tzcntw %ax, %cx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - tzcntw (%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - tzcntl %eax, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - tzcntl (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - tzcntq %rax, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - tzcntq (%rax), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi2.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi2.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-bmi2.s @@ -0,0 +1,146 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +bzhi %eax, %ebx, %ecx +bzhi %eax, (%rbx), %ecx + +bzhi %rax, %rbx, %rcx +bzhi %rax, (%rbx), %rcx + +mulx %eax, %ebx, %ecx +mulx (%rax), %ebx, %ecx + +mulx %rax, %rbx, %rcx +mulx (%rax), %rbx, %rcx + +pdep %eax, %ebx, %ecx +pdep (%rax), %ebx, %ecx + +pdep %rax, %rbx, %rcx +pdep (%rax), %rbx, %rcx + +pext %eax, %ebx, %ecx +pext (%rax), %ebx, %ecx + +pext %rax, %rbx, %rcx +pext (%rax), %rbx, %rcx + +rorx $1, %eax, %ecx +rorx $1, (%rax), %ecx + +rorx $1, %rax, %rcx +rorx $1, (%rax), %rcx + +sarx %eax, %ebx, %ecx +sarx %eax, (%rbx), %ecx + +sarx %rax, %rbx, %rcx +sarx %rax, (%rbx), %rcx + +shlx %eax, %ebx, %ecx +shlx %eax, (%rbx), %ecx + +shlx %rax, %rbx, %rcx +shlx %rax, (%rbx), %rcx + +shrx %eax, %ebx, %ecx +shrx %eax, (%rbx), %ecx + +shrx %rax, %rbx, %rcx +shrx %rax, (%rbx), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 bzhil %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 1.00 * bzhil %eax, (%rbx), %ecx +# CHECK-NEXT: 1 3 1.00 bzhiq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 1.00 * bzhiq %rax, (%rbx), %rcx +# CHECK-NEXT: 3 4 1.00 mulxl %eax, %ebx, %ecx +# CHECK-NEXT: 4 9 1.00 * mulxl (%rax), %ebx, %ecx +# CHECK-NEXT: 2 4 1.00 mulxq %rax, %rbx, %rcx +# CHECK-NEXT: 3 9 1.00 * mulxq (%rax), %rbx, %rcx +# CHECK-NEXT: 1 3 1.00 pdepl %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 1.00 * pdepl (%rax), %ebx, %ecx +# CHECK-NEXT: 1 3 1.00 pdepq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 1.00 * pdepq (%rax), %rbx, %rcx +# CHECK-NEXT: 1 3 1.00 pextl %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 1.00 * pextl (%rax), %ebx, %ecx +# CHECK-NEXT: 1 3 1.00 pextq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 1.00 * pextq (%rax), %rbx, %rcx +# CHECK-NEXT: 1 1 0.50 rorxl $1, %eax, %ecx +# CHECK-NEXT: 2 6 0.50 * rorxl $1, (%rax), %ecx +# CHECK-NEXT: 1 1 0.50 rorxq $1, %rax, %rcx +# CHECK-NEXT: 2 6 0.50 * rorxq $1, (%rax), %rcx +# CHECK-NEXT: 1 3 0.50 sarxl %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 0.50 * sarxl %eax, (%rbx), %ecx +# CHECK-NEXT: 1 3 0.50 sarxq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 0.50 * sarxq %rax, (%rbx), %rcx +# CHECK-NEXT: 1 3 0.50 shlxl %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 0.50 * shlxl %eax, (%rbx), %ecx +# CHECK-NEXT: 1 3 0.50 shlxq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 0.50 * shlxq %rax, (%rbx), %rcx +# CHECK-NEXT: 1 3 0.50 shrxl %eax, %ebx, %ecx +# CHECK-NEXT: 2 8 0.50 * shrxl %eax, (%rbx), %ecx +# CHECK-NEXT: 1 3 0.50 shrxq %rax, %rbx, %rcx +# CHECK-NEXT: 2 8 0.50 * shrxq %rax, (%rbx), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 9.40 16.40 5.33 5.33 - 2.40 9.40 - - - 0.40 5.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bzhil %eax, %ebx, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bzhil %eax, (%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bzhiq %rax, %rbx, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bzhiq %rax, (%rbx), %rcx +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - mulxl %eax, %ebx, %ecx +# CHECK-NEXT: 0.70 1.20 0.33 0.33 - 0.20 0.70 - - - 0.20 0.33 - mulxl (%rax), %ebx, %ecx +# CHECK-NEXT: - 1.00 - - - 1.00 - - - - - - - mulxq %rax, %rbx, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - mulxq (%rax), %rbx, %rcx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pdepl %eax, %ebx, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - pdepl (%rax), %ebx, %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pdepq %rax, %rbx, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - pdepq (%rax), %rbx, %rcx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pextl %eax, %ebx, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - pextl (%rax), %ebx, %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pextq %rax, %rbx, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - pextq (%rax), %rbx, %rcx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - rorxl $1, %eax, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - rorxl $1, (%rax), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - rorxq $1, %rax, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - rorxq $1, (%rax), %rcx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarxl %eax, %ebx, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sarxl %eax, (%rbx), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarxq %rax, %rbx, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sarxq %rax, (%rbx), %rcx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlxl %eax, %ebx, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - shlxl %eax, (%rbx), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlxq %rax, %rbx, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - shlxq %rax, (%rbx), %rcx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrxl %eax, %ebx, %ecx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - shrxl %eax, (%rbx), %ecx +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrxq %rax, %rbx, %rcx +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - shrxq %rax, (%rbx), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clflushopt.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clflushopt.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clflushopt.s @@ -0,0 +1,38 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +clflushopt (%rax) + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 3 2 0.50 * * U clflushopt (%rax) + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 0.20 0.20 - - 0.50 0.20 0.20 0.50 0.50 0.50 0.20 - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.20 0.20 - - 0.50 0.20 0.20 0.50 0.50 0.50 0.20 - - clflushopt (%rax) diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clwb.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clwb.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-clwb.s @@ -0,0 +1,38 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +clwb (%rax) + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 3 5 0.50 * * U clwb (%rax) + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 0.20 0.20 - - 0.50 0.20 0.20 0.50 0.50 0.50 0.20 - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.20 0.20 - - 0.50 0.20 0.20 0.50 0.50 0.50 0.20 - - clwb (%rax) diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmov.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmov.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmov.s @@ -0,0 +1,328 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +cmovow %si, %di +cmovnow %si, %di +cmovbw %si, %di +cmovaew %si, %di +cmovew %si, %di +cmovnew %si, %di +cmovbew %si, %di +cmovaw %si, %di +cmovsw %si, %di +cmovnsw %si, %di +cmovpw %si, %di +cmovnpw %si, %di +cmovlw %si, %di +cmovgew %si, %di +cmovlew %si, %di +cmovgw %si, %di + +cmovow (%rax), %di +cmovnow (%rax), %di +cmovbw (%rax), %di +cmovaew (%rax), %di +cmovew (%rax), %di +cmovnew (%rax), %di +cmovbew (%rax), %di +cmovaw (%rax), %di +cmovsw (%rax), %di +cmovnsw (%rax), %di +cmovpw (%rax), %di +cmovnpw (%rax), %di +cmovlw (%rax), %di +cmovgew (%rax), %di +cmovlew (%rax), %di +cmovgw (%rax), %di + +cmovol %esi, %edi +cmovnol %esi, %edi +cmovbl %esi, %edi +cmovael %esi, %edi +cmovel %esi, %edi +cmovnel %esi, %edi +cmovbel %esi, %edi +cmoval %esi, %edi +cmovsl %esi, %edi +cmovnsl %esi, %edi +cmovpl %esi, %edi +cmovnpl %esi, %edi +cmovll %esi, %edi +cmovgel %esi, %edi +cmovlel %esi, %edi +cmovgl %esi, %edi + +cmovol (%rax), %edi +cmovnol (%rax), %edi +cmovbl (%rax), %edi +cmovael (%rax), %edi +cmovel (%rax), %edi +cmovnel (%rax), %edi +cmovbel (%rax), %edi +cmoval (%rax), %edi +cmovsl (%rax), %edi +cmovnsl (%rax), %edi +cmovpl (%rax), %edi +cmovnpl (%rax), %edi +cmovll (%rax), %edi +cmovgel (%rax), %edi +cmovlel (%rax), %edi +cmovgl (%rax), %edi + +cmovoq %rsi, %rdi +cmovnoq %rsi, %rdi +cmovbq %rsi, %rdi +cmovaeq %rsi, %rdi +cmoveq %rsi, %rdi +cmovneq %rsi, %rdi +cmovbeq %rsi, %rdi +cmovaq %rsi, %rdi +cmovsq %rsi, %rdi +cmovnsq %rsi, %rdi +cmovpq %rsi, %rdi +cmovnpq %rsi, %rdi +cmovlq %rsi, %rdi +cmovgeq %rsi, %rdi +cmovleq %rsi, %rdi +cmovgq %rsi, %rdi + +cmovoq (%rax), %rdi +cmovnoq (%rax), %rdi +cmovbq (%rax), %rdi +cmovaeq (%rax), %rdi +cmoveq (%rax), %rdi +cmovneq (%rax), %rdi +cmovbeq (%rax), %rdi +cmovaq (%rax), %rdi +cmovsq (%rax), %rdi +cmovnsq (%rax), %rdi +cmovpq (%rax), %rdi +cmovnpq (%rax), %rdi +cmovlq (%rax), %rdi +cmovgeq (%rax), %rdi +cmovleq (%rax), %rdi +cmovgq (%rax), %rdi + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.50 cmovow %si, %di +# CHECK-NEXT: 1 1 0.50 cmovnow %si, %di +# CHECK-NEXT: 1 1 0.50 cmovbw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovaew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovnew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovbew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovaw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovsw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovnsw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovpw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovnpw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovlw %si, %di +# CHECK-NEXT: 1 1 0.50 cmovgew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovlew %si, %di +# CHECK-NEXT: 1 1 0.50 cmovgw %si, %di +# CHECK-NEXT: 2 7 0.50 * cmovow (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovnow (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovbw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovaew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovnew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovbew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovaw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovsw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovnsw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovpw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovnpw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovlw (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovgew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovlew (%rax), %di +# CHECK-NEXT: 2 7 0.50 * cmovgw (%rax), %di +# CHECK-NEXT: 1 1 0.50 cmovol %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovnol %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovbl %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovael %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovel %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovnel %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovbel %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmoval %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovsl %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovnsl %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovpl %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovnpl %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovll %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovgel %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovlel %esi, %edi +# CHECK-NEXT: 1 1 0.50 cmovgl %esi, %edi +# CHECK-NEXT: 2 7 0.50 * cmovol (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovnol (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovbl (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovael (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovel (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovnel (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovbel (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmoval (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovsl (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovnsl (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovpl (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovnpl (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovll (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovgel (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovlel (%rax), %edi +# CHECK-NEXT: 2 7 0.50 * cmovgl (%rax), %edi +# CHECK-NEXT: 1 1 0.50 cmovoq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovnoq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovbq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovaeq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmoveq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovneq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovbeq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovaq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovsq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovnsq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovpq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovnpq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovlq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovgeq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovleq %rsi, %rdi +# CHECK-NEXT: 1 1 0.50 cmovgq %rsi, %rdi +# CHECK-NEXT: 2 7 0.50 * cmovoq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovnoq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovbq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovaeq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmoveq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovneq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovbeq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovaq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovsq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovnsq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovpq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovnpq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovlq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovgeq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovleq (%rax), %rdi +# CHECK-NEXT: 2 7 0.50 * cmovgq (%rax), %rdi + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 48.00 - 16.00 16.00 - - 48.00 - - - - 16.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovow %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnow %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovaew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovaw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovsw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnsw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovpw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnpw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovlw %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovlew %si, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgw %si, %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovow (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnow (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovaew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovaw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovsw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnsw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovpw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnpw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovlw (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovlew (%rax), %di +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgw (%rax), %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovol %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnol %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbl %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovael %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovel %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnel %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbel %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmoval %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovsl %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnsl %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovpl %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnpl %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovll %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgel %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovlel %esi, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgl %esi, %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovol (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnol (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbl (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovael (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovel (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnel (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbel (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmoval (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovsl (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnsl (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovpl (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnpl (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovll (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgel (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovlel (%rax), %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgl (%rax), %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovoq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnoq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovaeq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmoveq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovneq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovbeq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovaq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovsq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnsq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovpq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovnpq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovlq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgeq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovleq %rsi, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cmovgq %rsi, %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovoq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnoq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovaeq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmoveq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovneq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovbeq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovaq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovsq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnsq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovpq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovnpq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovlq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgeq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovleq (%rax), %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - cmovgq (%rax), %rdi diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmpxchg.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmpxchg.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-cmpxchg.s @@ -0,0 +1,47 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +cmpxchg8b (%rax) +cmpxchg16b (%rax) +lock cmpxchg8b (%rax) +lock cmpxchg16b (%rax) + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 16 25 3.50 * * cmpxchg8b (%rax) +# CHECK-NEXT: 22 32 4.00 * * cmpxchg16b (%rax) +# CHECK-NEXT: 16 25 3.50 * * lock cmpxchg8b (%rax) +# CHECK-NEXT: 22 32 4.00 * * lock cmpxchg16b (%rax) + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 21.40 10.40 1.33 1.33 2.00 10.40 17.40 2.00 2.00 2.00 4.40 1.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 4.30 2.80 0.33 0.33 0.50 0.80 4.30 0.50 0.50 0.50 0.80 0.33 - cmpxchg8b (%rax) +# CHECK-NEXT: 6.40 2.40 0.33 0.33 0.50 4.40 4.40 0.50 0.50 0.50 1.40 0.33 - cmpxchg16b (%rax) +# CHECK-NEXT: 4.30 2.80 0.33 0.33 0.50 0.80 4.30 0.50 0.50 0.50 0.80 0.33 - lock cmpxchg8b (%rax) +# CHECK-NEXT: 6.40 2.40 0.33 0.33 0.50 4.40 4.40 0.50 0.50 0.50 1.40 0.33 - lock cmpxchg16b (%rax) diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-f16c.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-f16c.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-f16c.s @@ -0,0 +1,62 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vcvtph2ps %xmm0, %xmm2 +vcvtph2ps (%rax), %xmm2 + +vcvtph2ps %xmm0, %ymm2 +vcvtph2ps (%rax), %ymm2 + +vcvtps2ph $0, %xmm0, %xmm2 +vcvtps2ph $0, %xmm0, (%rax) + +vcvtps2ph $0, %ymm0, %xmm2 +vcvtps2ph $0, %ymm0, (%rax) + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 6 1.00 vcvtph2ps %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * vcvtph2ps (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 vcvtph2ps %xmm0, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vcvtph2ps (%rax), %ymm2 +# CHECK-NEXT: 2 6 1.00 vcvtps2ph $0, %xmm0, %xmm2 +# CHECK-NEXT: 3 12 0.50 * vcvtps2ph $0, %xmm0, (%rax) +# CHECK-NEXT: 2 8 1.00 vcvtps2ph $0, %ymm0, %xmm2 +# CHECK-NEXT: 3 12 0.50 * vcvtps2ph $0, %ymm0, (%rax) + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 4.00 4.00 0.67 0.67 1.00 4.00 - 1.00 1.00 1.00 - 0.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtph2ps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtph2ps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtph2ps %xmm0, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vcvtph2ps (%rax), %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2ph $0, %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - 0.50 - - 0.50 0.50 0.50 - - - vcvtps2ph $0, %xmm0, (%rax) +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - vcvtps2ph $0, %ymm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - 0.50 - - 0.50 0.50 0.50 - - - vcvtps2ph $0, %ymm0, (%rax) diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fma.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fma.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fma.s @@ -0,0 +1,706 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vfmadd132pd %xmm0, %xmm1, %xmm2 +vfmadd132pd (%rax), %xmm1, %xmm2 + +vfmadd132pd %ymm0, %ymm1, %ymm2 +vfmadd132pd (%rax), %ymm1, %ymm2 + +vfmadd213pd %xmm0, %xmm1, %xmm2 +vfmadd213pd (%rax), %xmm1, %xmm2 + +vfmadd213pd %ymm0, %ymm1, %ymm2 +vfmadd213pd (%rax), %ymm1, %ymm2 + +vfmadd231pd %xmm0, %xmm1, %xmm2 +vfmadd231pd (%rax), %xmm1, %xmm2 + +vfmadd231pd %ymm0, %ymm1, %ymm2 +vfmadd231pd (%rax), %ymm1, %ymm2 + +vfmadd132ps %xmm0, %xmm1, %xmm2 +vfmadd132ps (%rax), %xmm1, %xmm2 + +vfmadd132ps %ymm0, %ymm1, %ymm2 +vfmadd132ps (%rax), %ymm1, %ymm2 + +vfmadd213ps %xmm0, %xmm1, %xmm2 +vfmadd213ps (%rax), %xmm1, %xmm2 + +vfmadd213ps %ymm0, %ymm1, %ymm2 +vfmadd213ps (%rax), %ymm1, %ymm2 + +vfmadd231ps %xmm0, %xmm1, %xmm2 +vfmadd231ps (%rax), %xmm1, %xmm2 + +vfmadd231ps %ymm0, %ymm1, %ymm2 +vfmadd231ps (%rax), %ymm1, %ymm2 + +vfmadd132sd %xmm0, %xmm1, %xmm2 +vfmadd132sd (%rax), %xmm1, %xmm2 + +vfmadd213sd %xmm0, %xmm1, %xmm2 +vfmadd213sd (%rax), %xmm1, %xmm2 + +vfmadd231sd %xmm0, %xmm1, %xmm2 +vfmadd231sd (%rax), %xmm1, %xmm2 + +vfmadd132ss %xmm0, %xmm1, %xmm2 +vfmadd132ss (%rax), %xmm1, %xmm2 + +vfmadd213ss %xmm0, %xmm1, %xmm2 +vfmadd213ss (%rax), %xmm1, %xmm2 + +vfmadd231ss %xmm0, %xmm1, %xmm2 +vfmadd231ss (%rax), %xmm1, %xmm2 + +vfmaddsub132pd %xmm0, %xmm1, %xmm2 +vfmaddsub132pd (%rax), %xmm1, %xmm2 + +vfmaddsub132pd %ymm0, %ymm1, %ymm2 +vfmaddsub132pd (%rax), %ymm1, %ymm2 + +vfmaddsub213pd %xmm0, %xmm1, %xmm2 +vfmaddsub213pd (%rax), %xmm1, %xmm2 + +vfmaddsub213pd %ymm0, %ymm1, %ymm2 +vfmaddsub213pd (%rax), %ymm1, %ymm2 + +vfmaddsub231pd %xmm0, %xmm1, %xmm2 +vfmaddsub231pd (%rax), %xmm1, %xmm2 + +vfmaddsub231pd %ymm0, %ymm1, %ymm2 +vfmaddsub231pd (%rax), %ymm1, %ymm2 + +vfmaddsub132ps %xmm0, %xmm1, %xmm2 +vfmaddsub132ps (%rax), %xmm1, %xmm2 + +vfmaddsub132ps %ymm0, %ymm1, %ymm2 +vfmaddsub132ps (%rax), %ymm1, %ymm2 + +vfmaddsub213ps %xmm0, %xmm1, %xmm2 +vfmaddsub213ps (%rax), %xmm1, %xmm2 + +vfmaddsub213ps %ymm0, %ymm1, %ymm2 +vfmaddsub213ps (%rax), %ymm1, %ymm2 + +vfmaddsub231ps %xmm0, %xmm1, %xmm2 +vfmaddsub231ps (%rax), %xmm1, %xmm2 + +vfmaddsub231ps %ymm0, %ymm1, %ymm2 +vfmaddsub231ps (%rax), %ymm1, %ymm2 + +vfmsub132pd %xmm0, %xmm1, %xmm2 +vfmsub132pd (%rax), %xmm1, %xmm2 + +vfmsub132pd %ymm0, %ymm1, %ymm2 +vfmsub132pd (%rax), %ymm1, %ymm2 + +vfmsub213pd %xmm0, %xmm1, %xmm2 +vfmsub213pd (%rax), %xmm1, %xmm2 + +vfmsub213pd %ymm0, %ymm1, %ymm2 +vfmsub213pd (%rax), %ymm1, %ymm2 + +vfmsub231pd %xmm0, %xmm1, %xmm2 +vfmsub231pd (%rax), %xmm1, %xmm2 + +vfmsub231pd %ymm0, %ymm1, %ymm2 +vfmsub231pd (%rax), %ymm1, %ymm2 + +vfmsub132ps %xmm0, %xmm1, %xmm2 +vfmsub132ps (%rax), %xmm1, %xmm2 + +vfmsub132ps %ymm0, %ymm1, %ymm2 +vfmsub132ps (%rax), %ymm1, %ymm2 + +vfmsub213ps %xmm0, %xmm1, %xmm2 +vfmsub213ps (%rax), %xmm1, %xmm2 + +vfmsub213ps %ymm0, %ymm1, %ymm2 +vfmsub213ps (%rax), %ymm1, %ymm2 + +vfmsub231ps %xmm0, %xmm1, %xmm2 +vfmsub231ps (%rax), %xmm1, %xmm2 + +vfmsub231ps %ymm0, %ymm1, %ymm2 +vfmsub231ps (%rax), %ymm1, %ymm2 + +vfmsub132sd %xmm0, %xmm1, %xmm2 +vfmsub132sd (%rax), %xmm1, %xmm2 + +vfmsub213sd %xmm0, %xmm1, %xmm2 +vfmsub213sd (%rax), %xmm1, %xmm2 + +vfmsub231sd %xmm0, %xmm1, %xmm2 +vfmsub231sd (%rax), %xmm1, %xmm2 + +vfmsub132ss %xmm0, %xmm1, %xmm2 +vfmsub132ss (%rax), %xmm1, %xmm2 + +vfmsub213ss %xmm0, %xmm1, %xmm2 +vfmsub213ss (%rax), %xmm1, %xmm2 + +vfmsub231ss %xmm0, %xmm1, %xmm2 +vfmsub231ss (%rax), %xmm1, %xmm2 + +vfmsubadd132pd %xmm0, %xmm1, %xmm2 +vfmsubadd132pd (%rax), %xmm1, %xmm2 + +vfmsubadd132pd %ymm0, %ymm1, %ymm2 +vfmsubadd132pd (%rax), %ymm1, %ymm2 + +vfmsubadd213pd %xmm0, %xmm1, %xmm2 +vfmsubadd213pd (%rax), %xmm1, %xmm2 + +vfmsubadd213pd %ymm0, %ymm1, %ymm2 +vfmsubadd213pd (%rax), %ymm1, %ymm2 + +vfmsubadd231pd %xmm0, %xmm1, %xmm2 +vfmsubadd231pd (%rax), %xmm1, %xmm2 + +vfmsubadd231pd %ymm0, %ymm1, %ymm2 +vfmsubadd231pd (%rax), %ymm1, %ymm2 + +vfmsubadd132ps %xmm0, %xmm1, %xmm2 +vfmsubadd132ps (%rax), %xmm1, %xmm2 + +vfmsubadd132ps %ymm0, %ymm1, %ymm2 +vfmsubadd132ps (%rax), %ymm1, %ymm2 + +vfmsubadd213ps %xmm0, %xmm1, %xmm2 +vfmsubadd213ps (%rax), %xmm1, %xmm2 + +vfmsubadd213ps %ymm0, %ymm1, %ymm2 +vfmsubadd213ps (%rax), %ymm1, %ymm2 + +vfmsubadd231ps %xmm0, %xmm1, %xmm2 +vfmsubadd231ps (%rax), %xmm1, %xmm2 + +vfmsubadd231ps %ymm0, %ymm1, %ymm2 +vfmsubadd231ps (%rax), %ymm1, %ymm2 + +vfnmadd132pd %xmm0, %xmm1, %xmm2 +vfnmadd132pd (%rax), %xmm1, %xmm2 + +vfnmadd132pd %ymm0, %ymm1, %ymm2 +vfnmadd132pd (%rax), %ymm1, %ymm2 + +vfnmadd213pd %xmm0, %xmm1, %xmm2 +vfnmadd213pd (%rax), %xmm1, %xmm2 + +vfnmadd213pd %ymm0, %ymm1, %ymm2 +vfnmadd213pd (%rax), %ymm1, %ymm2 + +vfnmadd231pd %xmm0, %xmm1, %xmm2 +vfnmadd231pd (%rax), %xmm1, %xmm2 + +vfnmadd231pd %ymm0, %ymm1, %ymm2 +vfnmadd231pd (%rax), %ymm1, %ymm2 + +vfnmadd132ps %xmm0, %xmm1, %xmm2 +vfnmadd132ps (%rax), %xmm1, %xmm2 + +vfnmadd132ps %ymm0, %ymm1, %ymm2 +vfnmadd132ps (%rax), %ymm1, %ymm2 + +vfnmadd213ps %xmm0, %xmm1, %xmm2 +vfnmadd213ps (%rax), %xmm1, %xmm2 + +vfnmadd213ps %ymm0, %ymm1, %ymm2 +vfnmadd213ps (%rax), %ymm1, %ymm2 + +vfnmadd231ps %xmm0, %xmm1, %xmm2 +vfnmadd231ps (%rax), %xmm1, %xmm2 + +vfnmadd231ps %ymm0, %ymm1, %ymm2 +vfnmadd231ps (%rax), %ymm1, %ymm2 + +vfnmadd132sd %xmm0, %xmm1, %xmm2 +vfnmadd132sd (%rax), %xmm1, %xmm2 + +vfnmadd213sd %xmm0, %xmm1, %xmm2 +vfnmadd213sd (%rax), %xmm1, %xmm2 + +vfnmadd231sd %xmm0, %xmm1, %xmm2 +vfnmadd231sd (%rax), %xmm1, %xmm2 + +vfnmadd132ss %xmm0, %xmm1, %xmm2 +vfnmadd132ss (%rax), %xmm1, %xmm2 + +vfnmadd213ss %xmm0, %xmm1, %xmm2 +vfnmadd213ss (%rax), %xmm1, %xmm2 + +vfnmadd231ss %xmm0, %xmm1, %xmm2 +vfnmadd231ss (%rax), %xmm1, %xmm2 + +vfnmsub132pd %xmm0, %xmm1, %xmm2 +vfnmsub132pd (%rax), %xmm1, %xmm2 + +vfnmsub132pd %ymm0, %ymm1, %ymm2 +vfnmsub132pd (%rax), %ymm1, %ymm2 + +vfnmsub213pd %xmm0, %xmm1, %xmm2 +vfnmsub213pd (%rax), %xmm1, %xmm2 + +vfnmsub213pd %ymm0, %ymm1, %ymm2 +vfnmsub213pd (%rax), %ymm1, %ymm2 + +vfnmsub231pd %xmm0, %xmm1, %xmm2 +vfnmsub231pd (%rax), %xmm1, %xmm2 + +vfnmsub231pd %ymm0, %ymm1, %ymm2 +vfnmsub231pd (%rax), %ymm1, %ymm2 + +vfnmsub132ps %xmm0, %xmm1, %xmm2 +vfnmsub132ps (%rax), %xmm1, %xmm2 + +vfnmsub132ps %ymm0, %ymm1, %ymm2 +vfnmsub132ps (%rax), %ymm1, %ymm2 + +vfnmsub213ps %xmm0, %xmm1, %xmm2 +vfnmsub213ps (%rax), %xmm1, %xmm2 + +vfnmsub213ps %ymm0, %ymm1, %ymm2 +vfnmsub213ps (%rax), %ymm1, %ymm2 + +vfnmsub231ps %xmm0, %xmm1, %xmm2 +vfnmsub231ps (%rax), %xmm1, %xmm2 + +vfnmsub231ps %ymm0, %ymm1, %ymm2 +vfnmsub231ps (%rax), %ymm1, %ymm2 + +vfnmsub132sd %xmm0, %xmm1, %xmm2 +vfnmsub132sd (%rax), %xmm1, %xmm2 + +vfnmsub213sd %xmm0, %xmm1, %xmm2 +vfnmsub213sd (%rax), %xmm1, %xmm2 + +vfnmsub231sd %xmm0, %xmm1, %xmm2 +vfnmsub231sd (%rax), %xmm1, %xmm2 + +vfnmsub132ss %xmm0, %xmm1, %xmm2 +vfnmsub132ss (%rax), %xmm1, %xmm2 + +vfnmsub213ss %xmm0, %xmm1, %xmm2 +vfnmsub213ss (%rax), %xmm1, %xmm2 + +vfnmsub231ss %xmm0, %xmm1, %xmm2 +vfnmsub231ss (%rax), %xmm1, %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 4 0.50 vfmadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmadd132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmadd231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmadd231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmaddsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmaddsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmaddsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsub231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsub231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfmsubadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfmsubadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfmsubadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmadd231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmadd231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 2 12 0.50 * vfnmsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 1 4 0.50 vfnmsub231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 2 11 0.50 * vfnmsub231ss (%rax), %xmm1, %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 96.00 96.00 32.00 32.00 - - - - - - - 32.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmadd231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmadd231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmaddsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmaddsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsub231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsub231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfmsubadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfmsubadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmadd231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmadd231ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231pd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231pd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231pd %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231pd (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231ps %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231ps (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231ps %ymm0, %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231ps (%rax), %ymm1, %ymm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231sd %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231sd (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub132ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub132ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub213ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub213ss (%rax), %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vfnmsub231ss %xmm0, %xmm1, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vfnmsub231ss (%rax), %xmm1, %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fsgsbase.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fsgsbase.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-fsgsbase.s @@ -0,0 +1,62 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +rdfsbase %eax +rdfsbase %rax + +rdgsbase %eax +rdgsbase %rax + +wrfsbase %edi +wrfsbase %rdi + +wrgsbase %edi +wrgsbase %rdi + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 100 0.25 * * U rdfsbasel %eax +# CHECK-NEXT: 1 100 0.25 * * U rdfsbaseq %rax +# CHECK-NEXT: 1 100 0.25 * * U rdgsbasel %eax +# CHECK-NEXT: 1 100 0.25 * * U rdgsbaseq %rax +# CHECK-NEXT: 1 100 0.25 * * U wrfsbasel %edi +# CHECK-NEXT: 1 100 0.25 * * U wrfsbaseq %rdi +# CHECK-NEXT: 1 100 0.25 * * U wrgsbasel %edi +# CHECK-NEXT: 1 100 0.25 * * U wrgsbaseq %rdi + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 2.00 2.00 - - - 2.00 2.00 - - - - - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - rdfsbasel %eax +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - rdfsbaseq %rax +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - rdgsbasel %eax +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - rdgsbaseq %rax +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - wrfsbasel %edi +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - wrfsbaseq %rdi +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - wrgsbasel %edi +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - wrgsbaseq %rdi diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-gfni.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-gfni.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-gfni.s @@ -0,0 +1,55 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +gf2p8affineinvqb $0, %xmm0, %xmm1 +gf2p8affineinvqb $0, (%rax), %xmm1 + +gf2p8affineqb $0, %xmm0, %xmm1 +gf2p8affineqb $0, (%rax), %xmm1 + +gf2p8mulb %xmm0, %xmm1 +gf2p8mulb (%rax), %xmm1 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 gf2p8affineinvqb $0, %xmm0, %xmm1 +# CHECK-NEXT: 2 12 0.50 * gf2p8affineinvqb $0, (%rax), %xmm1 +# CHECK-NEXT: 1 5 0.50 gf2p8affineqb $0, %xmm0, %xmm1 +# CHECK-NEXT: 2 12 0.50 * gf2p8affineqb $0, (%rax), %xmm1 +# CHECK-NEXT: 1 5 0.50 gf2p8mulb %xmm0, %xmm1 +# CHECK-NEXT: 2 12 0.50 * gf2p8mulb (%rax), %xmm1 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 3.00 3.00 1.00 1.00 - - - - - - - 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - gf2p8affineinvqb $0, %xmm0, %xmm1 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - gf2p8affineinvqb $0, (%rax), %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - gf2p8affineqb $0, %xmm0, %xmm1 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - gf2p8affineqb $0, (%rax), %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - gf2p8mulb %xmm0, %xmm1 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - gf2p8mulb (%rax), %xmm1 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lea.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lea.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lea.s @@ -0,0 +1,442 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +lea 0(), %cx +lea 0(), %ecx +lea 0(), %rcx +lea (%eax), %cx +lea (%eax), %ecx +lea (%eax), %rcx +lea (%rax), %cx +lea (%rax), %ecx +lea (%rax), %rcx +lea (, %ebx), %cx +lea (, %ebx), %ecx +lea (, %ebx), %rcx +lea (, %rbx), %cx +lea (, %rbx), %ecx +lea (, %rbx), %rcx +lea (, %ebx, 1), %cx +lea (, %ebx, 1), %ecx +lea (, %ebx, 1), %rcx +lea (, %rbx, 1), %cx +lea (, %rbx, 1), %ecx +lea (, %rbx, 1), %rcx +lea (, %ebx, 2), %cx +lea (, %ebx, 2), %ecx +lea (, %ebx, 2), %rcx +lea (, %rbx, 2), %cx +lea (, %rbx, 2), %ecx +lea (, %rbx, 2), %rcx +lea (%eax, %ebx), %cx +lea (%eax, %ebx), %ecx +lea (%eax, %ebx), %rcx +lea (%rax, %rbx), %cx +lea (%rax, %rbx), %ecx +lea (%rax, %rbx), %rcx +lea (%eax, %ebx, 1), %cx +lea (%eax, %ebx, 1), %ecx +lea (%eax, %ebx, 1), %rcx +lea (%rax, %rbx, 1), %cx +lea (%rax, %rbx, 1), %ecx +lea (%rax, %rbx, 1), %rcx +lea (%eax, %ebx, 2), %cx +lea (%eax, %ebx, 2), %ecx +lea (%eax, %ebx, 2), %rcx +lea (%rax, %rbx, 2), %cx +lea (%rax, %rbx, 2), %ecx +lea (%rax, %rbx, 2), %rcx + +lea -16(), %cx +lea -16(), %ecx +lea -16(), %rcx +lea -16(%eax), %cx +lea -16(%eax), %ecx +lea -16(%eax), %rcx +lea -16(%rax), %cx +lea -16(%rax), %ecx +lea -16(%rax), %rcx +lea -16(, %ebx), %cx +lea -16(, %ebx), %ecx +lea -16(, %ebx), %rcx +lea -16(, %rbx), %cx +lea -16(, %rbx), %ecx +lea -16(, %rbx), %rcx +lea -16(, %ebx, 1), %cx +lea -16(, %ebx, 1), %ecx +lea -16(, %ebx, 1), %rcx +lea -16(, %rbx, 1), %cx +lea -16(, %rbx, 1), %ecx +lea -16(, %rbx, 1), %rcx +lea -16(, %ebx, 2), %cx +lea -16(, %ebx, 2), %ecx +lea -16(, %ebx, 2), %rcx +lea -16(, %rbx, 2), %cx +lea -16(, %rbx, 2), %ecx +lea -16(, %rbx, 2), %rcx +lea -16(%eax, %ebx), %cx +lea -16(%eax, %ebx), %ecx +lea -16(%eax, %ebx), %rcx +lea -16(%rax, %rbx), %cx +lea -16(%rax, %rbx), %ecx +lea -16(%rax, %rbx), %rcx +lea -16(%eax, %ebx, 1), %cx +lea -16(%eax, %ebx, 1), %ecx +lea -16(%eax, %ebx, 1), %rcx +lea -16(%rax, %rbx, 1), %cx +lea -16(%rax, %rbx, 1), %ecx +lea -16(%rax, %rbx, 1), %rcx +lea -16(%eax, %ebx, 2), %cx +lea -16(%eax, %ebx, 2), %ecx +lea -16(%eax, %ebx, 2), %rcx +lea -16(%rax, %rbx, 2), %cx +lea -16(%rax, %rbx, 2), %ecx +lea -16(%rax, %rbx, 2), %rcx + +lea 1024(), %cx +lea 1024(), %ecx +lea 1024(), %rcx +lea 1024(%eax), %cx +lea 1024(%eax), %ecx +lea 1024(%eax), %rcx +lea 1024(%rax), %cx +lea 1024(%rax), %ecx +lea 1024(%rax), %rcx +lea 1024(, %ebx), %cx +lea 1024(, %ebx), %ecx +lea 1024(, %ebx), %rcx +lea 1024(, %rbx), %cx +lea 1024(, %rbx), %ecx +lea 1024(, %rbx), %rcx +lea 1024(, %ebx, 1), %cx +lea 1024(, %ebx, 1), %ecx +lea 1024(, %ebx, 1), %rcx +lea 1024(, %rbx, 1), %cx +lea 1024(, %rbx, 1), %ecx +lea 1024(, %rbx, 1), %rcx +lea 1024(, %ebx, 2), %cx +lea 1024(, %ebx, 2), %ecx +lea 1024(, %ebx, 2), %rcx +lea 1024(, %rbx, 2), %cx +lea 1024(, %rbx, 2), %ecx +lea 1024(, %rbx, 2), %rcx +lea 1024(%eax, %ebx), %cx +lea 1024(%eax, %ebx), %ecx +lea 1024(%eax, %ebx), %rcx +lea 1024(%rax, %rbx), %cx +lea 1024(%rax, %rbx), %ecx +lea 1024(%rax, %rbx), %rcx +lea 1024(%eax, %ebx, 1), %cx +lea 1024(%eax, %ebx, 1), %ecx +lea 1024(%eax, %ebx, 1), %rcx +lea 1024(%rax, %rbx, 1), %cx +lea 1024(%rax, %rbx, 1), %ecx +lea 1024(%rax, %rbx, 1), %rcx +lea 1024(%eax, %ebx, 2), %cx +lea 1024(%eax, %ebx, 2), %ecx +lea 1024(%eax, %ebx, 2), %rcx +lea 1024(%rax, %rbx, 2), %cx +lea 1024(%rax, %rbx, 2), %ecx +lea 1024(%rax, %rbx, 2), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 2 2 1.00 leaw 0, %cx +# CHECK-NEXT: 1 1 1.00 leal 0, %ecx +# CHECK-NEXT: 1 1 1.00 leaq 0, %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%eax), %cx +# CHECK-NEXT: 1 1 1.00 leal (%eax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%eax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%rax), %cx +# CHECK-NEXT: 1 1 1.00 leal (%rax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%rax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal (,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (,%rbx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal (%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal (%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal (%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal (%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%eax,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal (%eax,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%eax,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw (%rax,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal (%rax,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq (%rax,%rbx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16, %cx +# CHECK-NEXT: 1 1 1.00 leal -16, %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16, %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%eax), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%eax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%eax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%rax), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%rax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%rax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(,%rbx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%eax,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%eax,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%eax,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw -16(%rax,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal -16(%rax,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq -16(%rax,%rbx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024, %cx +# CHECK-NEXT: 1 1 1.00 leal 1024, %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024, %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%eax), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%eax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%eax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%rax), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%rax), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%rax), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(,%rbx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%eax,%ebx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%eax,%ebx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%eax,%ebx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%rax,%rbx), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%rax,%rbx), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%rax,%rbx), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%eax,%ebx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%eax,%ebx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%eax,%ebx,2), %rcx +# CHECK-NEXT: 2 2 1.00 leaw 1024(%rax,%rbx,2), %cx +# CHECK-NEXT: 1 1 1.00 leal 1024(%rax,%rbx,2), %ecx +# CHECK-NEXT: 1 1 1.00 leaq 1024(%rax,%rbx,2), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 9.00 144.00 - - - 9.00 9.00 - - - 9.00 - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 0, %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 0, %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 0, %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%eax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%eax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%eax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%rax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (,%rbx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%eax,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%eax,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%eax,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw (%rax,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal (%rax,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq (%rax,%rbx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16, %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16, %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16, %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%eax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%eax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%eax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%rax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(,%rbx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%eax,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%eax,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%eax,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw -16(%rax,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal -16(%rax,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq -16(%rax,%rbx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024, %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024, %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024, %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%eax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%eax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%eax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%rax), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(,%rbx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%eax,%ebx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%eax,%ebx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%eax,%ebx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%rax,%rbx), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%rax,%rbx), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%rax,%rbx), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%eax,%ebx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%eax,%ebx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%eax,%ebx,2), %rcx +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - leaw 1024(%rax,%rbx,2), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leal 1024(%rax,%rbx,2), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - leaq 1024(%rax,%rbx,2), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lzcnt.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lzcnt.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-lzcnt.s @@ -0,0 +1,55 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +lzcntw %cx, %cx +lzcntw (%rax), %cx + +lzcntl %eax, %ecx +lzcntl (%rax), %ecx + +lzcntq %rax, %rcx +lzcntq (%rax), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 lzcntw %cx, %cx +# CHECK-NEXT: 2 8 1.00 * lzcntw (%rax), %cx +# CHECK-NEXT: 1 3 1.00 lzcntl %eax, %ecx +# CHECK-NEXT: 2 8 1.00 * lzcntl (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 lzcntq %rax, %rcx +# CHECK-NEXT: 2 8 1.00 * lzcntq (%rax), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - 6.00 1.00 1.00 - - - - - - - 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 1.00 - - - - - - - - - - - lzcntw %cx, %cx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - lzcntw (%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - lzcntl %eax, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - lzcntl (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - lzcntq %rax, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - lzcntq (%rax), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-mmx.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-mmx.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-mmx.s @@ -0,0 +1,398 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +emms + +movd %eax, %mm2 +movd (%rax), %mm2 + +movd %mm0, %ecx +movd %mm0, (%rax) + +movq %rax, %mm2 +movq (%rax), %mm2 + +movq %mm0, %rcx +movq %mm0, (%rax) + +packsswb %mm0, %mm2 +packsswb (%rax), %mm2 + +packssdw %mm0, %mm2 +packssdw (%rax), %mm2 + +packuswb %mm0, %mm2 +packuswb (%rax), %mm2 + +paddb %mm0, %mm2 +paddb (%rax), %mm2 + +paddd %mm0, %mm2 +paddd (%rax), %mm2 + +paddsb %mm0, %mm2 +paddsb (%rax), %mm2 + +paddsw %mm0, %mm2 +paddsw (%rax), %mm2 + +paddusb %mm0, %mm2 +paddusb (%rax), %mm2 + +paddusw %mm0, %mm2 +paddusw (%rax), %mm2 + +paddw %mm0, %mm2 +paddw (%rax), %mm2 + +pand %mm0, %mm2 +pand (%rax), %mm2 + +pandn %mm0, %mm2 +pandn (%rax), %mm2 + +pcmpeqb %mm0, %mm2 +pcmpeqb (%rax), %mm2 + +pcmpeqd %mm0, %mm2 +pcmpeqd (%rax), %mm2 + +pcmpeqw %mm0, %mm2 +pcmpeqw (%rax), %mm2 + +pcmpgtb %mm0, %mm2 +pcmpgtb (%rax), %mm2 + +pcmpgtd %mm0, %mm2 +pcmpgtd (%rax), %mm2 + +pcmpgtw %mm0, %mm2 +pcmpgtw (%rax), %mm2 + +pmaddwd %mm0, %mm2 +pmaddwd (%rax), %mm2 + +pmulhw %mm0, %mm2 +pmulhw (%rax), %mm2 + +pmullw %mm0, %mm2 +pmullw (%rax), %mm2 + +por %mm0, %mm2 +por (%rax), %mm2 + +pslld $1, %mm2 +pslld %mm0, %mm2 +pslld (%rax), %mm2 + +psllq $1, %mm2 +psllq %mm0, %mm2 +psllq (%rax), %mm2 + +psllw $1, %mm2 +psllw %mm0, %mm2 +psllw (%rax), %mm2 + +psrad $1, %mm2 +psrad %mm0, %mm2 +psrad (%rax), %mm2 + +psraw $1, %mm2 +psraw %mm0, %mm2 +psraw (%rax), %mm2 + +psrld $1, %mm2 +psrld %mm0, %mm2 +psrld (%rax), %mm2 + +psrlq $1, %mm2 +psrlq %mm0, %mm2 +psrlq (%rax), %mm2 + +psrlw $1, %mm2 +psrlw %mm0, %mm2 +psrlw (%rax), %mm2 + +psubb %mm0, %mm2 +psubb (%rax), %mm2 + +psubd %mm0, %mm2 +psubd (%rax), %mm2 + +psubsb %mm0, %mm2 +psubsb (%rax), %mm2 + +psubsw %mm0, %mm2 +psubsw (%rax), %mm2 + +psubusb %mm0, %mm2 +psubusb (%rax), %mm2 + +psubusw %mm0, %mm2 +psubusw (%rax), %mm2 + +psubw %mm0, %mm2 +psubw (%rax), %mm2 + +punpckhbw %mm0, %mm2 +punpckhbw (%rax), %mm2 + +punpckhdq %mm0, %mm2 +punpckhdq (%rax), %mm2 + +punpckhwd %mm0, %mm2 +punpckhwd (%rax), %mm2 + +punpcklbw %mm0, %mm2 +punpcklbw (%rax), %mm2 + +punpckldq %mm0, %mm2 +punpckldq (%rax), %mm2 + +punpcklwd %mm0, %mm2 +punpcklwd (%rax), %mm2 + +pxor %mm0, %mm2 +pxor (%rax), %mm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 10 10 4.50 * * U emms +# CHECK-NEXT: 1 3 1.00 movd %eax, %mm2 +# CHECK-NEXT: 1 8 0.33 * movd (%rax), %mm2 +# CHECK-NEXT: 1 3 1.00 movd %mm0, %ecx +# CHECK-NEXT: 2 18 0.50 * U movd %mm0, (%rax) +# CHECK-NEXT: 1 3 1.00 movq %rax, %mm2 +# CHECK-NEXT: 1 8 0.33 * movq (%rax), %mm2 +# CHECK-NEXT: 1 3 1.00 movq %mm0, %rcx +# CHECK-NEXT: 2 12 0.50 * movq %mm0, (%rax) +# CHECK-NEXT: 2 4 2.00 packsswb %mm0, %mm2 +# CHECK-NEXT: 3 12 2.00 * packsswb (%rax), %mm2 +# CHECK-NEXT: 2 4 2.00 packssdw %mm0, %mm2 +# CHECK-NEXT: 3 12 2.00 * packssdw (%rax), %mm2 +# CHECK-NEXT: 2 4 2.00 packuswb %mm0, %mm2 +# CHECK-NEXT: 3 12 2.00 * packuswb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 paddb %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * paddb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 paddd %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * paddd (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 paddsb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * paddsb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 paddsw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * paddsw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 paddusb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * paddusb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 paddusw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * paddusw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 paddw %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * paddw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pand %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * pand (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pandn %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * pandn (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpeqb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpeqb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpeqd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpeqd (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpeqw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpeqw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpgtb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpgtb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpgtd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpgtd (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpgtw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pcmpgtw (%rax), %mm2 +# CHECK-NEXT: 1 5 1.00 pmaddwd %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmaddwd (%rax), %mm2 +# CHECK-NEXT: 1 5 1.00 pmulhw %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmulhw (%rax), %mm2 +# CHECK-NEXT: 1 5 1.00 pmullw %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmullw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 por %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * por (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pslld $1, %mm2 +# CHECK-NEXT: 1 1 1.00 pslld %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pslld (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psllq $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psllq %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psllq (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psllw $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psllw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psllw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psrad $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psrad %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psrad (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psraw $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psraw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psraw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psrld $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psrld %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psrld (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psrlq $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psrlq %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psrlq (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psrlw $1, %mm2 +# CHECK-NEXT: 1 1 1.00 psrlw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psrlw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psubb %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * psubb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psubd %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * psubd (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psubsb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psubsb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psubsw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psubsw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psubusb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psubusb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 psubusw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psubusw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psubw %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * psubw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpckhbw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpckhbw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpckhdq %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpckhdq (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpckhwd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpckhwd (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpcklbw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpcklbw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpckldq %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpckldq (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 punpcklwd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * punpcklwd (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pxor %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * pxor (%rax), %mm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 75.50 - 15.33 15.33 1.00 40.00 0.50 1.00 1.00 1.00 - 15.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 5.50 - - - - 4.00 0.50 - - - - - - emms +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movd %eax, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movd %mm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movd %mm0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movq %rax, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movq (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movq %mm0, %rcx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movq %mm0, (%rax) +# CHECK-NEXT: - - - - - 2.00 - - - - - - - packsswb %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - packsswb (%rax), %mm2 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - packssdw %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - packssdw (%rax), %mm2 +# CHECK-NEXT: - - - - - 2.00 - - - - - - - packuswb %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - packuswb (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - paddb %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - paddb (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - paddd %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - paddd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - paddsb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - paddsb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - paddsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - paddsw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - paddusb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - paddusb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - paddusw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - paddusw (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - paddw %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - paddw (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - pand %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - pand (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - pandn %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - pandn (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpeqb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpeqb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpeqd %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpeqd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpeqw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpeqw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpgtb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtd %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpgtd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpgtw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmaddwd %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmaddwd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmulhw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmulhw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmullw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmullw (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - por %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - por (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pslld $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pslld %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pslld (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psllq $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psllq %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psllq (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psllw $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psllw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psllw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrad $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrad %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psrad (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psraw $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psraw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psraw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrld $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrld %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psrld (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrlq $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrlq %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psrlq (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrlw $1, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psrlw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psrlw (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - psubb %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - psubb (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - psubd %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - psubd (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubsb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psubsb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psubsw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubusb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psubusb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubusw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psubusw (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - psubw %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - psubw (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpckhbw %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpckhbw (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpckhdq %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpckhdq (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpckhwd %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpckhwd (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpcklbw %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpcklbw (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpckldq %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpckldq (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - punpcklwd %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - punpcklwd (%rax), %mm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - pxor %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - pxor (%rax), %mm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-movbe.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-movbe.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-movbe.s @@ -0,0 +1,55 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +movbe %cx, (%rax) +movbe (%rax), %cx + +movbe %ecx, (%rax) +movbe (%rax), %ecx + +movbe %rcx, (%rax) +movbe (%rax), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 3 12 0.50 * movbew %cx, (%rax) +# CHECK-NEXT: 3 7 0.50 * movbew (%rax), %cx +# CHECK-NEXT: 3 12 1.00 * movbel %ecx, (%rax) +# CHECK-NEXT: 2 6 1.00 * movbel (%rax), %ecx +# CHECK-NEXT: 4 12 1.00 * movbeq %rcx, (%rax) +# CHECK-NEXT: 3 7 1.00 * movbeq (%rax), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 2.20 4.20 1.00 1.00 1.50 0.20 2.20 1.50 1.50 1.50 0.20 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 - - - 0.50 - 0.50 0.50 0.50 0.50 - - - movbew %cx, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 - 0.20 0.70 - - - 0.20 0.33 - movbew (%rax), %cx +# CHECK-NEXT: - 1.00 - - 0.50 - - 0.50 0.50 0.50 - - - movbel %ecx, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - movbel (%rax), %ecx +# CHECK-NEXT: 0.50 1.00 - - 0.50 - 0.50 0.50 0.50 0.50 - - - movbeq %rcx, (%rax) +# CHECK-NEXT: 0.50 1.00 0.33 0.33 - - 0.50 - - - - 0.33 - movbeq (%rax), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-pclmul.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-pclmul.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-pclmul.s @@ -0,0 +1,41 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +pclmulqdq $11, %xmm0, %xmm2 +pclmulqdq $11, (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 pclmulqdq $11, %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * pclmulqdq $11, (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - pclmulqdq $11, %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - pclmulqdq $11, (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-popcnt.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-popcnt.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-popcnt.s @@ -0,0 +1,55 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +popcntw %cx, %cx +popcntw (%rax), %cx + +popcntl %eax, %ecx +popcntl (%rax), %ecx + +popcntq %rax, %rcx +popcntq (%rax), %rcx + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 popcntw %cx, %cx +# CHECK-NEXT: 2 8 1.00 * popcntw (%rax), %cx +# CHECK-NEXT: 1 3 1.00 popcntl %eax, %ecx +# CHECK-NEXT: 2 8 1.00 * popcntl (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 popcntq %rax, %rcx +# CHECK-NEXT: 2 8 1.00 * popcntq (%rax), %rcx + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - 6.00 1.00 1.00 - - - - - - - 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 1.00 - - - - - - - - - - - popcntw %cx, %cx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - popcntw (%rax), %cx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - popcntl %eax, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - popcntl (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - popcntq %rax, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - popcntq (%rax), %rcx diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-prefetchw.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-prefetchw.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-prefetchw.s @@ -0,0 +1,41 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +prefetch (%rax) +prefetchw (%rax) + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.33 * * prefetch (%rax) +# CHECK-NEXT: 1 5 0.33 * * prefetchw (%rax) + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 0.67 0.67 - - - - - - - 0.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetch (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetchw (%rax) diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdrand.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdrand.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdrand.s @@ -0,0 +1,44 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +rdrand %ax +rdrand %eax +rdrand %rax + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 25 1386 7.00 U rdrandw %ax +# CHECK-NEXT: 25 100 7.00 U rdrandl %eax +# CHECK-NEXT: 25 100 7.00 U rdrandq %rax + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 17.30 27.30 1.00 1.00 - 14.30 11.30 - - - 1.80 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 5.77 9.10 0.33 0.33 - 4.77 3.77 - - - 0.60 0.33 - rdrandw %ax +# CHECK-NEXT: 5.77 9.10 0.33 0.33 - 4.77 3.77 - - - 0.60 0.33 - rdrandl %eax +# CHECK-NEXT: 5.77 9.10 0.33 0.33 - 4.77 3.77 - - - 0.60 0.33 - rdrandq %rax diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdseed.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdseed.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-rdseed.s @@ -0,0 +1,44 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +rdseed %ax +rdseed %eax +rdseed %rax + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 25 1381 7.00 U rdseedw %ax +# CHECK-NEXT: 25 100 7.00 U rdseedl %eax +# CHECK-NEXT: 25 100 7.00 U rdseedq %rax + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 19.50 24.00 1.00 1.00 - 18.00 10.50 - - - - 1.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 6.50 8.00 0.33 0.33 - 6.00 3.50 - - - - 0.33 - rdseedw %ax +# CHECK-NEXT: 6.50 8.00 0.33 0.33 - 6.00 3.50 - - - - 0.33 - rdseedl %eax +# CHECK-NEXT: 6.50 8.00 0.33 0.33 - 6.00 3.50 - - - - 0.33 - rdseedq %rax diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse1.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse1.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse1.s @@ -0,0 +1,466 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +addps %xmm0, %xmm2 +addps (%rax), %xmm2 + +addss %xmm0, %xmm2 +addss (%rax), %xmm2 + +andnps %xmm0, %xmm2 +andnps (%rax), %xmm2 + +andps %xmm0, %xmm2 +andps (%rax), %xmm2 + +cmpps $0, %xmm0, %xmm2 +cmpps $0, (%rax), %xmm2 + +cmpss $0, %xmm0, %xmm2 +cmpss $0, (%rax), %xmm2 + +comiss %xmm0, %xmm1 +comiss (%rax), %xmm1 + +cvtpi2ps %mm0, %xmm2 +cvtpi2ps (%rax), %xmm2 + +cvtps2pi %xmm0, %mm2 +cvtps2pi (%rax), %mm2 + +cvtsi2ss %ecx, %xmm2 +cvtsi2ss %rcx, %xmm2 +cvtsi2ssl (%rax), %xmm2 +cvtsi2ssq (%rax), %xmm2 + +cvtss2si %xmm0, %ecx +cvtss2si %xmm0, %rcx +cvtss2si (%rax), %ecx +cvtss2si (%rax), %rcx + +cvttps2pi %xmm0, %mm2 +cvttps2pi (%rax), %mm2 + +cvttss2si %xmm0, %ecx +cvttss2si %xmm0, %rcx +cvttss2si (%rax), %ecx +cvttss2si (%rax), %rcx + +divps %xmm0, %xmm2 +divps (%rax), %xmm2 + +divss %xmm0, %xmm2 +divss (%rax), %xmm2 + +ldmxcsr (%rax) + +maskmovq %mm0, %mm1 + +maxps %xmm0, %xmm2 +maxps (%rax), %xmm2 + +maxss %xmm0, %xmm2 +maxss (%rax), %xmm2 + +minps %xmm0, %xmm2 +minps (%rax), %xmm2 + +minss %xmm0, %xmm2 +minss (%rax), %xmm2 + +movaps %xmm0, %xmm2 +movaps %xmm0, (%rax) +movaps (%rax), %xmm2 + +movhlps %xmm0, %xmm2 +movlhps %xmm0, %xmm2 + +movhps %xmm0, (%rax) +movhps (%rax), %xmm2 + +movlps %xmm0, (%rax) +movlps (%rax), %xmm2 + +movmskps %xmm0, %rcx + +movntps %xmm0, (%rax) +movntq %mm0, (%rax) + +movss %xmm0, %xmm2 +movss %xmm0, (%rax) +movss (%rax), %xmm2 + +movups %xmm0, %xmm2 +movups %xmm0, (%rax) +movups (%rax), %xmm2 + +mulps %xmm0, %xmm2 +mulps (%rax), %xmm2 + +mulss %xmm0, %xmm2 +mulss (%rax), %xmm2 + +orps %xmm0, %xmm2 +orps (%rax), %xmm2 + +pavgb %mm0, %mm2 +pavgb (%rax), %mm2 + +pavgw %mm0, %mm2 +pavgw (%rax), %mm2 + +pextrw $1, %mm0, %rcx + +pinsrw $1, %rax, %mm2 +pinsrw $1, (%rax), %mm2 + +pmaxsw %mm0, %mm2 +pmaxsw (%rax), %mm2 + +pmaxub %mm0, %mm2 +pmaxub (%rax), %mm2 + +pminsw %mm0, %mm2 +pminsw (%rax), %mm2 + +pminub %mm0, %mm2 +pminub (%rax), %mm2 + +pmovmskb %mm0, %rcx + +pmulhuw %mm0, %mm2 +pmulhuw (%rax), %mm2 + +prefetcht0 (%rax) +prefetcht1 (%rax) +prefetcht2 (%rax) +prefetchnta (%rax) + +psadbw %mm0, %mm2 +psadbw (%rax), %mm2 + +pshufw $1, %mm0, %mm2 +pshufw $1, (%rax), %mm2 + +rcpps %xmm0, %xmm2 +rcpps (%rax), %xmm2 + +rcpss %xmm0, %xmm2 +rcpss (%rax), %xmm2 + +rsqrtps %xmm0, %xmm2 +rsqrtps (%rax), %xmm2 + +rsqrtss %xmm0, %xmm2 +rsqrtss (%rax), %xmm2 + +sfence + +shufps $1, %xmm0, %xmm2 +shufps $1, (%rax), %xmm2 + +sqrtps %xmm0, %xmm2 +sqrtps (%rax), %xmm2 + +sqrtss %xmm0, %xmm2 +sqrtss (%rax), %xmm2 + +stmxcsr (%rax) + +subps %xmm0, %xmm2 +subps (%rax), %xmm2 + +subss %xmm0, %xmm2 +subss (%rax), %xmm2 + +ucomiss %xmm0, %xmm1 +ucomiss (%rax), %xmm1 + +unpckhps %xmm0, %xmm2 +unpckhps (%rax), %xmm2 + +unpcklps %xmm0, %xmm2 +unpcklps (%rax), %xmm2 + +xorps %xmm0, %xmm2 +xorps (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 0.50 addps %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addps (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 addss %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addss (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 andnps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * andnps (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 andps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * andps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 cmpeqps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cmpeqps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 cmpeqss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cmpeqss (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 comiss %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * comiss (%rax), %xmm1 +# CHECK-NEXT: 2 7 1.00 cvtpi2ps %mm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtpi2ps (%rax), %xmm2 +# CHECK-NEXT: 2 9 1.00 cvtps2pi %xmm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * cvtps2pi (%rax), %mm2 +# CHECK-NEXT: 2 7 1.00 cvtsi2ss %ecx, %xmm2 +# CHECK-NEXT: 3 8 2.00 cvtsi2ss %rcx, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtsi2ssl (%rax), %xmm2 +# CHECK-NEXT: 3 12 1.00 * cvtsi2ssq (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 cvtss2si %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 cvtss2si %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * cvtss2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * cvtss2si (%rax), %rcx +# CHECK-NEXT: 2 9 1.00 cvttps2pi %xmm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * cvttps2pi (%rax), %mm2 +# CHECK-NEXT: 2 7 1.00 cvttss2si %xmm0, %ecx +# CHECK-NEXT: 3 8 1.00 cvttss2si %xmm0, %rcx +# CHECK-NEXT: 3 12 1.00 * cvttss2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * cvttss2si (%rax), %rcx +# CHECK-NEXT: 1 11 1.00 divps %xmm0, %xmm2 +# CHECK-NEXT: 2 18 1.00 * divps (%rax), %xmm2 +# CHECK-NEXT: 1 11 1.00 divss %xmm0, %xmm2 +# CHECK-NEXT: 2 18 1.00 * divss (%rax), %xmm2 +# CHECK-NEXT: 4 7 1.00 * * U ldmxcsr (%rax) +# CHECK-NEXT: 4 12 2.00 * * U maskmovq %mm0, %mm1 +# CHECK-NEXT: 1 4 0.50 maxps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * maxps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 maxss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * maxss (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 minps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * minps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 minss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * minss (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 movaps %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movaps %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movaps (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 movhlps %xmm0, %xmm2 +# CHECK-NEXT: 1 1 1.00 movlhps %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movhps %xmm0, (%rax) +# CHECK-NEXT: 2 8 1.00 * movhps (%rax), %xmm2 +# CHECK-NEXT: 2 12 0.50 * movlps %xmm0, (%rax) +# CHECK-NEXT: 2 8 0.50 * movlps (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 movmskps %xmm0, %ecx +# CHECK-NEXT: 2 518 0.50 * movntps %xmm0, (%rax) +# CHECK-NEXT: 2 511 0.50 * * U movntq %mm0, (%rax) +# CHECK-NEXT: 1 1 0.33 movss %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movss %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movss (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 movups %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movups %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movups (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 mulps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * mulps (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 mulss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * mulss (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 orps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * orps (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 pavgb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pavgb (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pavgw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pavgw (%rax), %mm2 +# CHECK-NEXT: 2 4 1.00 pextrw $1, %mm0, %ecx +# CHECK-NEXT: 2 4 2.00 pinsrw $1, %eax, %mm2 +# CHECK-NEXT: 2 9 1.00 * pinsrw $1, (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pmaxsw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pmaxsw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pmaxub %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pmaxub (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pminsw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pminsw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pminub %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pminub (%rax), %mm2 +# CHECK-NEXT: 1 3 1.00 pmovmskb %mm0, %ecx +# CHECK-NEXT: 1 5 1.00 pmulhuw %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmulhuw (%rax), %mm2 +# CHECK-NEXT: 1 0 0.33 * * prefetcht0 (%rax) +# CHECK-NEXT: 1 0 0.33 * * prefetcht1 (%rax) +# CHECK-NEXT: 1 0 0.33 * * prefetcht2 (%rax) +# CHECK-NEXT: 1 0 0.33 * * prefetchnta (%rax) +# CHECK-NEXT: 1 3 1.00 psadbw %mm0, %mm2 +# CHECK-NEXT: 2 11 1.00 * psadbw (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 pshufw $1, %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pshufw $1, (%rax), %mm2 +# CHECK-NEXT: 1 4 1.00 rcpps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * rcpps (%rax), %xmm2 +# CHECK-NEXT: 1 4 1.00 rcpss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * rcpss (%rax), %xmm2 +# CHECK-NEXT: 1 4 1.00 rsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * rsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1 4 1.00 rsqrtss %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * rsqrtss (%rax), %xmm2 +# CHECK-NEXT: 2 2 0.50 * * U sfence +# CHECK-NEXT: 1 1 0.50 shufps $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * shufps $1, (%rax), %xmm2 +# CHECK-NEXT: 1 12 1.00 sqrtps %xmm0, %xmm2 +# CHECK-NEXT: 2 19 1.00 * sqrtps (%rax), %xmm2 +# CHECK-NEXT: 1 12 1.00 sqrtss %xmm0, %xmm2 +# CHECK-NEXT: 2 19 1.00 * sqrtss (%rax), %xmm2 +# CHECK-NEXT: 4 12 1.00 * U stmxcsr (%rax) +# CHECK-NEXT: 1 3 0.50 subps %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * subps (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 subss %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * subss (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 ucomiss %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * ucomiss (%rax), %xmm1 +# CHECK-NEXT: 1 1 1.00 unpckhps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * unpckhps (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 unpcklps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * unpcklps (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 xorps %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * xorps (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 74.00 24.50 19.33 19.33 5.00 30.50 1.00 5.00 5.00 5.00 - 19.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addps %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addps (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addss %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addss (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - andnps %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - andnps (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - andps %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - andps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cmpeqps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cmpeqps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cmpeqss %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cmpeqss (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - comiss %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - comiss (%rax), %xmm1 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvtpi2ps %mm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtpi2ps (%rax), %xmm2 +# CHECK-NEXT: 1.33 0.33 - - - 0.33 - - - - - - - cvtps2pi %xmm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - cvtps2pi (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtsi2ss %ecx, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 2.00 - - - - - - - cvtsi2ss %rcx, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtsi2ssl (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvtsi2ssq (%rax), %xmm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvtss2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - cvtss2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtss2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtss2si (%rax), %rcx +# CHECK-NEXT: 1.33 0.33 - - - 0.33 - - - - - - - cvttps2pi %xmm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - cvttps2pi (%rax), %mm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvttss2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - 1.00 - - - - - - - cvttss2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvttss2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvttss2si (%rax), %rcx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - divps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - divps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - divss %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - divss (%rax), %xmm2 +# CHECK-NEXT: 1.83 0.33 0.33 0.33 - 0.33 0.50 - - - - 0.33 - ldmxcsr (%rax) +# CHECK-NEXT: 2.00 - - - 0.50 - - 0.50 0.50 0.50 - - - maskmovq %mm0, %mm1 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - maxps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - maxps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - maxss %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - maxss (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - minps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - minps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - minss %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - minss (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - movaps %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movaps %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movaps (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movhlps %xmm0, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movlhps %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movhps %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - movhps (%rax), %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movlps %xmm0, (%rax) +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - movlps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movmskps %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntps %xmm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntq %mm0, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - movss %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movss %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movss (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - movups %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movups %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movups (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - mulps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - mulps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - mulss %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - mulss (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - orps %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - orps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pavgb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pavgb (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pavgw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pavgw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - pextrw $1, %mm0, %ecx +# CHECK-NEXT: - - - - - 2.00 - - - - - - - pinsrw $1, %eax, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - pinsrw $1, (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmaxsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmaxsw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmaxub %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmaxub (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pminsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pminsw (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pminub %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pminub (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmovmskb %mm0, %ecx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmulhuw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmulhuw (%rax), %mm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetcht0 (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetcht1 (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetcht2 (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - prefetchnta (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psadbw %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - psadbw (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - pshufw $1, %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - pshufw $1, (%rax), %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - rcpps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - rcpps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - rcpss %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - rcpss (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - rsqrtps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - rsqrtps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - rsqrtss %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - rsqrtss (%rax), %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - sfence +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - shufps $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - shufps $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - sqrtps %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - sqrtps (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - sqrtss %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - sqrtss (%rax), %xmm2 +# CHECK-NEXT: 1.50 - - - 0.50 - 0.50 0.50 0.50 0.50 - - - stmxcsr (%rax) +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - subps %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - subps (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - subss %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - subss (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ucomiss %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - ucomiss (%rax), %xmm1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - unpckhps %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - unpckhps (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - unpcklps %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - unpcklps (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - xorps %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - xorps (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse2.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse2.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse2.s @@ -0,0 +1,965 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +addpd %xmm0, %xmm2 +addpd (%rax), %xmm2 + +addsd %xmm0, %xmm2 +addsd (%rax), %xmm2 + +andnpd %xmm0, %xmm2 +andnpd (%rax), %xmm2 + +andpd %xmm0, %xmm2 +andpd (%rax), %xmm2 + +clflush (%rax) + +cmppd $0, %xmm0, %xmm2 +cmppd $0, (%rax), %xmm2 + +cmpsd $0, %xmm0, %xmm2 +cmpsd $0, (%rax), %xmm2 + +comisd %xmm0, %xmm1 +comisd (%rax), %xmm1 + +cvtdq2pd %xmm0, %xmm2 +cvtdq2pd (%rax), %xmm2 + +cvtdq2ps %xmm0, %xmm2 +cvtdq2ps (%rax), %xmm2 + +cvtpd2dq %xmm0, %xmm2 +cvtpd2dq (%rax), %xmm2 + +cvtpd2pi %xmm0, %mm2 +cvtpd2pi (%rax), %mm2 + +cvtpd2ps %xmm0, %xmm2 +cvtpd2ps (%rax), %xmm2 + +cvtpi2pd %mm0, %xmm2 +cvtpi2pd (%rax), %xmm2 + +cvtps2dq %xmm0, %xmm2 +cvtps2dq (%rax), %xmm2 + +cvtps2pd %xmm0, %xmm2 +cvtps2pd (%rax), %xmm2 + +cvtsd2si %xmm0, %ecx +cvtsd2si %xmm0, %rcx +cvtsd2si (%rax), %ecx +cvtsd2si (%rax), %rcx + +cvtsd2ss %xmm0, %xmm2 +cvtsd2ss (%rax), %xmm2 + +cvtsi2sd %ecx, %xmm2 +cvtsi2sd %rcx, %xmm2 +cvtsi2sdl (%rax), %xmm2 +cvtsi2sdq (%rax), %xmm2 + +cvtss2sd %xmm0, %xmm2 +cvtss2sd (%rax), %xmm2 + +cvttpd2dq %xmm0, %xmm2 +cvttpd2dq (%rax), %xmm2 + +cvttpd2pi %xmm0, %mm2 +cvttpd2pi (%rax), %mm2 + +cvttps2dq %xmm0, %xmm2 +cvttps2dq (%rax), %xmm2 + +cvttsd2si %xmm0, %ecx +cvttsd2si %xmm0, %rcx +cvttsd2si (%rax), %ecx +cvttsd2si (%rax), %rcx + +divpd %xmm0, %xmm2 +divpd (%rax), %xmm2 + +divsd %xmm0, %xmm2 +divsd (%rax), %xmm2 + +lfence + +maskmovdqu %xmm0, %xmm1 + +maxpd %xmm0, %xmm2 +maxpd (%rax), %xmm2 + +maxsd %xmm0, %xmm2 +maxsd (%rax), %xmm2 + +mfence + +minpd %xmm0, %xmm2 +minpd (%rax), %xmm2 + +minsd %xmm0, %xmm2 +minsd (%rax), %xmm2 + +movapd %xmm0, %xmm2 +movapd %xmm0, (%rax) +movapd (%rax), %xmm2 + +movd %eax, %xmm2 +movd (%rax), %xmm2 + +movd %xmm0, %ecx +movd %xmm0, (%rax) + +movdqa %xmm0, %xmm2 +movdqa %xmm0, (%rax) +movdqa (%rax), %xmm2 + +movdqu %xmm0, %xmm2 +movdqu %xmm0, (%rax) +movdqu (%rax), %xmm2 + +movdq2q %xmm0, %mm2 + +movhpd %xmm0, (%rax) +movhpd (%rax), %xmm2 + +movlpd %xmm0, (%rax) +movlpd (%rax), %xmm2 + +movmskpd %xmm0, %rcx + +movntil %eax, (%rax) +movntiq %rax, (%rax) + +movntdq %xmm0, (%rax) +movntpd %xmm0, (%rax) + +movq %xmm0, %xmm2 + +movq %rax, %xmm2 +movq (%rax), %xmm2 + +movq %xmm0, %rcx +movq %xmm0, (%rax) + +movq2dq %mm0, %xmm2 + +movsd %xmm0, %xmm2 +movsd %xmm0, (%rax) +movsd (%rax), %xmm2 + +movupd %xmm0, %xmm2 +movupd %xmm0, (%rax) +movupd (%rax), %xmm2 + +mulpd %xmm0, %xmm2 +mulpd (%rax), %xmm2 + +mulsd %xmm0, %xmm2 +mulsd (%rax), %xmm2 + +orpd %xmm0, %xmm2 +orpd (%rax), %xmm2 + +packssdw %xmm0, %xmm2 +packssdw (%rax), %xmm2 + +packsswb %xmm0, %xmm2 +packsswb (%rax), %xmm2 + +packuswb %xmm0, %xmm2 +packuswb (%rax), %xmm2 + +paddb %xmm0, %xmm2 +paddb (%rax), %xmm2 + +paddd %xmm0, %xmm2 +paddd (%rax), %xmm2 + +paddq %mm0, %mm2 +paddq (%rax), %mm2 + +paddq %xmm0, %xmm2 +paddq (%rax), %xmm2 + +paddsb %xmm0, %xmm2 +paddsb (%rax), %xmm2 + +paddsw %xmm0, %xmm2 +paddsw (%rax), %xmm2 + +paddusb %xmm0, %xmm2 +paddusb (%rax), %xmm2 + +paddusw %xmm0, %xmm2 +paddusw (%rax), %xmm2 + +paddw %xmm0, %xmm2 +paddw (%rax), %xmm2 + +pand %xmm0, %xmm2 +pand (%rax), %xmm2 + +pandn %xmm0, %xmm2 +pandn (%rax), %xmm2 + +pavgb %xmm0, %xmm2 +pavgb (%rax), %xmm2 + +pavgw %xmm0, %xmm2 +pavgw (%rax), %xmm2 + +pcmpeqb %xmm0, %xmm2 +pcmpeqb (%rax), %xmm2 + +pcmpeqd %xmm0, %xmm2 +pcmpeqd (%rax), %xmm2 + +pcmpeqw %xmm0, %xmm2 +pcmpeqw (%rax), %xmm2 + +pcmpgtb %xmm0, %xmm2 +pcmpgtb (%rax), %xmm2 + +pcmpgtd %xmm0, %xmm2 +pcmpgtd (%rax), %xmm2 + +pcmpgtw %xmm0, %xmm2 +pcmpgtw (%rax), %xmm2 + +pextrw $1, %xmm0, %rcx + +pinsrw $1, %rax, %xmm0 +pinsrw $1, (%rax), %xmm0 + +pmaddwd %xmm0, %xmm2 +pmaddwd (%rax), %xmm2 + +pmaxsw %xmm0, %xmm2 +pmaxsw (%rax), %xmm2 + +pmaxub %xmm0, %xmm2 +pmaxub (%rax), %xmm2 + +pminsw %xmm0, %xmm2 +pminsw (%rax), %xmm2 + +pminub %xmm0, %xmm2 +pminub (%rax), %xmm2 + +pmovmskb %xmm0, %rcx + +pmulhuw %xmm0, %xmm2 +pmulhuw (%rax), %xmm2 + +pmulhw %xmm0, %xmm2 +pmulhw (%rax), %xmm2 + +pmullw %xmm0, %xmm2 +pmullw (%rax), %xmm2 + +pmuludq %mm0, %mm2 +pmuludq (%rax), %mm2 + +pmuludq %xmm0, %xmm2 +pmuludq (%rax), %xmm2 + +por %xmm0, %xmm2 +por (%rax), %xmm2 + +psadbw %xmm0, %xmm2 +psadbw (%rax), %xmm2 + +pshufd $1, %xmm0, %xmm2 +pshufd $1, (%rax), %xmm2 + +pshufhw $1, %xmm0, %xmm2 +pshufhw $1, (%rax), %xmm2 + +pshuflw $1, %xmm0, %xmm2 +pshuflw $1, (%rax), %xmm2 + +pslld $1, %xmm2 +pslld %xmm0, %xmm2 +pslld (%rax), %xmm2 + +pslldq $1, %xmm2 + +psllq $1, %xmm2 +psllq %xmm0, %xmm2 +psllq (%rax), %xmm2 + +psllw $1, %xmm2 +psllw %xmm0, %xmm2 +psllw (%rax), %xmm2 + +psrad $1, %xmm2 +psrad %xmm0, %xmm2 +psrad (%rax), %xmm2 + +psraw $1, %xmm2 +psraw %xmm0, %xmm2 +psraw (%rax), %xmm2 + +psrld $1, %xmm2 +psrld %xmm0, %xmm2 +psrld (%rax), %xmm2 + +psrldq $1, %xmm2 + +psrlq $1, %xmm2 +psrlq %xmm0, %xmm2 +psrlq (%rax), %xmm2 + +psrlw $1, %xmm2 +psrlw %xmm0, %xmm2 +psrlw (%rax), %xmm2 + +psubb %xmm0, %xmm2 +psubb (%rax), %xmm2 + +psubd %xmm0, %xmm2 +psubd (%rax), %xmm2 + +psubq %mm0, %mm2 +psubq (%rax), %mm2 + +psubq %xmm0, %xmm2 +psubq (%rax), %xmm2 + +psubsb %xmm0, %xmm2 +psubsb (%rax), %xmm2 + +psubsw %xmm0, %xmm2 +psubsw (%rax), %xmm2 + +psubusb %xmm0, %xmm2 +psubusb (%rax), %xmm2 + +psubusw %xmm0, %xmm2 +psubusw (%rax), %xmm2 + +psubw %xmm0, %xmm2 +psubw (%rax), %xmm2 + +punpckhbw %xmm0, %xmm2 +punpckhbw (%rax), %xmm2 + +punpckhdq %xmm0, %xmm2 +punpckhdq (%rax), %xmm2 + +punpckhqdq %xmm0, %xmm2 +punpckhqdq (%rax), %xmm2 + +punpckhwd %xmm0, %xmm2 +punpckhwd (%rax), %xmm2 + +punpcklbw %xmm0, %xmm2 +punpcklbw (%rax), %xmm2 + +punpckldq %xmm0, %xmm2 +punpckldq (%rax), %xmm2 + +punpcklqdq %xmm0, %xmm2 +punpcklqdq (%rax), %xmm2 + +punpcklwd %xmm0, %xmm2 +punpcklwd (%rax), %xmm2 + +pxor %xmm0, %xmm2 +pxor (%rax), %xmm2 + +shufpd $1, %xmm0, %xmm2 +shufpd $1, (%rax), %xmm2 + +sqrtpd %xmm0, %xmm2 +sqrtpd (%rax), %xmm2 + +sqrtsd %xmm0, %xmm2 +sqrtsd (%rax), %xmm2 + +subpd %xmm0, %xmm2 +subpd (%rax), %xmm2 + +subsd %xmm0, %xmm2 +subsd (%rax), %xmm2 + +ucomisd %xmm0, %xmm1 +ucomisd (%rax), %xmm1 + +unpckhpd %xmm0, %xmm2 +unpckhpd (%rax), %xmm2 + +unpcklpd %xmm0, %xmm2 +unpcklpd (%rax), %xmm2 + +xorpd %xmm0, %xmm2 +xorpd (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 0.50 addpd %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addpd (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 addsd %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 andnpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * andnpd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 andpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * andpd (%rax), %xmm2 +# CHECK-NEXT: 4 2 0.50 * * U clflush (%rax) +# CHECK-NEXT: 1 4 0.50 cmpeqpd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cmpeqpd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 cmpeqsd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cmpeqsd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 comisd %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * comisd (%rax), %xmm1 +# CHECK-NEXT: 2 5 1.00 cvtdq2pd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtdq2pd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 cvtdq2ps %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtdq2ps (%rax), %xmm2 +# CHECK-NEXT: 2 5 1.00 cvtpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * cvtpd2dq (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 cvtpd2pi %xmm0, %mm2 +# CHECK-NEXT: 3 24 1.00 * cvtpd2pi (%rax), %mm2 +# CHECK-NEXT: 2 5 1.00 cvtpd2ps %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * cvtpd2ps (%rax), %xmm2 +# CHECK-NEXT: 2 6 1.00 cvtpi2pd %mm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtpi2pd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 cvtps2dq %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtps2dq (%rax), %xmm2 +# CHECK-NEXT: 2 5 1.00 cvtps2pd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtps2pd (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 cvtsd2si %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 cvtsd2si %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * cvtsd2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * cvtsd2si (%rax), %rcx +# CHECK-NEXT: 2 5 1.00 cvtsd2ss %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * cvtsd2ss (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 cvtsi2sd %ecx, %xmm2 +# CHECK-NEXT: 2 7 1.00 cvtsi2sd %rcx, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtsi2sdl (%rax), %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtsi2sdq (%rax), %xmm2 +# CHECK-NEXT: 2 5 1.00 cvtss2sd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvtss2sd (%rax), %xmm2 +# CHECK-NEXT: 2 5 1.00 cvttpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 3 12 1.00 * cvttpd2dq (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 cvttpd2pi %xmm0, %mm2 +# CHECK-NEXT: 3 24 1.00 * cvttpd2pi (%rax), %mm2 +# CHECK-NEXT: 1 4 0.50 cvttps2dq %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * cvttps2dq (%rax), %xmm2 +# CHECK-NEXT: 2 7 1.00 cvttsd2si %xmm0, %ecx +# CHECK-NEXT: 2 7 1.00 cvttsd2si %xmm0, %rcx +# CHECK-NEXT: 3 26 1.00 * cvttsd2si (%rax), %ecx +# CHECK-NEXT: 3 12 1.00 * cvttsd2si (%rax), %rcx +# CHECK-NEXT: 1 14 1.00 divpd %xmm0, %xmm2 +# CHECK-NEXT: 2 20 1.00 * divpd (%rax), %xmm2 +# CHECK-NEXT: 1 14 1.00 divsd %xmm0, %xmm2 +# CHECK-NEXT: 2 20 1.00 * divsd (%rax), %xmm2 +# CHECK-NEXT: 1 2 0.50 * * U lfence +# CHECK-NEXT: 2 1 1.00 * * U maskmovdqu %xmm0, %xmm1 +# CHECK-NEXT: 1 4 0.50 maxpd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * maxpd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 maxsd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * maxsd (%rax), %xmm2 +# CHECK-NEXT: 2 3 0.50 * * U mfence +# CHECK-NEXT: 1 4 0.50 minpd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * minpd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 minsd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * minsd (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 movapd %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movapd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movapd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 movd %eax, %xmm2 +# CHECK-NEXT: 1 7 0.33 * movd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 movd %xmm0, %ecx +# CHECK-NEXT: 2 12 0.50 * movd %xmm0, (%rax) +# CHECK-NEXT: 0 1 0.00 movdqa %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movdqa %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movdqa (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 movdqu %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movdqu %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movdqu (%rax), %xmm2 +# CHECK-NEXT: 2 3 0.67 movdq2q %xmm0, %mm2 +# CHECK-NEXT: 2 12 0.50 * movhpd %xmm0, (%rax) +# CHECK-NEXT: 2 8 1.00 * movhpd (%rax), %xmm2 +# CHECK-NEXT: 2 12 0.50 * movlpd %xmm0, (%rax) +# CHECK-NEXT: 2 8 0.50 * movlpd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 movmskpd %xmm0, %ecx +# CHECK-NEXT: 2 518 0.50 * movntil %eax, (%rax) +# CHECK-NEXT: 2 512 0.50 * movntiq %rax, (%rax) +# CHECK-NEXT: 2 512 0.50 * movntdq %xmm0, (%rax) +# CHECK-NEXT: 2 518 0.50 * movntpd %xmm0, (%rax) +# CHECK-NEXT: 1 1 0.33 movq %xmm0, %xmm2 +# CHECK-NEXT: 1 3 1.00 movq %rax, %xmm2 +# CHECK-NEXT: 1 7 0.33 * movq (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 movq %xmm0, %rcx +# CHECK-NEXT: 2 12 0.50 * movq %xmm0, (%rax) +# CHECK-NEXT: 2 3 1.00 movq2dq %mm0, %xmm2 +# CHECK-NEXT: 1 1 0.33 movsd %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movsd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movsd (%rax), %xmm2 +# CHECK-NEXT: 0 1 0.00 movupd %xmm0, %xmm2 +# CHECK-NEXT: 2 12 0.50 * movupd %xmm0, (%rax) +# CHECK-NEXT: 1 7 0.33 * movupd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 mulpd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * mulpd (%rax), %xmm2 +# CHECK-NEXT: 1 4 0.50 mulsd %xmm0, %xmm2 +# CHECK-NEXT: 2 11 0.50 * mulsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 orpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * orpd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 packssdw %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * packssdw (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 packsswb %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * packsswb (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 packuswb %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * packuswb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 paddb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * paddb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 paddd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * paddd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 paddq %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * paddq (%rax), %mm2 +# CHECK-NEXT: 1 1 0.33 paddq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * paddq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 paddsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * paddsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 paddsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * paddsw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 paddusb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * paddusb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 paddusw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * paddusw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 paddw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * paddw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 pand %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * pand (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 pandn %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * pandn (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pavgb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pavgb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pavgw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pavgw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpeqb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpeqb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpeqd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpeqd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpeqw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpeqw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpgtb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpgtd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpgtw (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 pextrw $1, %xmm0, %ecx +# CHECK-NEXT: 2 4 1.00 pinsrw $1, %eax, %xmm0 +# CHECK-NEXT: 2 8 0.50 * pinsrw $1, (%rax), %xmm0 +# CHECK-NEXT: 1 5 0.50 pmaddwd %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmaddwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmaxsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxsw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmaxub %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxub (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminsw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminub %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminub (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 pmovmskb %xmm0, %ecx +# CHECK-NEXT: 1 5 0.50 pmulhuw %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmulhuw (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 pmulhw %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmulhw (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 pmullw %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmullw (%rax), %xmm2 +# CHECK-NEXT: 1 5 1.00 pmuludq %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmuludq (%rax), %mm2 +# CHECK-NEXT: 1 5 0.50 pmuludq %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmuludq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 por %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * por (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 psadbw %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * psadbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pshufd $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pshufd $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pshufhw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pshufhw $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pshuflw $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pshuflw $1, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pslld $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 pslld %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pslld (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pslldq $1, %xmm2 +# CHECK-NEXT: 1 1 0.50 psllq $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psllq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psllq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psllw $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psllw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psllw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psrad $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psrad %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psrad (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psraw $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psraw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psraw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psrld $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psrld %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psrld (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psrldq $1, %xmm2 +# CHECK-NEXT: 1 1 0.50 psrlq $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psrlq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psrlq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psrlw $1, %xmm2 +# CHECK-NEXT: 2 2 0.67 psrlw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psrlw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 psubb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * psubb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 psubd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * psubd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psubq %mm0, %mm2 +# CHECK-NEXT: 2 9 0.50 * psubq (%rax), %mm2 +# CHECK-NEXT: 1 1 0.33 psubq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * psubq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psubsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psubsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psubsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psubsw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psubusb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psubusb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 psubusw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psubusw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 psubw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * psubw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpckhbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpckhbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpckhdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpckhdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpckhqdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpckhqdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpckhwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpckhwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpcklbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpcklbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpckldq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpckldq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpcklqdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpcklqdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 punpcklwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * punpcklwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 pxor %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * pxor (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 shufpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * shufpd $1, (%rax), %xmm2 +# CHECK-NEXT: 1 18 1.00 sqrtpd %xmm0, %xmm2 +# CHECK-NEXT: 2 24 1.00 * sqrtpd (%rax), %xmm2 +# CHECK-NEXT: 1 18 1.00 sqrtsd %xmm0, %xmm2 +# CHECK-NEXT: 2 24 1.00 * sqrtsd (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 subpd %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * subpd (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 subsd %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * subsd (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 ucomisd %xmm0, %xmm1 +# CHECK-NEXT: 2 8 1.00 * ucomisd (%rax), %xmm1 +# CHECK-NEXT: 1 1 1.00 unpckhpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * unpckhpd (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 unpcklpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * unpcklpd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 xorpd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * xorpd (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 107.70 99.20 39.00 39.00 9.00 71.70 1.20 7.50 7.50 8.00 0.20 39.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addpd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addpd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addsd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addsd (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - andnpd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - andnpd (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - andpd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - andpd (%rax), %xmm2 +# CHECK-NEXT: 0.70 0.20 - - 0.50 0.20 0.70 0.50 0.50 0.50 0.20 - - clflush (%rax) +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cmpeqpd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cmpeqpd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cmpeqsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cmpeqsd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - comisd %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - comisd (%rax), %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtdq2pd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtdq2pd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cvtdq2ps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtdq2ps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvtpd2dq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtpd2pi %xmm0, %mm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvtpd2pi (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtpd2ps %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvtpd2ps (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtpi2pd %mm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtpi2pd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cvtps2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtps2dq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtps2pd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtps2pd (%rax), %xmm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvtsd2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvtsd2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtsd2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtsd2si (%rax), %rcx +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtsd2ss %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvtsd2ss (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtsi2sd %ecx, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtsi2sd %rcx, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtsi2sdl (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtsi2sdq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvtss2sd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvtss2sd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvttpd2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvttpd2dq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - 1.00 - - - - - - - cvttpd2pi %xmm0, %mm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - 1.00 - - - - - 0.33 - cvttpd2pi (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - cvttps2dq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvttps2dq (%rax), %xmm2 +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvttsd2si %xmm0, %ecx +# CHECK-NEXT: 1.50 0.50 - - - - - - - - - - - cvttsd2si %xmm0, %rcx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvttsd2si (%rax), %ecx +# CHECK-NEXT: 1.50 0.50 0.33 0.33 - - - - - - - 0.33 - cvttsd2si (%rax), %rcx +# CHECK-NEXT: 1.00 - - - - - - - - - - - - divpd %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - divpd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - divsd %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - divsd (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - lfence +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - maskmovdqu %xmm0, %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - maxpd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - maxpd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - maxsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - maxsd (%rax), %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - mfence +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - minpd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - minpd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - minsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - minsd (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - movapd %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movapd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movapd (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movd %eax, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movd %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movd %xmm0, (%rax) +# CHECK-NEXT: - - - - - - - - - - - - - movdqa %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movdqa %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movdqa (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - movdqu %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movdqu %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movdqu (%rax), %xmm2 +# CHECK-NEXT: 0.83 0.33 - - - 0.83 - - - - - - - movdq2q %xmm0, %mm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movhpd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - movhpd (%rax), %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movlpd %xmm0, (%rax) +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - movlpd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movmskpd %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntil %eax, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntiq %rax, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntdq %xmm0, (%rax) +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movntpd %xmm0, (%rax) +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - movq %xmm0, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movq %rax, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movq (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - movq %xmm0, %rcx +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movq %xmm0, (%rax) +# CHECK-NEXT: 1.33 0.33 - - - 0.33 - - - - - - - movq2dq %mm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - movsd %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movsd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movsd (%rax), %xmm2 +# CHECK-NEXT: - - - - - - - - - - - - - movupd %xmm0, %xmm2 +# CHECK-NEXT: - - - - 0.50 - - 0.50 0.50 0.50 - - - movupd %xmm0, (%rax) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movupd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - mulpd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - mulpd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - mulsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - mulsd (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - orpd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - orpd (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - packssdw %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - packssdw (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - packsswb %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - packsswb (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - packuswb %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - packuswb (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - paddb %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - paddb (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - paddd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - paddd (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - paddq %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - paddq (%rax), %mm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - paddq %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - paddq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - paddsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - paddsb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - paddsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - paddsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - paddusb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - paddusb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - paddusw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - paddusw (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - paddw %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - paddw (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - pand %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - pand (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - pandn %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - pandn (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pavgb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pavgb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pavgw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pavgw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpeqb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpeqb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpeqd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpeqd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpeqw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpeqw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpgtb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpgtb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpgtd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpgtd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpgtw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpgtw (%rax), %xmm2 +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - pextrw $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - pinsrw $1, %eax, %xmm0 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pinsrw $1, (%rax), %xmm0 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaddwd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaddwd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxub %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxub (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminub %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminub (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmovmskb %xmm0, %ecx +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmulhuw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmulhuw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmulhw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmulhw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmullw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmullw (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmuludq %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmuludq (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmuludq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmuludq (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - por %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - por (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psadbw %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - psadbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pshufd $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pshufd $1, (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pshufhw $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pshufhw $1, (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pshuflw $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pshuflw $1, (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pslld $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - pslld %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pslld (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pslldq $1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psllq $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psllq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psllq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psllw $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psllw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psllw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psrad $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psrad %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psrad (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psraw $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psraw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psraw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psrld $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psrld %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psrld (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - psrldq $1, %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psrlq $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psrlq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psrlq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psrlw $1, %xmm2 +# CHECK-NEXT: 0.50 1.00 - - - 0.50 - - - - - - - psrlw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psrlw (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - psubb %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - psubb (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - psubd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - psubd (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - psubq %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - psubq (%rax), %mm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - psubq %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - psubq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psubsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psubsb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psubsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psubsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psubusb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psubusb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psubusw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psubusw (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - psubw %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - psubw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpckhbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpckhbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpckhdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpckhdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpckhqdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpckhqdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpckhwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpckhwd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpcklbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpcklbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpckldq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpckldq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpcklqdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpcklqdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - punpcklwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - punpcklwd (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - pxor %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - pxor (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - shufpd $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - shufpd $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - sqrtpd %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - sqrtpd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - sqrtsd %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - sqrtsd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - subpd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - subpd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - subsd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - subsd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ucomisd %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - ucomisd (%rax), %xmm1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - unpckhpd %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - unpckhpd (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - unpcklpd %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - unpcklpd (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - xorpd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - xorpd (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse3.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse3.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse3.s @@ -0,0 +1,109 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +addsubpd %xmm0, %xmm2 +addsubpd (%rax), %xmm2 + +addsubps %xmm0, %xmm2 +addsubps (%rax), %xmm2 + +haddpd %xmm0, %xmm2 +haddpd (%rax), %xmm2 + +haddps %xmm0, %xmm2 +haddps (%rax), %xmm2 + +hsubpd %xmm0, %xmm2 +hsubpd (%rax), %xmm2 + +hsubps %xmm0, %xmm2 +hsubps (%rax), %xmm2 + +lddqu (%rax), %xmm2 + +monitor + +movddup %xmm0, %xmm2 +movddup (%rax), %xmm2 + +movshdup %xmm0, %xmm2 +movshdup (%rax), %xmm2 + +movsldup %xmm0, %xmm2 +movsldup (%rax), %xmm2 + +mwait + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 0.50 addsubpd %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addsubpd (%rax), %xmm2 +# CHECK-NEXT: 1 3 0.50 addsubps %xmm0, %xmm2 +# CHECK-NEXT: 2 10 0.50 * addsubps (%rax), %xmm2 +# CHECK-NEXT: 3 6 2.00 haddpd %xmm0, %xmm2 +# CHECK-NEXT: 4 12 2.00 * haddpd (%rax), %xmm2 +# CHECK-NEXT: 3 6 2.00 haddps %xmm0, %xmm2 +# CHECK-NEXT: 4 12 2.00 * haddps (%rax), %xmm2 +# CHECK-NEXT: 3 6 2.00 hsubpd %xmm0, %xmm2 +# CHECK-NEXT: 4 12 2.00 * hsubpd (%rax), %xmm2 +# CHECK-NEXT: 3 6 2.00 hsubps %xmm0, %xmm2 +# CHECK-NEXT: 4 12 2.00 * hsubps (%rax), %xmm2 +# CHECK-NEXT: 1 7 0.33 * lddqu (%rax), %xmm2 +# CHECK-NEXT: 1 100 0.25 U monitor +# CHECK-NEXT: 1 1 1.00 movddup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * movddup (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 movshdup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * movshdup (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 movsldup %xmm0, %xmm2 +# CHECK-NEXT: 1 7 0.33 * movsldup (%rax), %xmm2 +# CHECK-NEXT: 10 20 2.50 * * U mwait + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 2.00 9.00 3.33 3.33 - 27.00 4.00 - - - - 3.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addsubpd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addsubpd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - addsubps %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - addsubps (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - haddpd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - haddpd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - haddps %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - haddps (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - hsubpd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - hsubpd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 2.50 - - - - - - - hsubps %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 2.50 - - - - - 0.33 - hsubps (%rax), %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - lddqu (%rax), %xmm2 +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - monitor +# CHECK-NEXT: - - - - - 1.00 - - - - - - - movddup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movddup (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - movshdup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movshdup (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - movsldup %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movsldup (%rax), %xmm2 +# CHECK-NEXT: 1.75 1.75 - - - 2.75 3.75 - - - - - - mwait diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse41.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse41.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse41.s @@ -0,0 +1,371 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +blendpd $11, %xmm0, %xmm2 +blendpd $11, (%rax), %xmm2 + +blendps $11, %xmm0, %xmm2 +blendps $11, (%rax), %xmm2 + +blendvpd %xmm0, %xmm2 +blendvpd (%rax), %xmm2 + +blendvps %xmm0, %xmm2 +blendvps (%rax), %xmm2 + +dppd $22, %xmm0, %xmm2 +dppd $22, (%rax), %xmm2 + +dpps $22, %xmm0, %xmm2 +dpps $22, (%rax), %xmm2 + +extractps $1, %xmm0, %rcx +extractps $1, %xmm0, (%rax) + +insertps $1, %xmm0, %xmm2 +insertps $1, (%rax), %xmm2 + +movntdqa (%rax), %xmm2 + +mpsadbw $1, %xmm0, %xmm2 +mpsadbw $1, (%rax), %xmm2 + +packusdw %xmm0, %xmm2 +packusdw (%rax), %xmm2 + +pblendvb %xmm0, %xmm2 +pblendvb (%rax), %xmm2 + +pblendw $11, %xmm0, %xmm2 +pblendw $11, (%rax), %xmm2 + +pcmpeqq %xmm0, %xmm2 +pcmpeqq (%rax), %xmm2 + +pextrb $1, %xmm0, %ecx +pextrb $1, %xmm0, (%rax) + +pextrd $1, %xmm0, %ecx +pextrd $1, %xmm0, (%rax) + +pextrq $1, %xmm0, %rcx +pextrq $1, %xmm0, (%rax) + +pextrw $1, %xmm0, (%rax) + +phminposuw %xmm0, %xmm2 +phminposuw (%rax), %xmm2 + +pinsrb $1, %eax, %xmm1 +pinsrb $1, (%rax), %xmm1 + +pinsrd $1, %eax, %xmm1 +pinsrd $1, (%rax), %xmm1 + +pinsrq $1, %rax, %xmm1 +pinsrq $1, (%rax), %xmm1 + +pmaxsb %xmm0, %xmm2 +pmaxsb (%rax), %xmm2 + +pmaxsd %xmm0, %xmm2 +pmaxsd (%rax), %xmm2 + +pmaxud %xmm0, %xmm2 +pmaxud (%rax), %xmm2 + +pmaxuw %xmm0, %xmm2 +pmaxuw (%rax), %xmm2 + +pminsb %xmm0, %xmm2 +pminsb (%rax), %xmm2 + +pminsd %xmm0, %xmm2 +pminsd (%rax), %xmm2 + +pminud %xmm0, %xmm2 +pminud (%rax), %xmm2 + +pminuw %xmm0, %xmm2 +pminuw (%rax), %xmm2 + +pmovsxbd %xmm0, %xmm2 +pmovsxbd (%rax), %xmm2 + +pmovsxbq %xmm0, %xmm2 +pmovsxbq (%rax), %xmm2 + +pmovsxbw %xmm0, %xmm2 +pmovsxbw (%rax), %xmm2 + +pmovsxdq %xmm0, %xmm2 +pmovsxdq (%rax), %xmm2 + +pmovsxwd %xmm0, %xmm2 +pmovsxwd (%rax), %xmm2 + +pmovsxwq %xmm0, %xmm2 +pmovsxwq (%rax), %xmm2 + +pmovzxbd %xmm0, %xmm2 +pmovzxbd (%rax), %xmm2 + +pmovzxbq %xmm0, %xmm2 +pmovzxbq (%rax), %xmm2 + +pmovzxbw %xmm0, %xmm2 +pmovzxbw (%rax), %xmm2 + +pmovzxdq %xmm0, %xmm2 +pmovzxdq (%rax), %xmm2 + +pmovzxwd %xmm0, %xmm2 +pmovzxwd (%rax), %xmm2 + +pmovzxwq %xmm0, %xmm2 +pmovzxwq (%rax), %xmm2 + +pmuldq %xmm0, %xmm2 +pmuldq (%rax), %xmm2 + +pmulld %xmm0, %xmm2 +pmulld (%rax), %xmm2 + +ptest %xmm0, %xmm1 +ptest (%rax), %xmm1 + +roundpd $1, %xmm0, %xmm2 +roundpd $1, (%rax), %xmm2 + +roundps $1, %xmm0, %xmm2 +roundps $1, (%rax), %xmm2 + +roundsd $1, %xmm0, %xmm2 +roundsd $1, (%rax), %xmm2 + +roundss $1, %xmm0, %xmm2 +roundss $1, (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.33 blendpd $11, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * blendpd $11, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 blendps $11, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * blendps $11, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 blendvpd %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * blendvpd %xmm0, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 blendvps %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * blendvps %xmm0, (%rax), %xmm2 +# CHECK-NEXT: 3 9 1.00 dppd $22, %xmm0, %xmm2 +# CHECK-NEXT: 4 16 1.00 * dppd $22, (%rax), %xmm2 +# CHECK-NEXT: 6 14 1.67 dpps $22, %xmm0, %xmm2 +# CHECK-NEXT: 7 21 1.67 * dpps $22, (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 extractps $1, %xmm0, %ecx +# CHECK-NEXT: 3 12 1.00 * extractps $1, %xmm0, (%rax) +# CHECK-NEXT: 1 1 1.00 insertps $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * insertps $1, (%rax), %xmm2 +# CHECK-NEXT: 1 7 0.33 * movntdqa (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 mpsadbw $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 11 1.00 * mpsadbw $1, (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 packusdw %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * packusdw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.33 pblendvb %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.33 * pblendvb %xmm0, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pblendw $11, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pblendw $11, (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpeqq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pcmpeqq (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 pextrb $1, %xmm0, %ecx +# CHECK-NEXT: 3 19 0.50 * pextrb $1, %xmm0, (%rax) +# CHECK-NEXT: 2 4 1.00 pextrd $1, %xmm0, %ecx +# CHECK-NEXT: 3 12 0.50 * pextrd $1, %xmm0, (%rax) +# CHECK-NEXT: 2 4 1.00 pextrq $1, %xmm0, %rcx +# CHECK-NEXT: 3 12 0.50 * pextrq $1, %xmm0, (%rax) +# CHECK-NEXT: 3 19 0.50 * pextrw $1, %xmm0, (%rax) +# CHECK-NEXT: 1 4 1.00 phminposuw %xmm0, %xmm2 +# CHECK-NEXT: 2 11 1.00 * phminposuw (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 pinsrb $1, %eax, %xmm1 +# CHECK-NEXT: 2 8 0.50 * pinsrb $1, (%rax), %xmm1 +# CHECK-NEXT: 2 4 1.00 pinsrd $1, %eax, %xmm1 +# CHECK-NEXT: 2 8 0.50 * pinsrd $1, (%rax), %xmm1 +# CHECK-NEXT: 2 4 1.00 pinsrq $1, %rax, %xmm1 +# CHECK-NEXT: 2 8 0.50 * pinsrq $1, (%rax), %xmm1 +# CHECK-NEXT: 1 1 0.50 pmaxsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmaxsd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmaxud %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxud (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmaxuw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmaxuw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminsd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminud %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminud (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pminuw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pminuw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxbd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxbd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxbq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxbq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovsxwq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovsxwq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxbd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxbd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxbq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxbq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxbw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxbw (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxdq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxdq (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxwd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxwd (%rax), %xmm2 +# CHECK-NEXT: 1 1 0.50 pmovzxwq %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pmovzxwq (%rax), %xmm2 +# CHECK-NEXT: 1 5 0.50 pmuldq %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmuldq (%rax), %xmm2 +# CHECK-NEXT: 2 10 1.00 pmulld %xmm0, %xmm2 +# CHECK-NEXT: 3 18 1.00 * pmulld (%rax), %xmm2 +# CHECK-NEXT: 2 4 1.00 ptest %xmm0, %xmm1 +# CHECK-NEXT: 3 9 1.00 * ptest (%rax), %xmm1 +# CHECK-NEXT: 2 8 1.00 roundpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * roundpd $1, (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 roundps $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * roundps $1, (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 roundsd $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * roundsd $1, (%rax), %xmm2 +# CHECK-NEXT: 2 8 1.00 roundss $1, %xmm0, %xmm2 +# CHECK-NEXT: 3 15 1.00 * roundss $1, (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 36.33 50.83 14.67 14.67 2.50 41.83 1.00 2.50 2.50 2.50 - 14.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - blendpd $11, %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - blendpd $11, (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - blendps $11, %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - blendps $11, (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - blendvpd %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - blendvpd %xmm0, (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - blendvps %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - blendvps %xmm0, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.50 - - - 0.50 - - - - - - - dppd $22, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.50 0.33 0.33 - 0.50 - - - - - 0.33 - dppd $22, (%rax), %xmm2 +# CHECK-NEXT: 1.50 2.00 - - - 2.00 0.50 - - - - - - dpps $22, %xmm0, %xmm2 +# CHECK-NEXT: 1.50 2.00 0.33 0.33 - 2.00 0.50 - - - - 0.33 - dpps $22, (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - extractps $1, %xmm0, %ecx +# CHECK-NEXT: - - - - 0.50 1.00 - 0.50 0.50 0.50 - - - extractps $1, %xmm0, (%rax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - insertps $1, %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - insertps $1, (%rax), %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movntdqa (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - mpsadbw $1, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 1.50 - - - - - 0.33 - mpsadbw $1, (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - packusdw %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - packusdw (%rax), %xmm2 +# CHECK-NEXT: 0.33 0.33 - - - 0.33 - - - - - - - pblendvb %xmm0, %xmm0, %xmm2 +# CHECK-NEXT: 0.33 0.33 0.33 0.33 - 0.33 - - - - - 0.33 - pblendvb %xmm0, (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pblendw $11, %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pblendw $11, (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pcmpeqq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pcmpeqq (%rax), %xmm2 +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - pextrb $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - pextrb $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - pextrd $1, %xmm0, %ecx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - pextrd $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 0.50 - - - 0.50 - - - - - - - pextrq $1, %xmm0, %rcx +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - pextrq $1, %xmm0, (%rax) +# CHECK-NEXT: - 0.50 - - 0.50 0.50 - 0.50 0.50 0.50 - - - pextrw $1, %xmm0, (%rax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - phminposuw %xmm0, %xmm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - phminposuw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - pinsrb $1, %eax, %xmm1 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pinsrb $1, (%rax), %xmm1 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - pinsrd $1, %eax, %xmm1 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pinsrd $1, (%rax), %xmm1 +# CHECK-NEXT: - 0.50 - - - 1.50 - - - - - - - pinsrq $1, %rax, %xmm1 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pinsrq $1, (%rax), %xmm1 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxsb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxsd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxud %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxud (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaxuw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaxuw (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminsb (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminsd (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminud %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminud (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pminuw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pminuw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxbd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxbd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxbq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxbq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxwd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovsxwq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovsxwq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxbd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxbd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxbq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxbq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxbw %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxbw (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxdq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxdq (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxwd %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxwd (%rax), %xmm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pmovzxwq %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pmovzxwq (%rax), %xmm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmuldq %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmuldq (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - pmulld %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - pmulld (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - ptest %xmm0, %xmm1 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - ptest (%rax), %xmm1 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - roundpd $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - roundpd $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - roundps $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - roundps $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - roundsd $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - roundsd $1, (%rax), %xmm2 +# CHECK-NEXT: 1.00 1.00 - - - - - - - - - - - roundss $1, %xmm0, %xmm2 +# CHECK-NEXT: 1.00 1.00 0.33 0.33 - - - - - - - 0.33 - roundss $1, (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse42.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse42.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-sse42.s @@ -0,0 +1,104 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +crc32b %al, %ecx +crc32b (%rax), %ecx + +crc32l %eax, %ecx +crc32l (%rax), %ecx + +crc32w %ax, %ecx +crc32w (%rax), %ecx + +crc32b %al, %rcx +crc32b (%rax), %rcx + +crc32q %rax, %rcx +crc32q (%rax), %rcx + +pcmpestri $1, %xmm0, %xmm2 +pcmpestri $1, (%rax), %xmm2 + +pcmpestrm $1, %xmm0, %xmm2 +pcmpestrm $1, (%rax), %xmm2 + +pcmpistri $1, %xmm0, %xmm2 +pcmpistri $1, (%rax), %xmm2 + +pcmpistrm $1, %xmm0, %xmm2 +pcmpistrm $1, (%rax), %xmm2 + +pcmpgtq %xmm0, %xmm2 +pcmpgtq (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 crc32b %al, %ecx +# CHECK-NEXT: 2 8 1.00 * crc32b (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 crc32l %eax, %ecx +# CHECK-NEXT: 2 8 1.00 * crc32l (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 crc32w %ax, %ecx +# CHECK-NEXT: 2 8 1.00 * crc32w (%rax), %ecx +# CHECK-NEXT: 1 3 1.00 crc32b %al, %rcx +# CHECK-NEXT: 2 8 1.00 * crc32b (%rax), %rcx +# CHECK-NEXT: 1 3 1.00 crc32q %rax, %rcx +# CHECK-NEXT: 2 8 1.00 * crc32q (%rax), %rcx +# CHECK-NEXT: 8 16 3.00 pcmpestri $1, %xmm0, %xmm2 +# CHECK-NEXT: 8 31 3.00 * pcmpestri $1, (%rax), %xmm2 +# CHECK-NEXT: 9 16 3.00 pcmpestrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 9 17 3.00 * pcmpestrm $1, (%rax), %xmm2 +# CHECK-NEXT: 3 11 3.00 pcmpistri $1, %xmm0, %xmm2 +# CHECK-NEXT: 4 31 3.00 * pcmpistri $1, (%rax), %xmm2 +# CHECK-NEXT: 3 11 3.00 pcmpistrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 4 16 3.00 * pcmpistrm $1, (%rax), %xmm2 +# CHECK-NEXT: 1 3 1.00 pcmpgtq %xmm0, %xmm2 +# CHECK-NEXT: 2 10 1.00 * pcmpgtq (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 28.67 16.67 3.33 3.33 - 8.67 2.00 - - - - 3.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - 1.00 - - - - - - - - - - - crc32b %al, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - crc32b (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - crc32l %eax, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - crc32l (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - crc32w %ax, %ecx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - crc32w (%rax), %ecx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - crc32b %al, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - crc32b (%rax), %rcx +# CHECK-NEXT: - 1.00 - - - - - - - - - - - crc32q %rax, %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - crc32q (%rax), %rcx +# CHECK-NEXT: 4.17 1.67 - - - 1.67 0.50 - - - - - - pcmpestri $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.83 1.33 0.33 0.33 - 1.33 0.50 - - - - 0.33 - pcmpestri $1, (%rax), %xmm2 +# CHECK-NEXT: 4.50 2.00 - - - 2.00 0.50 - - - - - - pcmpestrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 4.17 1.67 0.33 0.33 - 1.67 0.50 - - - - 0.33 - pcmpestrm $1, (%rax), %xmm2 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - pcmpistri $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpistri $1, (%rax), %xmm2 +# CHECK-NEXT: 3.00 - - - - - - - - - - - - pcmpistrm $1, %xmm0, %xmm2 +# CHECK-NEXT: 3.00 - 0.33 0.33 - - - - - - - 0.33 - pcmpistrm $1, (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - pcmpgtq %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - pcmpgtq (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-ssse3.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-ssse3.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-ssse3.s @@ -0,0 +1,258 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +pabsb %mm0, %mm2 +pabsb (%rax), %mm2 + +pabsb %xmm0, %xmm2 +pabsb (%rax), %xmm2 + +pabsd %mm0, %mm2 +pabsd (%rax), %mm2 + +pabsd %xmm0, %xmm2 +pabsd (%rax), %xmm2 + +pabsw %mm0, %mm2 +pabsw (%rax), %mm2 + +pabsw %xmm0, %xmm2 +pabsw (%rax), %xmm2 + +palignr $1, %mm0, %mm2 +palignr $1, (%rax), %mm2 + +palignr $1, %xmm0, %xmm2 +palignr $1, (%rax), %xmm2 + +phaddd %mm0, %mm2 +phaddd (%rax), %mm2 + +phaddd %xmm0, %xmm2 +phaddd (%rax), %xmm2 + +phaddsw %mm0, %mm2 +phaddsw (%rax), %mm2 + +phaddsw %xmm0, %xmm2 +phaddsw (%rax), %xmm2 + +phaddw %mm0, %mm2 +phaddw (%rax), %mm2 + +phaddw %xmm0, %xmm2 +phaddw (%rax), %xmm2 + +phsubd %mm0, %mm2 +phsubd (%rax), %mm2 + +phsubd %xmm0, %xmm2 +phsubd (%rax), %xmm2 + +phsubsw %mm0, %mm2 +phsubsw (%rax), %mm2 + +phsubsw %xmm0, %xmm2 +phsubsw (%rax), %xmm2 + +phsubw %mm0, %mm2 +phsubw (%rax), %mm2 + +phsubw %xmm0, %xmm2 +phsubw (%rax), %xmm2 + +pmaddubsw %mm0, %mm2 +pmaddubsw (%rax), %mm2 + +pmaddubsw %xmm0, %xmm2 +pmaddubsw (%rax), %xmm2 + +pmulhrsw %mm0, %mm2 +pmulhrsw (%rax), %mm2 + +pmulhrsw %xmm0, %xmm2 +pmulhrsw (%rax), %xmm2 + +pshufb %mm0, %mm2 +pshufb (%rax), %mm2 + +pshufb %xmm0, %xmm2 +pshufb (%rax), %xmm2 + +psignb %mm0, %mm2 +psignb (%rax), %mm2 + +psignb %xmm0, %xmm2 +psignb (%rax), %xmm2 + +psignd %mm0, %mm2 +psignd (%rax), %mm2 + +psignd %xmm0, %xmm2 +psignd (%rax), %xmm2 + +psignw %mm0, %mm2 +psignw (%rax), %mm2 + +psignw %xmm0, %xmm2 +psignw (%rax), %xmm2 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 1.00 pabsb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pabsb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pabsb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pabsb (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 pabsd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pabsd (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pabsd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pabsd (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 pabsw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * pabsw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pabsw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pabsw (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 palignr $1, %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * palignr $1, (%rax), %mm2 +# CHECK-NEXT: 1 1 1.00 palignr $1, %xmm0, %xmm2 +# CHECK-NEXT: 2 8 1.00 * palignr $1, (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phaddd %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phaddd (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phaddd %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phaddd (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phaddsw %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phaddsw (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phaddsw %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phaddsw (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phaddw %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phaddw (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phaddw %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phaddw (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phsubd %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phsubd (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phsubd %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phsubd (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phsubsw %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phsubsw (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phsubsw %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phsubsw (%rax), %xmm2 +# CHECK-NEXT: 3 3 2.00 phsubw %mm0, %mm2 +# CHECK-NEXT: 4 11 2.00 * phsubw (%rax), %mm2 +# CHECK-NEXT: 3 2 1.00 phsubw %xmm0, %xmm2 +# CHECK-NEXT: 4 9 1.00 * phsubw (%rax), %xmm2 +# CHECK-NEXT: 1 5 1.00 pmaddubsw %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmaddubsw (%rax), %mm2 +# CHECK-NEXT: 1 5 0.50 pmaddubsw %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmaddubsw (%rax), %xmm2 +# CHECK-NEXT: 1 5 1.00 pmulhrsw %mm0, %mm2 +# CHECK-NEXT: 2 13 1.00 * pmulhrsw (%rax), %mm2 +# CHECK-NEXT: 1 5 0.50 pmulhrsw %xmm0, %xmm2 +# CHECK-NEXT: 2 13 0.50 * pmulhrsw (%rax), %xmm2 +# CHECK-NEXT: 2 3 1.00 pshufb %mm0, %mm2 +# CHECK-NEXT: 3 11 1.00 * pshufb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 pshufb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * pshufb (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 psignb %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psignb (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psignb %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psignb (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 psignd %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psignd (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psignd %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psignd (%rax), %xmm2 +# CHECK-NEXT: 1 1 1.00 psignw %mm0, %mm2 +# CHECK-NEXT: 2 9 1.00 * psignw (%rax), %mm2 +# CHECK-NEXT: 1 1 0.50 psignw %xmm0, %xmm2 +# CHECK-NEXT: 2 8 0.50 * psignw (%rax), %xmm2 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 38.67 25.67 10.67 10.67 - 49.67 - - - - - 10.67 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pabsb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pabsb (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pabsb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pabsb (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pabsd %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pabsd (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pabsd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pabsd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pabsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pabsw (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pabsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pabsw (%rax), %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - palignr $1, %mm0, %mm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - palignr $1, (%rax), %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - palignr $1, %xmm0, %xmm2 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - palignr $1, (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - phaddd %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - phaddd (%rax), %mm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - phaddd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - phaddd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - 2.00 - - - - - - - phaddsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 2.00 - - - - - 0.33 - phaddsw (%rax), %mm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - phaddsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - phaddsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - phaddw %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - phaddw (%rax), %mm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - phaddw %xmm0, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - phaddw (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - phsubd %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - phsubd (%rax), %mm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - phsubd %xmm0, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - phsubd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - 2.00 - - - - - - - phsubsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 2.00 - - - - - 0.33 - phsubsw (%rax), %mm2 +# CHECK-NEXT: 0.50 1.50 - - - 1.00 - - - - - - - phsubsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 1.50 0.33 0.33 - 1.00 - - - - - 0.33 - phsubsw (%rax), %xmm2 +# CHECK-NEXT: 0.50 - - - - 2.50 - - - - - - - phsubw %mm0, %mm2 +# CHECK-NEXT: 0.50 - 0.33 0.33 - 2.50 - - - - - 0.33 - phsubw (%rax), %mm2 +# CHECK-NEXT: 0.33 1.33 - - - 1.33 - - - - - - - phsubw %xmm0, %xmm2 +# CHECK-NEXT: 0.33 1.33 0.33 0.33 - 1.33 - - - - - 0.33 - phsubw (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmaddubsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmaddubsw (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmaddubsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmaddubsw (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pmulhrsw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - pmulhrsw (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - pmulhrsw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - pmulhrsw (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - pshufb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - pshufb (%rax), %mm2 +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - pshufb %xmm0, %xmm2 +# CHECK-NEXT: - 0.50 0.33 0.33 - 0.50 - - - - - 0.33 - pshufb (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psignb %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psignb (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psignb %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psignb (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psignd %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psignd (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psignd %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psignd (%rax), %xmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psignw %mm0, %mm2 +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - psignw (%rax), %mm2 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - psignw %xmm0, %xmm2 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - psignw (%rax), %xmm2 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vaes.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vaes.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vaes.s @@ -0,0 +1,62 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vaesdec %ymm0, %ymm1, %ymm3 +vaesdec (%rax), %ymm1, %ymm3 + +vaesdeclast %ymm0, %ymm1, %ymm3 +vaesdeclast (%rax), %ymm1, %ymm3 + +vaesenc %ymm0, %ymm1, %ymm3 +vaesenc (%rax), %ymm1, %ymm3 + +vaesenclast %ymm0, %ymm1, %ymm3 +vaesenclast (%rax), %ymm1, %ymm3 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 5 0.50 vaesdec %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 2 12 0.50 * vaesdec (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 1 5 0.50 vaesdeclast %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 2 12 0.50 * vaesdeclast (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 1 5 0.50 vaesenc %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 2 12 0.50 * vaesenc (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 1 5 0.50 vaesenclast %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 2 12 0.50 * vaesenclast (%rax), %ymm1, %ymm3 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 4.00 4.00 1.33 1.33 - - - - - - - 1.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdec %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdec (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesdeclast %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesdeclast (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenc %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenc (%rax), %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 - - - - - - - - - - - vaesenclast %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 0.50 0.50 0.33 0.33 - - - - - - - 0.33 - vaesenclast (%rax), %ymm1, %ymm3 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vpclmulqdq.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vpclmulqdq.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-vpclmulqdq.s @@ -0,0 +1,41 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +vpclmulqdq $11, %ymm0, %ymm1, %ymm3 +vpclmulqdq $11, (%rax), %ymm1, %ymm3 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 3 1.00 vpclmulqdq $11, %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: 2 11 1.00 * vpclmulqdq $11, (%rax), %ymm1, %ymm3 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpclmulqdq $11, %ymm0, %ymm1, %ymm3 +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - vpclmulqdq $11, (%rax), %ymm1, %ymm3 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_32.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_32.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_32.s @@ -0,0 +1,83 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=i686-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +aaa + +aad +aad $7 + +aam +aam $7 + +aas + +bound %bx, (%eax) +bound %ebx, (%eax) + +daa + +das + +into + +leave + +salc + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 100 0.25 aaa +# CHECK-NEXT: 1 100 0.25 aad +# CHECK-NEXT: 1 100 0.25 aad $7 +# CHECK-NEXT: 1 100 0.25 aam +# CHECK-NEXT: 1 100 0.25 aam $7 +# CHECK-NEXT: 1 100 0.25 aas +# CHECK-NEXT: 1 100 0.25 U bound %bx, (%eax) +# CHECK-NEXT: 1 100 0.25 U bound %ebx, (%eax) +# CHECK-NEXT: 1 100 0.25 daa +# CHECK-NEXT: 1 100 0.25 das +# CHECK-NEXT: 1 100 0.25 U into +# CHECK-NEXT: 4 6 0.60 * leave +# CHECK-NEXT: 1 1 0.25 U salc + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 3.60 3.60 0.33 0.33 - 3.60 3.60 - - - 0.60 0.33 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aaa +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aad +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aad $7 +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aam +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aam $7 +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - aas +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - bound %bx, (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - bound %ebx, (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - daa +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - das +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - into +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - leave +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - salc diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_64.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_64.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x86_64.s @@ -0,0 +1,2884 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +adcb $0, %al +adcb $0, %dil +adcb $0, (%rax) +lock adcb $0, (%rax) +adcb $7, %al +adcb $7, %dil +adcb $7, (%rax) +lock adcb $7, (%rax) +adcb %sil, %dil +adcb %sil, (%rax) +lock adcb %sil, (%rax) +adcb (%rax), %dil + +adcw $0, %ax +adcw $0, %di +adcw $0, (%rax) +lock adcw $0, (%rax) +adcw $511, %ax +adcw $511, %di +adcw $511, (%rax) +lock adcw $511, (%rax) +adcw $7, %di +adcw $7, (%rax) +lock adcw $7, (%rax) +adcw %si, %di +adcw %si, (%rax) +lock adcw %si, (%rax) +adcw (%rax), %di + +adcl $0, %eax +adcl $0, %edi +adcl $0, (%rax) +lock adcl $0, (%rax) +adcl $665536, %eax +adcl $665536, %edi +adcl $665536, (%rax) +lock adcl $665536, (%rax) +adcl $7, %edi +adcl $7, (%rax) +lock adcl $7, (%rax) +adcl %esi, %edi +adcl %esi, (%rax) +lock adcl %esi, (%rax) +adcl (%rax), %edi + +adcq $0, %rax +adcq $0, %rdi +adcq $0, (%rax) +lock adcq $0, (%rax) +adcq $665536, %rax +adcq $665536, %rdi +adcq $665536, (%rax) +lock adcq $665536, (%rax) +adcq $7, %rdi +adcq $7, (%rax) +lock adcq $7, (%rax) +adcq %rsi, %rdi +adcq %rsi, (%rax) +lock adcq %rsi, (%rax) +adcq (%rax), %rdi + +addb $7, %al +addb $7, %dil +addb $7, (%rax) +lock addb $7, (%rax) +addb %sil, %dil +addb %sil, (%rax) +lock addb %sil, (%rax) +addb (%rax), %dil + +addw $511, %ax +addw $511, %di +addw $511, (%rax) +lock addw $511, (%rax) +addw $7, %di +addw $7, (%rax) +lock addw $7, (%rax) +addw %si, %di +addw %si, (%rax) +lock addw %si, (%rax) +addw (%rax), %di + +addl $665536, %eax +addl $665536, %edi +addl $665536, (%rax) +lock addl $665536, (%rax) +addl $7, %edi +addl $7, (%rax) +lock addl $7, (%rax) +addl %esi, %edi +addl %esi, (%rax) +lock addl %esi, (%rax) +addl (%rax), %edi + +addq $665536, %rax +addq $665536, %rdi +addq $665536, (%rax) +lock addq $665536, (%rax) +addq $7, %rdi +addq $7, (%rax) +lock addq $7, (%rax) +addq %rsi, %rdi +addq %rsi, (%rax) +lock addq %rsi, (%rax) +addq (%rax), %rdi + +andb $7, %al +andb $7, %dil +andb $7, (%rax) +lock andb $7, (%rax) +andb %sil, %dil +andb %sil, (%rax) +lock andb %sil, (%rax) +andb (%rax), %dil + +andw $511, %ax +andw $511, %di +andw $511, (%rax) +lock andw $511, (%rax) +andw $7, %di +andw $7, (%rax) +lock andw $7, (%rax) +andw %si, %di +andw %si, (%rax) +lock andw %si, (%rax) +andw (%rax), %di + +andl $665536, %eax +andl $665536, %edi +andl $665536, (%rax) +lock andl $665536, (%rax) +andl $7, %edi +andl $7, (%rax) +lock andl $7, (%rax) +andl %esi, %edi +andl %esi, (%rax) +lock andl %esi, (%rax) +andl (%rax), %edi + +andq $665536, %rax +andq $665536, %rdi +andq $665536, (%rax) +lock andq $665536, (%rax) +andq $7, %rdi +andq $7, (%rax) +lock andq $7, (%rax) +andq %rsi, %rdi +andq %rsi, (%rax) +lock andq %rsi, (%rax) +andq (%rax), %rdi + +bsfw %si, %di +bsrw %si, %di +bsfw (%rax), %di +bsrw (%rax), %di + +bsfl %esi, %edi +bsrl %esi, %edi +bsfl (%rax), %edi +bsrl (%rax), %edi + +bsfq %rsi, %rdi +bsrq %rsi, %rdi +bsfq (%rax), %rdi +bsrq (%rax), %rdi + +bswap %eax +bswap %rax + +btw %si, %di +btcw %si, %di +btrw %si, %di +btsw %si, %di +btw %si, (%rax) +btcw %si, (%rax) +btrw %si, (%rax) +btsw %si, (%rax) +lock btcw %si, (%rax) +lock btrw %si, (%rax) +lock btsw %si, (%rax) +btw $7, %di +btcw $7, %di +btrw $7, %di +btsw $7, %di +btw $7, (%rax) +btcw $7, (%rax) +btrw $7, (%rax) +btsw $7, (%rax) +lock btcw $7, (%rax) +lock btrw $7, (%rax) +lock btsw $7, (%rax) + +btl %esi, %edi +btcl %esi, %edi +btrl %esi, %edi +btsl %esi, %edi +btl %esi, (%rax) +btcl %esi, (%rax) +btrl %esi, (%rax) +btsl %esi, (%rax) +lock btcl %esi, (%rax) +lock btrl %esi, (%rax) +lock btsl %esi, (%rax) +btl $7, %edi +btcl $7, %edi +btrl $7, %edi +btsl $7, %edi +btl $7, (%rax) +btcl $7, (%rax) +btrl $7, (%rax) +btsl $7, (%rax) +lock btcl $7, (%rax) +lock btrl $7, (%rax) +lock btsl $7, (%rax) + +btq %rsi, %rdi +btcq %rsi, %rdi +btrq %rsi, %rdi +btsq %rsi, %rdi +btq %rsi, (%rax) +btcq %rsi, (%rax) +btrq %rsi, (%rax) +btsq %rsi, (%rax) +lock btcq %rsi, (%rax) +lock btrq %rsi, (%rax) +lock btsq %rsi, (%rax) +btq $7, %rdi +btcq $7, %rdi +btrq $7, %rdi +btsq $7, %rdi +btq $7, (%rax) +btcq $7, (%rax) +btrq $7, (%rax) +btsq $7, (%rax) +lock btcq $7, (%rax) +lock btrq $7, (%rax) +lock btsq $7, (%rax) + +cbw +cwde +cdqe +cwd +cdq +cqo + +clc +cld +cmc + +cmpb $7, %al +cmpb $7, %dil +cmpb $7, (%rax) +cmpb %sil, %dil +cmpb %sil, (%rax) +cmpb (%rax), %dil + +cmpw $511, %ax +cmpw $511, %di +cmpw $511, (%rax) +cmpw $7, %di +cmpw $7, (%rax) +cmpw %si, %di +cmpw %si, (%rax) +cmpw (%rax), %di + +cmpl $665536, %eax +cmpl $665536, %edi +cmpl $665536, (%rax) +cmpl $7, %edi +cmpl $7, (%rax) +cmpl %esi, %edi +cmpl %esi, (%rax) +cmpl (%rax), %edi + +cmpq $665536, %rax +cmpq $665536, %rdi +cmpq $665536, (%rax) +cmpq $7, %rdi +cmpq $7, (%rax) +cmpq %rsi, %rdi +cmpq %rsi, (%rax) +cmpq (%rax), %rdi + +cmpsb +cmpsw +cmpsl +cmpsq + +cmpxchgb %cl, %bl +cmpxchgb %cl, (%rbx) +lock cmpxchgb %cl, (%rbx) + +cmpxchgw %cx, %bx +cmpxchgw %cx, (%rbx) +lock cmpxchgw %cx, (%rbx) + +cmpxchgl %ecx, %ebx +cmpxchgl %ecx, (%rbx) +lock cmpxchgl %ecx, (%rbx) + +cmpxchgq %rcx, %rbx +cmpxchgq %rcx, (%rbx) +lock cmpxchgq %rcx, (%rbx) + +cpuid + +decb %dil +decb (%rax) +lock decb (%rax) +decw %di +decw (%rax) +lock decw (%rax) +decl %edi +decl (%rax) +lock decl (%rax) +decq %rdi +decq (%rax) +lock decq (%rax) + +divb %dil +divb (%rax) +divw %si +divw (%rax) +divl %edx +divl (%rax) +divq %rcx +divq (%rax) + +enter $7, $4095 + +idivb %dil +idivb (%rax) +idivw %si +idivw (%rax) +idivl %edx +idivl (%rax) +idivq %rcx +idivq (%rax) + +imulb %dil +imulb (%rax) + +imulw %di +imulw (%rax) +imulw %si, %di +imulw (%rax), %di +imulw $511, %si, %di +imulw $511, (%rax), %di +imulw $7, %si, %di +imulw $7, (%rax), %di + +imull %edi +imull (%rax) +imull %esi, %edi +imull (%rax), %edi +imull $665536, %esi, %edi +imull $665536, (%rax), %edi +imull $7, %esi, %edi +imull $7, (%rax), %edi + +imulq %rdi +imulq (%rax) +imulq %rsi, %rdi +imulq (%rax), %rdi +imulq $665536, %rsi, %rdi +imulq $665536, (%rax), %rdi +imulq $7, %rsi, %rdi +imulq $7, (%rax), %rdi + +inb $7, %al +inb %dx, %al +inw $7, %ax +inw %dx, %ax +inl $7, %eax +inl %dx, %eax + +incb %dil +incb (%rax) +lock incb (%rax) +incw %di +incw (%rax) +lock incw (%rax) +incl %edi +incl (%rax) +lock incl (%rax) +incq %rdi +incq (%rax) +lock incq (%rax) + +insb +insw +insl + +int $7 + +invlpg (%rax) +invlpga %rax, %ecx + +lahf + +leave + +lodsb +lodsw +lodsl +lodsq + +loop 0 +loope 0 +loopne 0 + +movsb +movsw +movsl +movsq + +movsbw %al, %di +movzbw %al, %di +movsbw (%rax), %di +movzbw (%rax), %di +movsbl %al, %edi +movzbl %al, %edi +movsbl (%rax), %edi +movzbl (%rax), %edi +movsbq %al, %rdi +movzbq %al, %rdi +movsbq (%rax), %rdi +movzbq (%rax), %rdi + +movswl %ax, %edi +movzwl %ax, %edi +movswl (%rax), %edi +movzwl (%rax), %edi +movswq %ax, %rdi +movzwq %ax, %rdi +movswq (%rax), %rdi +movzwq (%rax), %rdi + +movslq %eax, %rdi +movslq (%rax), %rdi + +mulb %dil +mulb (%rax) +mulw %si +mulw (%rax) +mull %edx +mull (%rax) +mulq %rcx +mulq (%rax) + +negb %dil +negb (%r8) +lock negb (%r8) +negw %si +negw (%r9) +lock negw (%r9) +negl %edx +negl (%rax) +lock negl (%rax) +negq %rcx +negq (%r10) +lock negq (%r10) + +nop +nopw %di +nopw (%rcx) +nopl %esi +nopl (%r8) +nopq %rdx +nopq (%r9) + +notb %dil +notb (%r8) +lock notb (%r8) +notw %si +notw (%r9) +lock notw (%r9) +notl %edx +notl (%rax) +lock notl (%rax) +notq %rcx +notq (%r10) +lock notq (%r10) + +orb $7, %al +orb $7, %dil +orb $7, (%rax) +lock orb $7, (%rax) +orb %sil, %dil +orb %sil, (%rax) +lock orb %sil, (%rax) +orb (%rax), %dil + +orw $511, %ax +orw $511, %di +orw $511, (%rax) +lock orw $511, (%rax) +orw $7, %di +orw $7, (%rax) +lock orw $7, (%rax) +orw %si, %di +orw %si, (%rax) +lock orw %si, (%rax) +orw (%rax), %di + +orl $665536, %eax +orl $665536, %edi +orl $665536, (%rax) +lock orl $665536, (%rax) +orl $7, %edi +orl $7, (%rax) +lock orl $7, (%rax) +orl %esi, %edi +orl %esi, (%rax) +lock orl %esi, (%rax) +orl (%rax), %edi + +orq $665536, %rax +orq $665536, %rdi +orq $665536, (%rax) +lock orq $665536, (%rax) +orq $7, %rdi +orq $7, (%rax) +lock orq $7, (%rax) +orq %rsi, %rdi +orq %rsi, (%rax) +lock orq %rsi, (%rax) +orq (%rax), %rdi + +outb %al, $7 +outb %al, %dx +outw %ax, $7 +outw %ax, %dx +outl %eax, $7 +outl %eax, %dx + +outsb +outsw +outsl + +pause + +rclb %dil +rcrb %dil +rclb (%rax) +rcrb (%rax) +rclb $7, %dil +rcrb $7, %dil +rclb $7, (%rax) +rcrb $7, (%rax) +rclb %cl, %dil +rcrb %cl, %dil +rclb %cl, (%rax) +rcrb %cl, (%rax) + +rclw %di +rcrw %di +rclw (%rax) +rcrw (%rax) +rclw $7, %di +rcrw $7, %di +rclw $7, (%rax) +rcrw $7, (%rax) +rclw %cl, %di +rcrw %cl, %di +rclw %cl, (%rax) +rcrw %cl, (%rax) + +rcll %edi +rcrl %edi +rcll (%rax) +rcrl (%rax) +rcll $7, %edi +rcrl $7, %edi +rcll $7, (%rax) +rcrl $7, (%rax) +rcll %cl, %edi +rcrl %cl, %edi +rcll %cl, (%rax) +rcrl %cl, (%rax) + +rclq %rdi +rcrq %rdi +rclq (%rax) +rcrq (%rax) +rclq $7, %rdi +rcrq $7, %rdi +rclq $7, (%rax) +rcrq $7, (%rax) +rclq %cl, %rdi +rcrq %cl, %rdi +rclq %cl, (%rax) +rcrq %cl, (%rax) + +rdmsr +rdpmc +rdtsc +rdtscp + +rolb %dil +rorb %dil +rolb (%rax) +rorb (%rax) +rolb $7, %dil +rorb $7, %dil +rolb $7, (%rax) +rorb $7, (%rax) +rolb %cl, %dil +rorb %cl, %dil +rolb %cl, (%rax) +rorb %cl, (%rax) + +rolw %di +rorw %di +rolw (%rax) +rorw (%rax) +rolw $7, %di +rorw $7, %di +rolw $7, (%rax) +rorw $7, (%rax) +rolw %cl, %di +rorw %cl, %di +rolw %cl, (%rax) +rorw %cl, (%rax) + +roll %edi +rorl %edi +roll (%rax) +rorl (%rax) +roll $7, %edi +rorl $7, %edi +roll $7, (%rax) +rorl $7, (%rax) +roll %cl, %edi +rorl %cl, %edi +roll %cl, (%rax) +rorl %cl, (%rax) + +rolq %rdi +rorq %rdi +rolq (%rax) +rorq (%rax) +rolq $7, %rdi +rorq $7, %rdi +rolq $7, (%rax) +rorq $7, (%rax) +rolq %cl, %rdi +rorq %cl, %rdi +rolq %cl, (%rax) +rorq %cl, (%rax) + +sahf + +sarb %dil +shlb %dil +shrb %dil +sarb (%rax) +shlb (%rax) +shrb (%rax) +sarb $7, %dil +shlb $7, %dil +shrb $7, %dil +sarb $7, (%rax) +shlb $7, (%rax) +shrb $7, (%rax) +sarb %cl, %dil +shlb %cl, %dil +shrb %cl, %dil +sarb %cl, (%rax) +shlb %cl, (%rax) +shrb %cl, (%rax) + +sarw %di +shlw %di +shrw %di +sarw (%rax) +shlw (%rax) +shrw (%rax) +sarw $7, %di +shlw $7, %di +shrw $7, %di +sarw $7, (%rax) +shlw $7, (%rax) +shrw $7, (%rax) +sarw %cl, %di +shlw %cl, %di +shrw %cl, %di +sarw %cl, (%rax) +shlw %cl, (%rax) +shrw %cl, (%rax) + +sarl %edi +shll %edi +shrl %edi +sarl (%rax) +shll (%rax) +shrl (%rax) +sarl $7, %edi +shll $7, %edi +shrl $7, %edi +sarl $7, (%rax) +shll $7, (%rax) +shrl $7, (%rax) +sarl %cl, %edi +shll %cl, %edi +shrl %cl, %edi +sarl %cl, (%rax) +shll %cl, (%rax) +shrl %cl, (%rax) + +sarq %rdi +shlq %rdi +shrq %rdi +sarq (%rax) +shlq (%rax) +shrq (%rax) +sarq $7, %rdi +shlq $7, %rdi +shrq $7, %rdi +sarq $7, (%rax) +shlq $7, (%rax) +shrq $7, (%rax) +sarq %cl, %rdi +shlq %cl, %rdi +shrq %cl, %rdi +sarq %cl, (%rax) +shlq %cl, (%rax) +shrq %cl, (%rax) + +sbbb $0, %al +sbbb $0, %dil +sbbb $0, (%rax) +lock sbbb $0, (%rax) +sbbb $7, %al +sbbb $7, %dil +sbbb $7, (%rax) +lock sbbb $7, (%rax) +sbbb %sil, %dil +sbbb %sil, (%rax) +lock sbbb %sil, (%rax) +sbbb (%rax), %dil + +sbbw $0, %ax +sbbw $0, %di +sbbw $0, (%rax) +lock sbbw $0, (%rax) +sbbw $511, %ax +sbbw $511, %di +sbbw $511, (%rax) +lock sbbw $511, (%rax) +sbbw $7, %di +sbbw $7, (%rax) +lock sbbw $7, (%rax) +sbbw %si, %di +sbbw %si, (%rax) +lock sbbw %si, (%rax) +sbbw (%rax), %di + +sbbl $0, %eax +sbbl $0, %edi +sbbl $0, (%rax) +lock sbbl $0, (%rax) +sbbl $665536, %eax +sbbl $665536, %edi +sbbl $665536, (%rax) +lock sbbl $665536, (%rax) +sbbl $7, %edi +sbbl $7, (%rax) +lock sbbl $7, (%rax) +sbbl %esi, %edi +sbbl %esi, (%rax) +lock sbbl %esi, (%rax) +sbbl (%rax), %edi + +sbbq $0, %rax +sbbq $0, %rdi +sbbq $0, (%rax) +lock sbbq $0, (%rax) +sbbq $665536, %rax +sbbq $665536, %rdi +sbbq $665536, (%rax) +lock sbbq $665536, (%rax) +sbbq $7, %rdi +sbbq $7, (%rax) +lock sbbq $7, (%rax) +sbbq %rsi, %rdi +sbbq %rsi, (%rax) +lock sbbq %rsi, (%rax) +sbbq (%rax), %rdi + +scasb +scasw +scasl +scasq + +seto %al +seto (%rax) +setno %al +setno (%rax) +setb %al +setb (%rax) +setnb %al +setnb (%rax) +setz %al +setz (%rax) +setnz %al +setnz (%rax) +seta %al +seta (%rax) +setna %al +setna (%rax) +sets %al +sets (%rax) +setns %al +setns (%rax) +setp %al +setp (%rax) +setnp %al +setnp (%rax) +setl %al +setl (%rax) +setnl %al +setnl (%rax) +setg %al +setg (%rax) +setng %al +setng (%rax) + +shldw %cl, %si, %di +shrdw %cl, %si, %di +shldw %cl, %si, (%rax) +shrdw %cl, %si, (%rax) +shldw $7, %si, %di +shrdw $7, %si, %di +shldw $7, %si, (%rax) +shrdw $7, %si, (%rax) + +shldl %cl, %esi, %edi +shrdl %cl, %esi, %edi +shldl %cl, %esi, (%rax) +shrdl %cl, %esi, (%rax) +shldl $7, %esi, %edi +shrdl $7, %esi, %edi +shldl $7, %esi, (%rax) +shrdl $7, %esi, (%rax) + +shldq %cl, %rsi, %rdi +shrdq %cl, %rsi, %rdi +shldq %cl, %rsi, (%rax) +shrdq %cl, %rsi, (%rax) +shldq $7, %rsi, %rdi +shrdq $7, %rsi, %rdi +shldq $7, %rsi, (%rax) +shrdq $7, %rsi, (%rax) + +stc +std + +stosb +stosw +stosl +stosq + +subb $7, %al +subb $7, %dil +subb $7, (%rax) +lock subb $7, (%rax) +subb %sil, %dil +subb %sil, (%rax) +lock subb %sil, (%rax) +subb (%rax), %dil + +subw $511, %ax +subw $511, %di +subw $511, (%rax) +lock subw $511, (%rax) +subw $7, %di +subw $7, (%rax) +lock subw $7, (%rax) +subw %si, %di +subw %si, (%rax) +lock subw %si, (%rax) +subw (%rax), %di + +subl $665536, %eax +subl $665536, %edi +subl $665536, (%rax) +lock subl $665536, (%rax) +subl $7, %edi +subl $7, (%rax) +lock subl $7, (%rax) +subl %esi, %edi +subl %esi, (%rax) +lock subl %esi, (%rax) +subl (%rax), %edi + +subq $665536, %rax +subq $665536, %rdi +subq $665536, (%rax) +lock subq $665536, (%rax) +subq $7, %rdi +subq $7, (%rax) +lock subq $7, (%rax) +subq %rsi, %rdi +subq %rsi, (%rax) +lock subq %rsi, (%rax) +subq (%rax), %rdi + +testb $7, %al +testb $7, %dil +testb $7, (%rax) +testb %sil, %dil +testb %sil, (%rax) + +testw $511, %ax +testw $511, %di +testw $511, (%rax) +testw $7, %di +testw $7, (%rax) +testw %si, %di +testw %si, (%rax) + +testl $665536, %eax +testl $665536, %edi +testl $665536, (%rax) +testl $7, %edi +testl $7, (%rax) +testl %esi, %edi +testl %esi, (%rax) + +testq $665536, %rax +testq $665536, %rdi +testq $665536, (%rax) +testq $7, %rdi +testq $7, (%rax) +testq %rsi, %rdi +testq %rsi, (%rax) + +ud2 + +wrmsr + +xaddb %bl, %cl +xaddb %bl, (%rcx) +lock xaddb %bl, (%rcx) + +xaddw %bx, %cx +xaddw %ax, (%rbx) +lock xaddw %ax, (%rbx) + +xaddl %ebx, %ecx +xaddl %eax, (%rbx) +lock xaddl %eax, (%rbx) + +xaddq %rbx, %rcx +xaddq %rax, (%rbx) +lock xaddq %rax, (%rbx) + +xchgb %bl, %cl +xchgb %bl, (%rbx) +lock xchgb %bl, (%rbx) + +xchgw %ax, %bx +xchgw %bx, %cx +xchgw %ax, (%rbx) +lock xchgw %ax, (%rbx) + +xchgl %eax, %ebx +xchgl %ebx, %ecx +xchgl %eax, (%rbx) +lock xchgl %eax, (%rbx) + +xchgq %rax, %rbx +xchgq %rbx, %rcx +xchgq %rax, (%rbx) +lock xchgq %rax, (%rbx) + +xlatb + +xorb $7, %al +xorb $7, %dil +xorb $7, (%rax) +lock xorb $7, (%rax) +xorb %sil, %dil +xorb %sil, (%rax) +lock xorb %sil, (%rax) +xorb (%rax), %dil + +xorw $511, %ax +xorw $511, %di +xorw $511, (%rax) +lock xorw $511, (%rax) +xorw $7, %di +xorw $7, (%rax) +lock xorw $7, (%rax) +xorw %si, %di +xorw %si, (%rax) +lock xorw %si, (%rax) +xorw (%rax), %di + +xorl $665536, %eax +xorl $665536, %edi +xorl $665536, (%rax) +lock xorl $665536, (%rax) +xorl $7, %edi +xorl $7, (%rax) +lock xorl $7, (%rax) +xorl %esi, %edi +xorl %esi, (%rax) +lock xorl %esi, (%rax) +xorl (%rax), %edi + +xorq $665536, %rax +xorq $665536, %rdi +xorq $665536, (%rax) +lock xorq $665536, (%rax) +xorq $7, %rdi +xorq $7, (%rax) +lock xorq $7, (%rax) +xorq %rsi, %rdi +xorq %rsi, (%rax) +lock xorq %rsi, (%rax) +xorq (%rax), %rdi + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.50 adcb $0, %al +# CHECK-NEXT: 1 1 0.50 adcb $0, %dil +# CHECK-NEXT: 5 13 0.50 * * adcb $0, (%rax) +# CHECK-NEXT: 5 13 0.50 * * lock adcb $0, (%rax) +# CHECK-NEXT: 1 1 0.50 adcb $7, %al +# CHECK-NEXT: 1 1 0.50 adcb $7, %dil +# CHECK-NEXT: 5 13 0.50 * * adcb $7, (%rax) +# CHECK-NEXT: 5 13 0.50 * * lock adcb $7, (%rax) +# CHECK-NEXT: 1 1 0.50 adcb %sil, %dil +# CHECK-NEXT: 6 13 0.60 * * adcb %sil, (%rax) +# CHECK-NEXT: 6 13 0.60 * * lock adcb %sil, (%rax) +# CHECK-NEXT: 2 6 0.50 * adcb (%rax), %dil +# CHECK-NEXT: 1 1 0.50 adcw $0, %ax +# CHECK-NEXT: 1 1 0.50 adcw $0, %di +# CHECK-NEXT: 5 12 0.50 * * adcw $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcw $0, (%rax) +# CHECK-NEXT: 1 1 0.50 adcw $511, %ax +# CHECK-NEXT: 1 1 0.50 adcw $511, %di +# CHECK-NEXT: 5 12 0.50 * * adcw $511, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcw $511, (%rax) +# CHECK-NEXT: 1 1 0.50 adcw $7, %di +# CHECK-NEXT: 5 12 0.50 * * adcw $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcw $7, (%rax) +# CHECK-NEXT: 1 1 0.50 adcw %si, %di +# CHECK-NEXT: 6 12 0.60 * * adcw %si, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock adcw %si, (%rax) +# CHECK-NEXT: 2 6 0.50 * adcw (%rax), %di +# CHECK-NEXT: 1 1 0.50 adcl $0, %eax +# CHECK-NEXT: 1 1 0.50 adcl $0, %edi +# CHECK-NEXT: 5 12 0.50 * * adcl $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcl $0, (%rax) +# CHECK-NEXT: 1 1 0.50 adcl $665536, %eax +# CHECK-NEXT: 1 1 0.50 adcl $665536, %edi +# CHECK-NEXT: 5 12 0.50 * * adcl $665536, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcl $665536, (%rax) +# CHECK-NEXT: 1 1 0.50 adcl $7, %edi +# CHECK-NEXT: 5 12 0.50 * * adcl $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcl $7, (%rax) +# CHECK-NEXT: 1 1 0.50 adcl %esi, %edi +# CHECK-NEXT: 6 12 0.60 * * adcl %esi, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock adcl %esi, (%rax) +# CHECK-NEXT: 2 6 0.50 * adcl (%rax), %edi +# CHECK-NEXT: 1 1 0.50 adcq $0, %rax +# CHECK-NEXT: 1 1 0.50 adcq $0, %rdi +# CHECK-NEXT: 5 12 0.50 * * adcq $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcq $0, (%rax) +# CHECK-NEXT: 1 1 0.50 adcq $665536, %rax +# CHECK-NEXT: 1 1 0.50 adcq $665536, %rdi +# CHECK-NEXT: 5 12 0.50 * * adcq $665536, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcq $665536, (%rax) +# CHECK-NEXT: 1 1 0.50 adcq $7, %rdi +# CHECK-NEXT: 5 12 0.50 * * adcq $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock adcq $7, (%rax) +# CHECK-NEXT: 1 1 0.50 adcq %rsi, %rdi +# CHECK-NEXT: 6 12 0.60 * * adcq %rsi, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock adcq %rsi, (%rax) +# CHECK-NEXT: 2 6 0.50 * adcq (%rax), %rdi +# CHECK-NEXT: 1 1 0.20 addb $7, %al +# CHECK-NEXT: 1 1 0.20 addb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * addb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock addb $7, (%rax) +# CHECK-NEXT: 1 1 0.20 addb %sil, %dil +# CHECK-NEXT: 4 13 0.50 * * addb %sil, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock addb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * addb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 addw $511, %ax +# CHECK-NEXT: 1 1 0.20 addw $511, %di +# CHECK-NEXT: 4 12 0.50 * * addw $511, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addw $511, (%rax) +# CHECK-NEXT: 1 1 0.20 addw $7, %di +# CHECK-NEXT: 4 12 0.50 * * addw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addw $7, (%rax) +# CHECK-NEXT: 1 1 0.20 addw %si, %di +# CHECK-NEXT: 4 12 0.50 * * addw %si, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * addw (%rax), %di +# CHECK-NEXT: 1 1 0.20 addl $665536, %eax +# CHECK-NEXT: 1 1 0.20 addl $665536, %edi +# CHECK-NEXT: 4 12 0.50 * * addl $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addl $665536, (%rax) +# CHECK-NEXT: 1 1 0.20 addl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * addl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addl $7, (%rax) +# CHECK-NEXT: 1 1 0.20 addl %esi, %edi +# CHECK-NEXT: 4 12 0.50 * * addl %esi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * addl (%rax), %edi +# CHECK-NEXT: 1 1 0.20 addq $665536, %rax +# CHECK-NEXT: 1 1 0.20 addq $665536, %rdi +# CHECK-NEXT: 4 12 0.50 * * addq $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addq $665536, (%rax) +# CHECK-NEXT: 0 1 0.00 addq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * addq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addq $7, (%rax) +# CHECK-NEXT: 1 1 0.20 addq %rsi, %rdi +# CHECK-NEXT: 4 12 0.50 * * addq %rsi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock addq %rsi, (%rax) +# CHECK-NEXT: 2 6 0.33 * addq (%rax), %rdi +# CHECK-NEXT: 1 2 0.20 andb $7, %al +# CHECK-NEXT: 1 2 0.20 andb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * andb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock andb $7, (%rax) +# CHECK-NEXT: 1 2 0.20 andb %sil, %dil +# CHECK-NEXT: 4 13 0.50 * * andb %sil, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock andb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * andb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 andw $511, %ax +# CHECK-NEXT: 1 1 0.20 andw $511, %di +# CHECK-NEXT: 4 12 0.50 * * andw $511, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andw $511, (%rax) +# CHECK-NEXT: 1 2 0.20 andw $7, %di +# CHECK-NEXT: 4 12 0.50 * * andw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andw $7, (%rax) +# CHECK-NEXT: 1 2 0.20 andw %si, %di +# CHECK-NEXT: 4 12 0.50 * * andw %si, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * andw (%rax), %di +# CHECK-NEXT: 1 2 0.20 andl $665536, %eax +# CHECK-NEXT: 1 2 0.20 andl $665536, %edi +# CHECK-NEXT: 4 12 0.50 * * andl $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andl $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 andl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * andl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andl $7, (%rax) +# CHECK-NEXT: 1 2 0.20 andl %esi, %edi +# CHECK-NEXT: 4 12 0.50 * * andl %esi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * andl (%rax), %edi +# CHECK-NEXT: 1 2 0.20 andq $665536, %rax +# CHECK-NEXT: 1 2 0.20 andq $665536, %rdi +# CHECK-NEXT: 4 12 0.50 * * andq $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andq $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 andq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * andq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andq $7, (%rax) +# CHECK-NEXT: 1 2 0.20 andq %rsi, %rdi +# CHECK-NEXT: 4 12 0.50 * * andq %rsi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock andq %rsi, (%rax) +# CHECK-NEXT: 2 7 0.33 * andq (%rax), %rdi +# CHECK-NEXT: 1 3 1.00 bsfw %si, %di +# CHECK-NEXT: 1 3 1.00 bsrw %si, %di +# CHECK-NEXT: 2 8 1.00 * bsfw (%rax), %di +# CHECK-NEXT: 2 8 1.00 * bsrw (%rax), %di +# CHECK-NEXT: 1 3 1.00 bsfl %esi, %edi +# CHECK-NEXT: 1 3 1.00 bsrl %esi, %edi +# CHECK-NEXT: 2 8 1.00 * bsfl (%rax), %edi +# CHECK-NEXT: 2 8 1.00 * bsrl (%rax), %edi +# CHECK-NEXT: 1 3 1.00 bsfq %rsi, %rdi +# CHECK-NEXT: 1 3 1.00 bsrq %rsi, %rdi +# CHECK-NEXT: 2 8 1.00 * bsfq (%rax), %rdi +# CHECK-NEXT: 2 8 1.00 * bsrq (%rax), %rdi +# CHECK-NEXT: 1 1 1.00 bswapl %eax +# CHECK-NEXT: 2 2 1.00 bswapq %rax +# CHECK-NEXT: 1 1 1.00 btw %si, %di +# CHECK-NEXT: 1 1 1.00 btcw %si, %di +# CHECK-NEXT: 1 1 1.00 btrw %si, %di +# CHECK-NEXT: 1 1 1.00 btsw %si, %di +# CHECK-NEXT: 10 11 1.80 * btw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btcw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btrw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btsw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btcw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btrw %si, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btsw %si, (%rax) +# CHECK-NEXT: 1 1 1.00 btw $7, %di +# CHECK-NEXT: 1 1 1.00 btcw $7, %di +# CHECK-NEXT: 1 1 1.00 btrw $7, %di +# CHECK-NEXT: 1 1 1.00 btsw $7, %di +# CHECK-NEXT: 2 6 1.00 * btw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btcw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btrw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btsw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btcw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btrw $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btsw $7, (%rax) +# CHECK-NEXT: 1 1 1.00 btl %esi, %edi +# CHECK-NEXT: 1 1 1.00 btcl %esi, %edi +# CHECK-NEXT: 1 1 1.00 btrl %esi, %edi +# CHECK-NEXT: 1 1 1.00 btsl %esi, %edi +# CHECK-NEXT: 10 11 1.80 * btl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btcl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btrl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * btsl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btcl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btrl %esi, (%rax) +# CHECK-NEXT: 11 18 1.60 * * lock btsl %esi, (%rax) +# CHECK-NEXT: 1 1 1.00 btl $7, %edi +# CHECK-NEXT: 1 1 1.00 btcl $7, %edi +# CHECK-NEXT: 1 1 1.00 btrl $7, %edi +# CHECK-NEXT: 1 1 1.00 btsl $7, %edi +# CHECK-NEXT: 2 6 1.00 * btl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btcl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btrl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btsl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btcl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btrl $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btsl $7, (%rax) +# CHECK-NEXT: 1 3 1.00 btq %rsi, %rdi +# CHECK-NEXT: 1 3 1.00 btcq %rsi, %rdi +# CHECK-NEXT: 1 3 1.00 btrq %rsi, %rdi +# CHECK-NEXT: 1 3 1.00 btsq %rsi, %rdi +# CHECK-NEXT: 9 10 1.60 * btq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * btcq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * btrq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * btsq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * lock btcq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * lock btrq %rsi, (%rax) +# CHECK-NEXT: 10 17 1.40 * * lock btsq %rsi, (%rax) +# CHECK-NEXT: 1 1 1.00 btq $7, %rdi +# CHECK-NEXT: 1 1 1.00 btcq $7, %rdi +# CHECK-NEXT: 1 1 1.00 btrq $7, %rdi +# CHECK-NEXT: 1 1 1.00 btsq $7, %rdi +# CHECK-NEXT: 2 6 1.00 * btq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btcq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btrq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * btsq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btcq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btrq $7, (%rax) +# CHECK-NEXT: 4 12 1.00 * * lock btsq $7, (%rax) +# CHECK-NEXT: 1 1 0.50 cbtw +# CHECK-NEXT: 1 1 0.50 cwtl +# CHECK-NEXT: 1 1 0.50 cltq +# CHECK-NEXT: 2 2 0.50 cwtd +# CHECK-NEXT: 1 1 0.50 cltd +# CHECK-NEXT: 1 1 0.50 cqto +# CHECK-NEXT: 0 1 0.00 U clc +# CHECK-NEXT: 2 3 0.50 U cld +# CHECK-NEXT: 1 1 0.20 U cmc +# CHECK-NEXT: 1 1 0.20 cmpb $7, %al +# CHECK-NEXT: 1 1 0.20 cmpb $7, %dil +# CHECK-NEXT: 2 6 0.33 * cmpb $7, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpb %sil, %dil +# CHECK-NEXT: 2 6 0.33 * cmpb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * cmpb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 cmpw $511, %ax +# CHECK-NEXT: 1 1 0.20 cmpw $511, %di +# CHECK-NEXT: 2 6 0.33 * cmpw $511, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpw $7, %di +# CHECK-NEXT: 2 6 0.33 * cmpw $7, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpw %si, %di +# CHECK-NEXT: 2 6 0.33 * cmpw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * cmpw (%rax), %di +# CHECK-NEXT: 1 1 0.20 cmpl $665536, %eax +# CHECK-NEXT: 1 1 0.20 cmpl $665536, %edi +# CHECK-NEXT: 2 6 0.33 * cmpl $665536, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpl $7, %edi +# CHECK-NEXT: 2 6 0.33 * cmpl $7, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpl %esi, %edi +# CHECK-NEXT: 2 6 0.33 * cmpl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * cmpl (%rax), %edi +# CHECK-NEXT: 1 1 0.20 cmpq $665536, %rax +# CHECK-NEXT: 1 1 0.20 cmpq $665536, %rdi +# CHECK-NEXT: 2 6 0.33 * cmpq $665536, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpq $7, %rdi +# CHECK-NEXT: 2 6 0.33 * cmpq $7, (%rax) +# CHECK-NEXT: 1 1 0.20 cmpq %rsi, %rdi +# CHECK-NEXT: 2 6 0.33 * cmpq %rsi, (%rax) +# CHECK-NEXT: 2 6 0.33 * cmpq (%rax), %rdi +# CHECK-NEXT: 7 6 1.00 U cmpsb %es:(%rdi), (%rsi) +# CHECK-NEXT: 7 6 1.00 U cmpsw %es:(%rdi), (%rsi) +# CHECK-NEXT: 7 6 1.00 U cmpsl %es:(%rdi), (%rsi) +# CHECK-NEXT: 7 6 1.00 U cmpsq %es:(%rdi), (%rsi) +# CHECK-NEXT: 5 3 1.00 cmpxchgb %cl, %bl +# CHECK-NEXT: 6 13 1.00 * * cmpxchgb %cl, (%rbx) +# CHECK-NEXT: 6 13 1.00 * * lock cmpxchgb %cl, (%rbx) +# CHECK-NEXT: 5 3 1.00 cmpxchgw %cx, %bx +# CHECK-NEXT: 6 12 1.00 * * cmpxchgw %cx, (%rbx) +# CHECK-NEXT: 6 12 1.00 * * lock cmpxchgw %cx, (%rbx) +# CHECK-NEXT: 5 3 1.00 cmpxchgl %ecx, %ebx +# CHECK-NEXT: 6 12 1.00 * * cmpxchgl %ecx, (%rbx) +# CHECK-NEXT: 6 12 1.00 * * lock cmpxchgl %ecx, (%rbx) +# CHECK-NEXT: 5 3 1.00 cmpxchgq %rcx, %rbx +# CHECK-NEXT: 6 12 1.00 * * cmpxchgq %rcx, (%rbx) +# CHECK-NEXT: 6 12 1.00 * * lock cmpxchgq %rcx, (%rbx) +# CHECK-NEXT: 26 18 6.00 U cpuid +# CHECK-NEXT: 1 1 0.20 decb %dil +# CHECK-NEXT: 4 13 0.50 * * decb (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock decb (%rax) +# CHECK-NEXT: 1 1 0.20 decw %di +# CHECK-NEXT: 4 12 0.50 * * decw (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock decw (%rax) +# CHECK-NEXT: 1 1 0.20 decl %edi +# CHECK-NEXT: 4 12 0.50 * * decl (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock decl (%rax) +# CHECK-NEXT: 0 1 0.00 decq %rdi +# CHECK-NEXT: 4 12 0.50 * * decq (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock decq (%rax) +# CHECK-NEXT: 3 17 3.00 U divb %dil +# CHECK-NEXT: 3 22 3.00 * U divb (%rax) +# CHECK-NEXT: 4 16 3.00 U divw %si +# CHECK-NEXT: 5 20 3.00 * U divw (%rax) +# CHECK-NEXT: 4 15 3.00 U divl %edx +# CHECK-NEXT: 5 19 3.00 * U divl (%rax) +# CHECK-NEXT: 3 18 3.00 U divq %rcx +# CHECK-NEXT: 4 23 3.00 * U divq (%rax) +# CHECK-NEXT: 57 126 11.50 U enter $7, $4095 +# CHECK-NEXT: 3 17 3.00 U idivb %dil +# CHECK-NEXT: 3 22 3.00 * U idivb (%rax) +# CHECK-NEXT: 4 16 3.00 U idivw %si +# CHECK-NEXT: 5 20 3.00 * U idivw (%rax) +# CHECK-NEXT: 4 15 3.00 U idivl %edx +# CHECK-NEXT: 5 19 3.00 * U idivl (%rax) +# CHECK-NEXT: 3 18 3.00 U idivq %rcx +# CHECK-NEXT: 4 23 3.00 * U idivq (%rax) +# CHECK-NEXT: 1 3 1.00 imulb %dil +# CHECK-NEXT: 2 8 1.00 * imulb (%rax) +# CHECK-NEXT: 4 5 1.00 imulw %di +# CHECK-NEXT: 5 10 1.00 * imulw (%rax) +# CHECK-NEXT: 1 3 1.00 imulw %si, %di +# CHECK-NEXT: 2 8 1.00 * imulw (%rax), %di +# CHECK-NEXT: 2 4 1.00 imulw $511, %si, %di +# CHECK-NEXT: 3 9 1.00 * imulw $511, (%rax), %di +# CHECK-NEXT: 2 4 1.00 imulw $7, %si, %di +# CHECK-NEXT: 3 9 1.00 * imulw $7, (%rax), %di +# CHECK-NEXT: 3 4 1.00 imull %edi +# CHECK-NEXT: 4 9 1.00 * imull (%rax) +# CHECK-NEXT: 1 3 1.00 imull %esi, %edi +# CHECK-NEXT: 2 8 1.00 * imull (%rax), %edi +# CHECK-NEXT: 1 3 1.00 imull $665536, %esi, %edi +# CHECK-NEXT: 2 8 1.00 * imull $665536, (%rax), %edi +# CHECK-NEXT: 1 3 1.00 imull $7, %esi, %edi +# CHECK-NEXT: 2 8 1.00 * imull $7, (%rax), %edi +# CHECK-NEXT: 2 4 1.00 imulq %rdi +# CHECK-NEXT: 3 9 1.00 * imulq (%rax) +# CHECK-NEXT: 1 3 1.00 imulq %rsi, %rdi +# CHECK-NEXT: 2 8 1.00 * imulq (%rax), %rdi +# CHECK-NEXT: 1 3 1.00 imulq $665536, %rsi, %rdi +# CHECK-NEXT: 2 8 1.00 * imulq $665536, (%rax), %rdi +# CHECK-NEXT: 1 3 1.00 imulq $7, %rsi, %rdi +# CHECK-NEXT: 2 8 1.00 * imulq $7, (%rax), %rdi +# CHECK-NEXT: 87 35 20.00 U inb $7, %al +# CHECK-NEXT: 86 35 20.00 U inb %dx, %al +# CHECK-NEXT: 87 35 21.00 U inw $7, %ax +# CHECK-NEXT: 87 35 20.00 U inw %dx, %ax +# CHECK-NEXT: 94 35 21.00 U inl $7, %eax +# CHECK-NEXT: 99 1 21.00 U inl %dx, %eax +# CHECK-NEXT: 1 1 0.20 incb %dil +# CHECK-NEXT: 4 13 0.50 * * incb (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock incb (%rax) +# CHECK-NEXT: 1 1 0.20 incw %di +# CHECK-NEXT: 4 12 0.50 * * incw (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock incw (%rax) +# CHECK-NEXT: 1 1 0.20 incl %edi +# CHECK-NEXT: 4 12 0.50 * * incl (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock incl (%rax) +# CHECK-NEXT: 0 1 0.00 incq %rdi +# CHECK-NEXT: 4 12 0.50 * * incq (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock incq (%rax) +# CHECK-NEXT: 83 20 19.00 U insb %dx, %es:(%rdi) +# CHECK-NEXT: 86 20 19.00 U insw %dx, %es:(%rdi) +# CHECK-NEXT: 92 20 21.00 U insl %dx, %es:(%rdi) +# CHECK-NEXT: 1 100 0.25 * * U int $7 +# CHECK-NEXT: 42 100 7.00 U invlpg (%rax) +# CHECK-NEXT: 1 100 0.25 U invlpga +# CHECK-NEXT: 1 3 0.50 lahf +# CHECK-NEXT: 3 6 0.40 * leave +# CHECK-NEXT: 4 6 0.60 U lodsb (%rsi), %al +# CHECK-NEXT: 4 6 0.60 U lodsw (%rsi), %ax +# CHECK-NEXT: 3 5 0.40 U lodsl (%rsi), %eax +# CHECK-NEXT: 3 5 0.40 U lodsq (%rsi), %rax +# CHECK-NEXT: 7 3 2.00 U loop 0 +# CHECK-NEXT: 11 3 3.00 U loope 0 +# CHECK-NEXT: 11 2 3.00 U loopne 0 +# CHECK-NEXT: 7 8 0.80 U movsb (%rsi), %es:(%rdi) +# CHECK-NEXT: 7 7 0.80 U movsw (%rsi), %es:(%rdi) +# CHECK-NEXT: 7 7 0.80 U movsl (%rsi), %es:(%rdi) +# CHECK-NEXT: 7 7 0.80 U movsq (%rsi), %es:(%rdi) +# CHECK-NEXT: 1 1 0.33 movsbw %al, %di +# CHECK-NEXT: 1 1 0.20 movzbw %al, %di +# CHECK-NEXT: 2 6 0.33 * movsbw (%rax), %di +# CHECK-NEXT: 2 6 0.33 * movzbw (%rax), %di +# CHECK-NEXT: 1 1 0.33 movsbl %al, %edi +# CHECK-NEXT: 1 0 0.20 movzbl %al, %edi +# CHECK-NEXT: 1 6 0.33 * movsbl (%rax), %edi +# CHECK-NEXT: 1 5 0.33 * movzbl (%rax), %edi +# CHECK-NEXT: 1 1 0.33 movsbq %al, %rdi +# CHECK-NEXT: 1 0 0.20 movzbq %al, %rdi +# CHECK-NEXT: 1 6 0.33 * movsbq (%rax), %rdi +# CHECK-NEXT: 1 5 0.33 * movzbq (%rax), %rdi +# CHECK-NEXT: 1 1 0.33 movswl %ax, %edi +# CHECK-NEXT: 1 1 0.20 movzwl %ax, %edi +# CHECK-NEXT: 1 6 0.33 * movswl (%rax), %edi +# CHECK-NEXT: 1 5 0.33 * movzwl (%rax), %edi +# CHECK-NEXT: 1 1 0.33 movswq %ax, %rdi +# CHECK-NEXT: 1 1 0.20 movzwq %ax, %rdi +# CHECK-NEXT: 1 6 0.33 * movswq (%rax), %rdi +# CHECK-NEXT: 1 5 0.33 * movzwq (%rax), %rdi +# CHECK-NEXT: 1 1 0.33 movslq %eax, %rdi +# CHECK-NEXT: 1 6 0.33 * movslq (%rax), %rdi +# CHECK-NEXT: 1 3 1.00 mulb %dil +# CHECK-NEXT: 2 8 1.00 * mulb (%rax) +# CHECK-NEXT: 4 5 1.00 mulw %si +# CHECK-NEXT: 5 10 1.00 * mulw (%rax) +# CHECK-NEXT: 3 4 1.00 mull %edx +# CHECK-NEXT: 4 9 1.00 * mull (%rax) +# CHECK-NEXT: 2 4 1.00 mulq %rcx +# CHECK-NEXT: 3 9 1.00 * mulq (%rax) +# CHECK-NEXT: 1 1 0.20 negb %dil +# CHECK-NEXT: 4 13 0.50 * * negb (%r8) +# CHECK-NEXT: 4 13 0.50 * * lock negb (%r8) +# CHECK-NEXT: 1 1 0.20 negw %si +# CHECK-NEXT: 4 12 0.50 * * negw (%r9) +# CHECK-NEXT: 4 12 0.50 * * lock negw (%r9) +# CHECK-NEXT: 1 1 0.20 negl %edx +# CHECK-NEXT: 4 12 0.50 * * negl (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock negl (%rax) +# CHECK-NEXT: 1 1 0.20 negq %rcx +# CHECK-NEXT: 4 12 0.50 * * negq (%r10) +# CHECK-NEXT: 4 12 0.50 * * lock negq (%r10) +# CHECK-NEXT: 0 1 0.00 nop +# CHECK-NEXT: 0 1 0.00 nopw %di +# CHECK-NEXT: 0 1 0.00 nopw (%rcx) +# CHECK-NEXT: 0 1 0.00 nopl %esi +# CHECK-NEXT: 0 1 0.00 nopl (%r8) +# CHECK-NEXT: 0 1 0.00 nopq %rdx +# CHECK-NEXT: 0 1 0.00 nopq (%r9) +# CHECK-NEXT: 1 1 0.20 notb %dil +# CHECK-NEXT: 4 13 0.50 * * notb (%r8) +# CHECK-NEXT: 4 13 0.50 * * lock notb (%r8) +# CHECK-NEXT: 1 1 0.20 notw %si +# CHECK-NEXT: 4 12 0.50 * * notw (%r9) +# CHECK-NEXT: 4 12 0.50 * * lock notw (%r9) +# CHECK-NEXT: 1 1 0.20 notl %edx +# CHECK-NEXT: 4 12 0.50 * * notl (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock notl (%rax) +# CHECK-NEXT: 1 1 0.20 notq %rcx +# CHECK-NEXT: 4 12 0.50 * * notq (%r10) +# CHECK-NEXT: 4 12 0.50 * * lock notq (%r10) +# CHECK-NEXT: 1 2 0.20 orb $7, %al +# CHECK-NEXT: 1 2 0.20 orb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * orb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock orb $7, (%rax) +# CHECK-NEXT: 1 2 0.20 orb %sil, %dil +# CHECK-NEXT: 4 13 0.50 * * orb %sil, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock orb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * orb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 orw $511, %ax +# CHECK-NEXT: 1 1 0.20 orw $511, %di +# CHECK-NEXT: 4 12 0.50 * * orw $511, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orw $511, (%rax) +# CHECK-NEXT: 1 2 0.20 orw $7, %di +# CHECK-NEXT: 4 12 0.50 * * orw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orw $7, (%rax) +# CHECK-NEXT: 1 2 0.20 orw %si, %di +# CHECK-NEXT: 4 12 0.50 * * orw %si, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * orw (%rax), %di +# CHECK-NEXT: 1 2 0.20 orl $665536, %eax +# CHECK-NEXT: 1 2 0.20 orl $665536, %edi +# CHECK-NEXT: 4 12 0.50 * * orl $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orl $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 orl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * orl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orl $7, (%rax) +# CHECK-NEXT: 1 2 0.20 orl %esi, %edi +# CHECK-NEXT: 4 12 0.50 * * orl %esi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * orl (%rax), %edi +# CHECK-NEXT: 1 2 0.20 orq $665536, %rax +# CHECK-NEXT: 1 2 0.20 orq $665536, %rdi +# CHECK-NEXT: 4 12 0.50 * * orq $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orq $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 orq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * orq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orq $7, (%rax) +# CHECK-NEXT: 1 2 0.20 orq %rsi, %rdi +# CHECK-NEXT: 4 12 0.50 * * orq %rsi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock orq %rsi, (%rax) +# CHECK-NEXT: 2 7 0.33 * orq (%rax), %rdi +# CHECK-NEXT: 73 35 15.33 U outb %al, $7 +# CHECK-NEXT: 73 35 15.50 U outb %al, %dx +# CHECK-NEXT: 79 35 17.00 U outw %ax, $7 +# CHECK-NEXT: 79 35 16.50 U outw %ax, %dx +# CHECK-NEXT: 85 35 18.33 U outl %eax, $7 +# CHECK-NEXT: 85 35 18.00 U outl %eax, %dx +# CHECK-NEXT: 80 100 17.00 U outsb (%rsi), %dx +# CHECK-NEXT: 83 100 18.00 U outsw (%rsi), %dx +# CHECK-NEXT: 89 100 20.00 U outsl (%rsi), %dx +# CHECK-NEXT: 2 140 1.00 * * U pause +# CHECK-NEXT: 3 2 1.00 rclb %dil +# CHECK-NEXT: 3 2 1.00 rcrb %dil +# CHECK-NEXT: 6 13 1.00 * rclb (%rax) +# CHECK-NEXT: 6 13 1.00 * rcrb (%rax) +# CHECK-NEXT: 3 2 1.00 rclb $7, %dil +# CHECK-NEXT: 3 2 1.00 rcrb $7, %dil +# CHECK-NEXT: 6 13 1.00 * rclb $7, (%rax) +# CHECK-NEXT: 6 13 1.00 * rcrb $7, (%rax) +# CHECK-NEXT: 9 7 2.50 rclb %cl, %dil +# CHECK-NEXT: 10 9 3.00 rcrb %cl, %dil +# CHECK-NEXT: 11 20 2.50 * rclb %cl, (%rax) +# CHECK-NEXT: 12 20 3.00 * rcrb %cl, (%rax) +# CHECK-NEXT: 3 2 1.00 rclw %di +# CHECK-NEXT: 3 2 1.00 rcrw %di +# CHECK-NEXT: 6 12 1.00 * rclw (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrw (%rax) +# CHECK-NEXT: 3 2 1.00 rclw $7, %di +# CHECK-NEXT: 3 2 1.00 rcrw $7, %di +# CHECK-NEXT: 6 12 1.00 * rclw $7, (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrw $7, (%rax) +# CHECK-NEXT: 7 8 2.00 rclw %cl, %di +# CHECK-NEXT: 7 8 2.00 rcrw %cl, %di +# CHECK-NEXT: 10 19 2.00 * rclw %cl, (%rax) +# CHECK-NEXT: 10 19 2.00 * rcrw %cl, (%rax) +# CHECK-NEXT: 3 2 1.00 rcll %edi +# CHECK-NEXT: 3 2 1.00 rcrl %edi +# CHECK-NEXT: 6 12 1.00 * rcll (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrl (%rax) +# CHECK-NEXT: 3 2 1.00 rcll $7, %edi +# CHECK-NEXT: 3 2 1.00 rcrl $7, %edi +# CHECK-NEXT: 6 12 1.00 * rcll $7, (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrl $7, (%rax) +# CHECK-NEXT: 7 8 2.00 rcll %cl, %edi +# CHECK-NEXT: 7 8 2.00 rcrl %cl, %edi +# CHECK-NEXT: 10 19 2.00 * rcll %cl, (%rax) +# CHECK-NEXT: 10 19 2.00 * rcrl %cl, (%rax) +# CHECK-NEXT: 3 2 1.00 rclq %rdi +# CHECK-NEXT: 3 2 1.00 rcrq %rdi +# CHECK-NEXT: 6 12 1.00 * rclq (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrq (%rax) +# CHECK-NEXT: 3 2 1.00 rclq $7, %rdi +# CHECK-NEXT: 3 2 1.00 rcrq $7, %rdi +# CHECK-NEXT: 6 12 1.00 * rclq $7, (%rax) +# CHECK-NEXT: 6 12 1.00 * rcrq $7, (%rax) +# CHECK-NEXT: 7 8 2.00 rclq %cl, %rdi +# CHECK-NEXT: 7 8 2.00 rcrq %cl, %rdi +# CHECK-NEXT: 10 19 2.00 * rclq %cl, (%rax) +# CHECK-NEXT: 10 19 2.00 * rcrq %cl, (%rax) +# CHECK-NEXT: 54 100 13.25 U rdmsr +# CHECK-NEXT: 18 100 3.60 U rdpmc +# CHECK-NEXT: 15 18 3.00 U rdtsc +# CHECK-NEXT: 21 42 5.25 U rdtscp +# CHECK-NEXT: 2 1 1.00 rolb %dil +# CHECK-NEXT: 2 1 1.00 rorb %dil +# CHECK-NEXT: 5 13 1.00 * * rolb (%rax) +# CHECK-NEXT: 5 13 1.00 * * rorb (%rax) +# CHECK-NEXT: 2 1 1.00 rolb $7, %dil +# CHECK-NEXT: 2 1 1.00 rorb $7, %dil +# CHECK-NEXT: 5 13 1.00 * * rolb $7, (%rax) +# CHECK-NEXT: 5 13 1.00 * * rorb $7, (%rax) +# CHECK-NEXT: 2 2 1.00 rolb %cl, %dil +# CHECK-NEXT: 2 2 1.00 rorb %cl, %dil +# CHECK-NEXT: 5 13 1.00 * * rolb %cl, (%rax) +# CHECK-NEXT: 5 13 1.00 * * rorb %cl, (%rax) +# CHECK-NEXT: 2 1 1.00 rolw %di +# CHECK-NEXT: 2 1 1.00 rorw %di +# CHECK-NEXT: 5 12 1.00 * * rolw (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorw (%rax) +# CHECK-NEXT: 2 1 1.00 rolw $7, %di +# CHECK-NEXT: 2 1 1.00 rorw $7, %di +# CHECK-NEXT: 5 12 1.00 * * rolw $7, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorw $7, (%rax) +# CHECK-NEXT: 2 2 1.00 rolw %cl, %di +# CHECK-NEXT: 2 2 1.00 rorw %cl, %di +# CHECK-NEXT: 5 12 1.00 * * rolw %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorw %cl, (%rax) +# CHECK-NEXT: 2 1 1.00 roll %edi +# CHECK-NEXT: 2 1 1.00 rorl %edi +# CHECK-NEXT: 5 12 1.00 * * roll (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorl (%rax) +# CHECK-NEXT: 2 1 1.00 roll $7, %edi +# CHECK-NEXT: 2 1 1.00 rorl $7, %edi +# CHECK-NEXT: 5 12 1.00 * * roll $7, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorl $7, (%rax) +# CHECK-NEXT: 2 2 1.00 roll %cl, %edi +# CHECK-NEXT: 2 2 1.00 rorl %cl, %edi +# CHECK-NEXT: 5 12 1.00 * * roll %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorl %cl, (%rax) +# CHECK-NEXT: 2 1 1.00 rolq %rdi +# CHECK-NEXT: 2 1 1.00 rorq %rdi +# CHECK-NEXT: 5 12 1.00 * * rolq (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorq (%rax) +# CHECK-NEXT: 2 1 1.00 rolq $7, %rdi +# CHECK-NEXT: 2 1 1.00 rorq $7, %rdi +# CHECK-NEXT: 5 12 1.00 * * rolq $7, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorq $7, (%rax) +# CHECK-NEXT: 2 2 1.00 rolq %cl, %rdi +# CHECK-NEXT: 2 2 1.00 rorq %cl, %rdi +# CHECK-NEXT: 5 12 1.00 * * rolq %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * rorq %cl, (%rax) +# CHECK-NEXT: 2 4 1.00 sahf +# CHECK-NEXT: 1 1 0.50 sarb %dil +# CHECK-NEXT: 1 1 0.50 shlb %dil +# CHECK-NEXT: 1 1 0.50 shrb %dil +# CHECK-NEXT: 4 13 0.50 * * sarb (%rax) +# CHECK-NEXT: 4 13 0.50 * * shlb (%rax) +# CHECK-NEXT: 4 13 0.50 * * shrb (%rax) +# CHECK-NEXT: 1 1 0.50 sarb $7, %dil +# CHECK-NEXT: 1 1 0.50 shlb $7, %dil +# CHECK-NEXT: 1 1 0.50 shrb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * sarb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * shlb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * shrb $7, (%rax) +# CHECK-NEXT: 2 2 1.00 sarb %cl, %dil +# CHECK-NEXT: 2 2 1.00 shlb %cl, %dil +# CHECK-NEXT: 2 2 1.00 shrb %cl, %dil +# CHECK-NEXT: 5 13 1.00 * * sarb %cl, (%rax) +# CHECK-NEXT: 5 13 1.00 * * shlb %cl, (%rax) +# CHECK-NEXT: 5 13 1.00 * * shrb %cl, (%rax) +# CHECK-NEXT: 1 1 0.50 sarw %di +# CHECK-NEXT: 1 1 0.50 shlw %di +# CHECK-NEXT: 1 1 0.50 shrw %di +# CHECK-NEXT: 4 12 0.50 * * sarw (%rax) +# CHECK-NEXT: 4 12 0.50 * * shlw (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrw (%rax) +# CHECK-NEXT: 1 1 0.50 sarw $7, %di +# CHECK-NEXT: 1 1 0.50 shlw $7, %di +# CHECK-NEXT: 1 1 0.50 shrw $7, %di +# CHECK-NEXT: 4 12 0.50 * * sarw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shlw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrw $7, (%rax) +# CHECK-NEXT: 2 2 1.00 sarw %cl, %di +# CHECK-NEXT: 2 2 1.00 shlw %cl, %di +# CHECK-NEXT: 2 2 1.00 shrw %cl, %di +# CHECK-NEXT: 5 12 1.00 * * sarw %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shlw %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shrw %cl, (%rax) +# CHECK-NEXT: 1 1 0.50 sarl %edi +# CHECK-NEXT: 1 1 0.50 shll %edi +# CHECK-NEXT: 1 1 0.50 shrl %edi +# CHECK-NEXT: 4 12 0.50 * * sarl (%rax) +# CHECK-NEXT: 4 12 0.50 * * shll (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrl (%rax) +# CHECK-NEXT: 1 1 0.50 sarl $7, %edi +# CHECK-NEXT: 1 1 0.50 shll $7, %edi +# CHECK-NEXT: 1 1 0.50 shrl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * sarl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shll $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrl $7, (%rax) +# CHECK-NEXT: 2 2 1.00 sarl %cl, %edi +# CHECK-NEXT: 2 2 1.00 shll %cl, %edi +# CHECK-NEXT: 2 2 1.00 shrl %cl, %edi +# CHECK-NEXT: 5 12 1.00 * * sarl %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shll %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shrl %cl, (%rax) +# CHECK-NEXT: 1 1 0.50 sarq %rdi +# CHECK-NEXT: 1 1 0.50 shlq %rdi +# CHECK-NEXT: 1 1 0.50 shrq %rdi +# CHECK-NEXT: 4 12 0.50 * * sarq (%rax) +# CHECK-NEXT: 4 12 0.50 * * shlq (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrq (%rax) +# CHECK-NEXT: 1 1 0.50 sarq $7, %rdi +# CHECK-NEXT: 1 1 0.50 shlq $7, %rdi +# CHECK-NEXT: 1 1 0.50 shrq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * sarq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shlq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * shrq $7, (%rax) +# CHECK-NEXT: 2 2 1.00 sarq %cl, %rdi +# CHECK-NEXT: 2 2 1.00 shlq %cl, %rdi +# CHECK-NEXT: 2 2 1.00 shrq %cl, %rdi +# CHECK-NEXT: 5 12 1.00 * * sarq %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shlq %cl, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shrq %cl, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbb $0, %al +# CHECK-NEXT: 1 1 0.50 sbbb $0, %dil +# CHECK-NEXT: 5 13 0.50 * * sbbb $0, (%rax) +# CHECK-NEXT: 5 13 0.50 * * lock sbbb $0, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbb $7, %al +# CHECK-NEXT: 1 1 0.50 sbbb $7, %dil +# CHECK-NEXT: 5 13 0.50 * * sbbb $7, (%rax) +# CHECK-NEXT: 5 13 0.50 * * lock sbbb $7, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbb %sil, %dil +# CHECK-NEXT: 6 13 0.60 * * sbbb %sil, (%rax) +# CHECK-NEXT: 6 13 0.60 * * lock sbbb %sil, (%rax) +# CHECK-NEXT: 2 6 0.50 * sbbb (%rax), %dil +# CHECK-NEXT: 1 1 0.50 sbbw $0, %ax +# CHECK-NEXT: 1 1 0.50 sbbw $0, %di +# CHECK-NEXT: 5 12 0.50 * * sbbw $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbw $0, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbw $511, %ax +# CHECK-NEXT: 1 1 0.50 sbbw $511, %di +# CHECK-NEXT: 5 12 0.50 * * sbbw $511, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbw $511, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbw $7, %di +# CHECK-NEXT: 5 12 0.50 * * sbbw $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbw $7, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbw %si, %di +# CHECK-NEXT: 6 12 0.60 * * sbbw %si, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock sbbw %si, (%rax) +# CHECK-NEXT: 2 6 0.50 * sbbw (%rax), %di +# CHECK-NEXT: 1 1 0.50 sbbl $0, %eax +# CHECK-NEXT: 1 1 0.50 sbbl $0, %edi +# CHECK-NEXT: 5 12 0.50 * * sbbl $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbl $0, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbl $665536, %eax +# CHECK-NEXT: 1 1 0.50 sbbl $665536, %edi +# CHECK-NEXT: 5 12 0.50 * * sbbl $665536, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbl $665536, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbl $7, %edi +# CHECK-NEXT: 5 12 0.50 * * sbbl $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbl $7, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbl %esi, %edi +# CHECK-NEXT: 6 12 0.60 * * sbbl %esi, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock sbbl %esi, (%rax) +# CHECK-NEXT: 2 6 0.50 * sbbl (%rax), %edi +# CHECK-NEXT: 1 1 0.50 sbbq $0, %rax +# CHECK-NEXT: 1 1 0.50 sbbq $0, %rdi +# CHECK-NEXT: 5 12 0.50 * * sbbq $0, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbq $0, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbq $665536, %rax +# CHECK-NEXT: 1 1 0.50 sbbq $665536, %rdi +# CHECK-NEXT: 5 12 0.50 * * sbbq $665536, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbq $665536, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbq $7, %rdi +# CHECK-NEXT: 5 12 0.50 * * sbbq $7, (%rax) +# CHECK-NEXT: 5 12 0.50 * * lock sbbq $7, (%rax) +# CHECK-NEXT: 1 1 0.50 sbbq %rsi, %rdi +# CHECK-NEXT: 6 12 0.60 * * sbbq %rsi, (%rax) +# CHECK-NEXT: 6 12 0.60 * * lock sbbq %rsi, (%rax) +# CHECK-NEXT: 2 6 0.50 * sbbq (%rax), %rdi +# CHECK-NEXT: 4 6 0.60 U scasb %es:(%rdi), %al +# CHECK-NEXT: 4 6 0.60 U scasw %es:(%rdi), %ax +# CHECK-NEXT: 4 6 0.60 U scasl %es:(%rdi), %eax +# CHECK-NEXT: 4 6 0.60 U scasq %es:(%rdi), %rax +# CHECK-NEXT: 2 2 1.00 seto %al +# CHECK-NEXT: 4 13 1.00 * seto (%rax) +# CHECK-NEXT: 2 2 1.00 setno %al +# CHECK-NEXT: 4 13 1.00 * setno (%rax) +# CHECK-NEXT: 2 2 1.00 setb %al +# CHECK-NEXT: 4 13 1.00 * setb (%rax) +# CHECK-NEXT: 2 2 1.00 setae %al +# CHECK-NEXT: 4 13 1.00 * setae (%rax) +# CHECK-NEXT: 2 2 1.00 sete %al +# CHECK-NEXT: 4 13 1.00 * sete (%rax) +# CHECK-NEXT: 2 2 1.00 setne %al +# CHECK-NEXT: 4 13 1.00 * setne (%rax) +# CHECK-NEXT: 2 2 1.00 seta %al +# CHECK-NEXT: 4 13 1.00 * seta (%rax) +# CHECK-NEXT: 2 2 1.00 setbe %al +# CHECK-NEXT: 4 13 1.00 * setbe (%rax) +# CHECK-NEXT: 2 2 1.00 sets %al +# CHECK-NEXT: 4 13 1.00 * sets (%rax) +# CHECK-NEXT: 2 2 1.00 setns %al +# CHECK-NEXT: 4 13 1.00 * setns (%rax) +# CHECK-NEXT: 2 2 1.00 setp %al +# CHECK-NEXT: 4 13 1.00 * setp (%rax) +# CHECK-NEXT: 2 2 1.00 setnp %al +# CHECK-NEXT: 4 13 1.00 * setnp (%rax) +# CHECK-NEXT: 2 2 1.00 setl %al +# CHECK-NEXT: 4 13 1.00 * setl (%rax) +# CHECK-NEXT: 2 2 1.00 setge %al +# CHECK-NEXT: 4 13 1.00 * setge (%rax) +# CHECK-NEXT: 2 2 1.00 setg %al +# CHECK-NEXT: 4 13 1.00 * setg (%rax) +# CHECK-NEXT: 2 2 1.00 setle %al +# CHECK-NEXT: 4 13 1.00 * setle (%rax) +# CHECK-NEXT: 3 5 1.00 shldw %cl, %si, %di +# CHECK-NEXT: 3 5 1.00 shrdw %cl, %si, %di +# CHECK-NEXT: 6 12 1.00 * * shldw %cl, %si, (%rax) +# CHECK-NEXT: 6 12 1.00 * * shrdw %cl, %si, (%rax) +# CHECK-NEXT: 1 3 1.00 shldw $7, %si, %di +# CHECK-NEXT: 1 3 1.00 shrdw $7, %si, %di +# CHECK-NEXT: 5 12 1.00 * * shldw $7, %si, (%rax) +# CHECK-NEXT: 5 13 1.00 * * shrdw $7, %si, (%rax) +# CHECK-NEXT: 3 5 1.00 shldl %cl, %esi, %edi +# CHECK-NEXT: 3 5 1.00 shrdl %cl, %esi, %edi +# CHECK-NEXT: 6 12 1.00 * * shldl %cl, %esi, (%rax) +# CHECK-NEXT: 6 12 1.00 * * shrdl %cl, %esi, (%rax) +# CHECK-NEXT: 1 3 1.00 shldl $7, %esi, %edi +# CHECK-NEXT: 1 3 1.00 shrdl $7, %esi, %edi +# CHECK-NEXT: 5 12 1.00 * * shldl $7, %esi, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shrdl $7, %esi, (%rax) +# CHECK-NEXT: 3 5 1.00 shldq %cl, %rsi, %rdi +# CHECK-NEXT: 3 5 1.00 shrdq %cl, %rsi, %rdi +# CHECK-NEXT: 6 12 1.00 * * shldq %cl, %rsi, (%rax) +# CHECK-NEXT: 6 12 1.00 * * shrdq %cl, %rsi, (%rax) +# CHECK-NEXT: 1 3 1.00 shldq $7, %rsi, %rdi +# CHECK-NEXT: 1 3 1.00 shrdq $7, %rsi, %rdi +# CHECK-NEXT: 5 12 1.00 * * shldq $7, %rsi, (%rax) +# CHECK-NEXT: 5 12 1.00 * * shrdq $7, %rsi, (%rax) +# CHECK-NEXT: 1 1 0.20 U stc +# CHECK-NEXT: 2 6 0.50 U std +# CHECK-NEXT: 4 8 0.50 U stosb %al, %es:(%rdi) +# CHECK-NEXT: 4 7 0.50 U stosw %ax, %es:(%rdi) +# CHECK-NEXT: 4 7 0.50 U stosl %eax, %es:(%rdi) +# CHECK-NEXT: 4 7 0.50 U stosq %rax, %es:(%rdi) +# CHECK-NEXT: 1 1 0.20 subb $7, %al +# CHECK-NEXT: 1 1 0.20 subb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * subb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock subb $7, (%rax) +# CHECK-NEXT: 1 1 0.20 subb %sil, %dil +# CHECK-NEXT: 4 13 0.50 * * subb %sil, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock subb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * subb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 subw $511, %ax +# CHECK-NEXT: 1 1 0.20 subw $511, %di +# CHECK-NEXT: 4 12 0.50 * * subw $511, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subw $511, (%rax) +# CHECK-NEXT: 1 1 0.20 subw $7, %di +# CHECK-NEXT: 4 12 0.50 * * subw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subw $7, (%rax) +# CHECK-NEXT: 1 1 0.20 subw %si, %di +# CHECK-NEXT: 4 12 0.50 * * subw %si, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * subw (%rax), %di +# CHECK-NEXT: 1 1 0.20 subl $665536, %eax +# CHECK-NEXT: 1 1 0.20 subl $665536, %edi +# CHECK-NEXT: 4 12 0.50 * * subl $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subl $665536, (%rax) +# CHECK-NEXT: 1 1 0.20 subl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * subl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subl $7, (%rax) +# CHECK-NEXT: 1 1 0.20 subl %esi, %edi +# CHECK-NEXT: 4 12 0.50 * * subl %esi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * subl (%rax), %edi +# CHECK-NEXT: 1 1 0.20 subq $665536, %rax +# CHECK-NEXT: 1 1 0.20 subq $665536, %rdi +# CHECK-NEXT: 4 12 0.50 * * subq $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subq $665536, (%rax) +# CHECK-NEXT: 0 1 0.00 subq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * subq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subq $7, (%rax) +# CHECK-NEXT: 1 1 0.20 subq %rsi, %rdi +# CHECK-NEXT: 4 12 0.50 * * subq %rsi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock subq %rsi, (%rax) +# CHECK-NEXT: 2 6 0.33 * subq (%rax), %rdi +# CHECK-NEXT: 1 2 0.20 testb $7, %al +# CHECK-NEXT: 1 2 0.20 testb $7, %dil +# CHECK-NEXT: 2 7 0.33 * testb $7, (%rax) +# CHECK-NEXT: 1 2 0.20 testb %sil, %dil +# CHECK-NEXT: 2 7 0.33 * testb %sil, (%rax) +# CHECK-NEXT: 1 1 0.20 testw $511, %ax +# CHECK-NEXT: 1 1 0.20 testw $511, %di +# CHECK-NEXT: 2 7 0.33 * testw $511, (%rax) +# CHECK-NEXT: 1 1 0.20 testw $7, %di +# CHECK-NEXT: 2 7 0.33 * testw $7, (%rax) +# CHECK-NEXT: 1 2 0.20 testw %si, %di +# CHECK-NEXT: 2 7 0.33 * testw %si, (%rax) +# CHECK-NEXT: 1 2 0.20 testl $665536, %eax +# CHECK-NEXT: 1 2 0.20 testl $665536, %edi +# CHECK-NEXT: 2 7 0.33 * testl $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 testl $7, %edi +# CHECK-NEXT: 2 7 0.33 * testl $7, (%rax) +# CHECK-NEXT: 1 2 0.20 testl %esi, %edi +# CHECK-NEXT: 2 7 0.33 * testl %esi, (%rax) +# CHECK-NEXT: 1 2 0.20 testq $665536, %rax +# CHECK-NEXT: 1 2 0.20 testq $665536, %rdi +# CHECK-NEXT: 2 7 0.33 * testq $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 testq $7, %rdi +# CHECK-NEXT: 2 7 0.33 * testq $7, (%rax) +# CHECK-NEXT: 1 2 0.20 testq %rsi, %rdi +# CHECK-NEXT: 2 7 0.33 * testq %rsi, (%rax) +# CHECK-NEXT: 1 100 0.25 * U ud2 +# CHECK-NEXT: 144 100 35.50 U wrmsr +# CHECK-NEXT: 3 2 0.60 xaddb %bl, %cl +# CHECK-NEXT: 5 13 0.50 * * xaddb %bl, (%rcx) +# CHECK-NEXT: 5 13 0.50 * * lock xaddb %bl, (%rcx) +# CHECK-NEXT: 3 2 0.60 xaddw %bx, %cx +# CHECK-NEXT: 5 12 0.50 * * xaddw %ax, (%rbx) +# CHECK-NEXT: 5 12 0.50 * * lock xaddw %ax, (%rbx) +# CHECK-NEXT: 3 2 0.60 xaddl %ebx, %ecx +# CHECK-NEXT: 5 12 0.50 * * xaddl %eax, (%rbx) +# CHECK-NEXT: 5 12 0.50 * * lock xaddl %eax, (%rbx) +# CHECK-NEXT: 3 2 0.60 xaddq %rbx, %rcx +# CHECK-NEXT: 5 12 0.50 * * xaddq %rax, (%rbx) +# CHECK-NEXT: 5 12 0.50 * * lock xaddq %rax, (%rbx) +# CHECK-NEXT: 3 2 0.60 xchgb %bl, %cl +# CHECK-NEXT: 8 40 1.00 * * xchgb %bl, (%rbx) +# CHECK-NEXT: 8 40 1.00 * * lock xchgb %bl, (%rbx) +# CHECK-NEXT: 3 2 0.60 xchgw %bx, %ax +# CHECK-NEXT: 3 2 0.60 xchgw %bx, %cx +# CHECK-NEXT: 8 39 1.00 * * xchgw %ax, (%rbx) +# CHECK-NEXT: 8 39 1.00 * * lock xchgw %ax, (%rbx) +# CHECK-NEXT: 3 2 0.60 xchgl %ebx, %eax +# CHECK-NEXT: 3 2 0.60 xchgl %ebx, %ecx +# CHECK-NEXT: 8 39 1.00 * * xchgl %eax, (%rbx) +# CHECK-NEXT: 8 39 1.00 * * lock xchgl %eax, (%rbx) +# CHECK-NEXT: 3 2 0.60 xchgq %rbx, %rax +# CHECK-NEXT: 3 2 0.60 xchgq %rbx, %rcx +# CHECK-NEXT: 9 39 1.20 * * xchgq %rax, (%rbx) +# CHECK-NEXT: 9 39 1.20 * * lock xchgq %rax, (%rbx) +# CHECK-NEXT: 3 7 0.40 * xlatb +# CHECK-NEXT: 1 2 0.20 xorb $7, %al +# CHECK-NEXT: 1 2 0.20 xorb $7, %dil +# CHECK-NEXT: 4 13 0.50 * * xorb $7, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock xorb $7, (%rax) +# CHECK-NEXT: 1 2 0.20 xorb %sil, %dil +# CHECK-NEXT: 4 13 0.50 * * xorb %sil, (%rax) +# CHECK-NEXT: 4 13 0.50 * * lock xorb %sil, (%rax) +# CHECK-NEXT: 2 6 0.33 * xorb (%rax), %dil +# CHECK-NEXT: 1 1 0.20 xorw $511, %ax +# CHECK-NEXT: 1 1 0.20 xorw $511, %di +# CHECK-NEXT: 4 12 0.50 * * xorw $511, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorw $511, (%rax) +# CHECK-NEXT: 1 2 0.20 xorw $7, %di +# CHECK-NEXT: 4 12 0.50 * * xorw $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorw $7, (%rax) +# CHECK-NEXT: 1 2 0.20 xorw %si, %di +# CHECK-NEXT: 4 12 0.50 * * xorw %si, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorw %si, (%rax) +# CHECK-NEXT: 2 6 0.33 * xorw (%rax), %di +# CHECK-NEXT: 1 2 0.20 xorl $665536, %eax +# CHECK-NEXT: 1 2 0.20 xorl $665536, %edi +# CHECK-NEXT: 4 12 0.50 * * xorl $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorl $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 xorl $7, %edi +# CHECK-NEXT: 4 12 0.50 * * xorl $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorl $7, (%rax) +# CHECK-NEXT: 1 2 0.20 xorl %esi, %edi +# CHECK-NEXT: 4 12 0.50 * * xorl %esi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorl %esi, (%rax) +# CHECK-NEXT: 2 6 0.33 * xorl (%rax), %edi +# CHECK-NEXT: 1 2 0.20 xorq $665536, %rax +# CHECK-NEXT: 1 2 0.20 xorq $665536, %rdi +# CHECK-NEXT: 4 12 0.50 * * xorq $665536, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorq $665536, (%rax) +# CHECK-NEXT: 1 2 0.20 xorq $7, %rdi +# CHECK-NEXT: 4 12 0.50 * * xorq $7, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorq $7, (%rax) +# CHECK-NEXT: 1 2 0.20 xorq %rsi, %rdi +# CHECK-NEXT: 4 12 0.50 * * xorq %rsi, (%rax) +# CHECK-NEXT: 4 12 0.50 * * lock xorq %rsi, (%rax) +# CHECK-NEXT: 2 7 0.33 * xorq (%rax), %rdi + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 949.92 794.58 213.00 213.00 202.50 599.75 793.42 203.00 203.00 202.50 191.33 213.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcb $0, %al +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcb $0, %dil +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcb $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcb $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcb $7, %al +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcb $7, %dil +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcb $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcb $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcb %sil, %dil +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - adcb %sil, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock adcb %sil, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcb (%rax), %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw $0, %ax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw $0, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcw $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcw $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw $511, %ax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw $511, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcw $511, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcw $511, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw $7, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcw $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcw $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcw %si, %di +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - adcw %si, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock adcw %si, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcw (%rax), %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl $0, %eax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl $0, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcl $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcl $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl $665536, %eax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl $665536, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcl $665536, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcl $665536, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl $7, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcl $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcl $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcl %esi, %edi +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - adcl %esi, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock adcl %esi, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcl (%rax), %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq $0, %rax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq $0, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcq $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcq $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq $665536, %rax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq $665536, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcq $665536, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcq $665536, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq $7, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - adcq $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock adcq $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - adcq %rsi, %rdi +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - adcq %rsi, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock adcq %rsi, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - adcq (%rax), %rdi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - addb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - addw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - addl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addq $665536, (%rax) +# CHECK-NEXT: - - - - - - - - - - - - - addq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - addq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - addq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock addq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - addq (%rax), %rdi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - andb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - andw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - andl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - andq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - andq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock andq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - andq (%rax), %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsfw %si, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsrw %si, %di +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsfw (%rax), %di +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsrw (%rax), %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsfl %esi, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsrl %esi, %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsfl (%rax), %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsrl (%rax), %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsfq %rsi, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bsrq %rsi, %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsfq (%rax), %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - bsrq (%rax), %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - bswapl %eax +# CHECK-NEXT: 0.50 1.00 - - - - 0.50 - - - - - - bswapq %rax +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btw %si, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcw %si, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrw %si, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsw %si, %di +# CHECK-NEXT: 1.80 2.47 0.33 0.33 - 1.47 1.80 - - - 1.47 0.33 - btw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btcw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btrw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btsw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btcw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btrw %si, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btsw %si, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btw $7, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcw $7, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrw $7, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsw $7, %di +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - btw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btcw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btrw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btsw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btcw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btrw $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btsw $7, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btl %esi, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcl %esi, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrl %esi, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsl %esi, %edi +# CHECK-NEXT: 1.80 2.47 0.33 0.33 - 1.47 1.80 - - - 1.47 0.33 - btl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btcl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btrl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - btsl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btcl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btrl %esi, (%rax) +# CHECK-NEXT: 1.60 2.27 0.33 0.33 0.50 1.27 1.60 0.50 0.50 0.50 1.27 0.33 - lock btsl %esi, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btl $7, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcl $7, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrl $7, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsl $7, %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - btl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btcl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btrl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btsl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btcl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btrl $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btsl $7, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btq %rsi, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcq %rsi, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrq %rsi, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsq %rsi, %rdi +# CHECK-NEXT: 2.00 2.00 0.33 0.33 - 1.00 2.00 - - - 1.00 0.33 - btq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - btcq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - btrq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - btsq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - lock btcq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - lock btrq %rsi, (%rax) +# CHECK-NEXT: 1.80 1.80 0.33 0.33 0.50 0.80 1.80 0.50 0.50 0.50 0.80 0.33 - lock btsq %rsi, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btq $7, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btcq $7, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btrq $7, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - btsq $7, %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - btq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btcq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btrq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - btsq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btcq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btrq $7, (%rax) +# CHECK-NEXT: - 1.00 0.33 0.33 0.50 - - 0.50 0.50 0.50 - 0.33 - lock btsq $7, (%rax) +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - cbtw +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - cwtl +# CHECK-NEXT: - 0.50 - - - 0.50 - - - - - - - cltq +# CHECK-NEXT: 0.70 0.20 - - - 0.20 0.70 - - - 0.20 - - cwtd +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cltd +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - cqto +# CHECK-NEXT: - - - - - - - - - - - - - clc +# CHECK-NEXT: 0.70 0.20 - - - 0.20 0.70 - - - 0.20 - - cld +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmc +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - cmpq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - cmpq (%rax), %rdi +# CHECK-NEXT: 1.00 1.00 0.67 0.67 - 1.00 1.00 - - - 1.00 0.67 - cmpsb %es:(%rdi), (%rsi) +# CHECK-NEXT: 1.00 1.00 0.67 0.67 - 1.00 1.00 - - - 1.00 0.67 - cmpsw %es:(%rdi), (%rsi) +# CHECK-NEXT: 1.00 1.00 0.67 0.67 - 1.00 1.00 - - - 1.00 0.67 - cmpsl %es:(%rdi), (%rsi) +# CHECK-NEXT: 1.00 1.00 0.67 0.67 - 1.00 1.00 - - - 1.00 0.67 - cmpsq %es:(%rdi), (%rsi) +# CHECK-NEXT: 1.60 0.60 - - - 0.60 1.60 - - - 0.60 - - cmpxchgb %cl, %bl +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - cmpxchgb %cl, (%rbx) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - lock cmpxchgb %cl, (%rbx) +# CHECK-NEXT: 1.60 0.60 - - - 0.60 1.60 - - - 0.60 - - cmpxchgw %cx, %bx +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - cmpxchgw %cx, (%rbx) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - lock cmpxchgw %cx, (%rbx) +# CHECK-NEXT: 1.60 0.60 - - - 0.60 1.60 - - - 0.60 - - cmpxchgl %ecx, %ebx +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - cmpxchgl %ecx, (%rbx) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - lock cmpxchgl %ecx, (%rbx) +# CHECK-NEXT: 1.60 0.60 - - - 0.60 1.60 - - - 0.60 - - cmpxchgq %rcx, %rbx +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - cmpxchgq %rcx, (%rbx) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - lock cmpxchgq %rcx, (%rbx) +# CHECK-NEXT: 7.50 6.50 - - 0.50 5.00 5.00 0.50 0.50 0.50 - - - cpuid +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - decb %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - decb (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock decb (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - decw %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - decw (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock decw (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - decl %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - decl (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock decl (%rax) +# CHECK-NEXT: - - - - - - - - - - - - - decq %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - decq (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock decq (%rax) +# CHECK-NEXT: - 3.00 - - - - - - - - - - - divb %dil +# CHECK-NEXT: - 3.00 - - - - - - - - - - - divb (%rax) +# CHECK-NEXT: 0.20 3.20 - - - 0.20 0.20 - - - 0.20 - - divw %si +# CHECK-NEXT: 0.20 3.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - divw (%rax) +# CHECK-NEXT: 0.20 3.20 - - - 0.20 0.20 - - - 0.20 - - divl %edx +# CHECK-NEXT: 0.20 3.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - divl (%rax) +# CHECK-NEXT: - 3.00 - - - - - - - - - - - divq %rcx +# CHECK-NEXT: - 3.00 0.33 0.33 - - - - - - - 0.33 - divq (%rax) +# CHECK-NEXT: 12.50 2.00 4.67 4.67 2.00 9.00 10.50 2.50 2.50 2.00 - 4.67 - enter $7, $4095 +# CHECK-NEXT: - 3.00 - - - - - - - - - - - idivb %dil +# CHECK-NEXT: - 3.00 - - - - - - - - - - - idivb (%rax) +# CHECK-NEXT: 0.20 3.20 - - - 0.20 0.20 - - - 0.20 - - idivw %si +# CHECK-NEXT: 0.20 3.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - idivw (%rax) +# CHECK-NEXT: 0.20 3.20 - - - 0.20 0.20 - - - 0.20 - - idivl %edx +# CHECK-NEXT: 0.20 3.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - idivl (%rax) +# CHECK-NEXT: - 3.00 - - - - - - - - - - - idivq %rcx +# CHECK-NEXT: - 3.00 0.33 0.33 - - - - - - - 0.33 - idivq (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imulb %dil +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imulb (%rax) +# CHECK-NEXT: 0.90 1.40 - - - 0.40 0.90 - - - 0.40 - - imulw %di +# CHECK-NEXT: 0.90 1.40 0.33 0.33 - 0.40 0.90 - - - 0.40 0.33 - imulw (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imulw %si, %di +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imulw (%rax), %di +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - imulw $511, %si, %di +# CHECK-NEXT: 0.20 1.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - imulw $511, (%rax), %di +# CHECK-NEXT: 0.20 1.20 - - - 0.20 0.20 - - - 0.20 - - imulw $7, %si, %di +# CHECK-NEXT: 0.20 1.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - imulw $7, (%rax), %di +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - imull %edi +# CHECK-NEXT: 0.70 1.20 0.33 0.33 - 0.20 0.70 - - - 0.20 0.33 - imull (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imull %esi, %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imull (%rax), %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imull $665536, %esi, %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imull $665536, (%rax), %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imull $7, %esi, %edi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imull $7, (%rax), %edi +# CHECK-NEXT: - 1.00 - - - 1.00 - - - - - - - imulq %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - imulq (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imulq %rsi, %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imulq (%rax), %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imulq $665536, %rsi, %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imulq $665536, (%rax), %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - imulq $7, %rsi, %rdi +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - imulq $7, (%rax), %rdi +# CHECK-NEXT: 20.70 20.87 2.67 2.67 - 21.87 13.70 - - - 1.87 2.67 - inb $7, %al +# CHECK-NEXT: 20.70 20.87 2.33 2.33 - 21.87 13.70 - - - 1.87 2.33 - inb %dx, %al +# CHECK-NEXT: 21.00 20.67 2.33 2.33 - 22.67 14.00 - - - 1.67 2.33 - inw $7, %ax +# CHECK-NEXT: 21.30 21.30 2.33 2.33 - 21.80 13.80 - - - 1.80 2.33 - inw %dx, %ax +# CHECK-NEXT: 22.20 22.87 3.33 3.33 - 21.87 15.20 - - - 1.87 3.33 - inl $7, %eax +# CHECK-NEXT: 22.80 23.47 3.67 3.67 - 23.47 15.80 - - - 2.47 3.67 - inl %dx, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - incb %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - incb (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock incb (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - incw %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - incw (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock incw (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - incl %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - incl (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock incl (%rax) +# CHECK-NEXT: - - - - - - - - - - - - - incq %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - incq (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock incq (%rax) +# CHECK-NEXT: 20.20 18.20 2.67 2.67 0.50 20.20 13.20 0.50 0.50 0.50 1.20 2.67 - insb %dx, %es:(%rdi) +# CHECK-NEXT: 20.97 18.47 3.00 3.00 0.50 20.80 13.63 0.50 0.50 0.50 1.13 3.00 - insw %dx, %es:(%rdi) +# CHECK-NEXT: 22.17 18.33 3.67 3.67 0.50 22.67 14.83 0.50 0.50 0.50 1.00 3.67 - insl %dx, %es:(%rdi) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - int $7 +# CHECK-NEXT: 9.80 7.47 - - 2.50 8.47 4.80 2.50 2.50 2.50 1.47 - - invlpg (%rax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - invlpga +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - lahf +# CHECK-NEXT: 0.40 0.40 0.33 0.33 - 0.40 0.40 - - - 0.40 0.33 - leave +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - lodsb (%rsi), %al +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - lodsw (%rsi), %ax +# CHECK-NEXT: 0.40 0.40 0.33 0.33 - 0.40 0.40 - - - 0.40 0.33 - lodsl (%rsi), %eax +# CHECK-NEXT: 0.40 0.40 0.33 0.33 - 0.40 0.40 - - - 0.40 0.33 - lodsq (%rsi), %rax +# CHECK-NEXT: 2.40 1.40 - - - 0.40 2.40 - - - 0.40 - - loop 0 +# CHECK-NEXT: 3.80 1.80 - - - 0.80 3.80 - - - 0.80 - - loope 0 +# CHECK-NEXT: 3.80 1.80 - - - 0.80 3.80 - - - 0.80 - - loopne 0 +# CHECK-NEXT: 0.80 0.80 0.33 0.33 0.50 0.80 0.80 0.50 0.50 0.50 0.80 0.33 - movsb (%rsi), %es:(%rdi) +# CHECK-NEXT: 0.80 0.80 0.33 0.33 0.50 0.80 0.80 0.50 0.50 0.50 0.80 0.33 - movsw (%rsi), %es:(%rdi) +# CHECK-NEXT: 0.80 0.80 0.33 0.33 0.50 0.80 0.80 0.50 0.50 0.50 0.80 0.33 - movsl (%rsi), %es:(%rdi) +# CHECK-NEXT: 0.80 0.80 0.33 0.33 0.50 0.80 0.80 0.50 0.50 0.50 0.80 0.33 - movsq (%rsi), %es:(%rdi) +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movsbw %al, %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - movzbw %al, %di +# CHECK-NEXT: - 0.33 0.33 0.33 - 0.33 - - - - 0.33 0.33 - movsbw (%rax), %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - movzbw (%rax), %di +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movsbl %al, %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - movzbl %al, %edi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movsbl (%rax), %edi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movzbl (%rax), %edi +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movsbq %al, %rdi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - movzbq %al, %rdi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movsbq (%rax), %rdi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movzbq (%rax), %rdi +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movswl %ax, %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - movzwl %ax, %edi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movswl (%rax), %edi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movzwl (%rax), %edi +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movswq %ax, %rdi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - movzwq %ax, %rdi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movswq (%rax), %rdi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movzwq (%rax), %rdi +# CHECK-NEXT: - 0.33 - - - 0.33 - - - - 0.33 - - movslq %eax, %rdi +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - movslq (%rax), %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - mulb %dil +# CHECK-NEXT: - 1.00 0.33 0.33 - - - - - - - 0.33 - mulb (%rax) +# CHECK-NEXT: 0.90 1.40 - - - 0.40 0.90 - - - 0.40 - - mulw %si +# CHECK-NEXT: 0.90 1.40 0.33 0.33 - 0.40 0.90 - - - 0.40 0.33 - mulw (%rax) +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - mull %edx +# CHECK-NEXT: 0.70 1.20 0.33 0.33 - 0.20 0.70 - - - 0.20 0.33 - mull (%rax) +# CHECK-NEXT: - 1.00 - - - 1.00 - - - - - - - mulq %rcx +# CHECK-NEXT: - 1.00 0.33 0.33 - 1.00 - - - - - 0.33 - mulq (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - negb %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - negb (%r8) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock negb (%r8) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - negw %si +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - negw (%r9) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock negw (%r9) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - negl %edx +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - negl (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock negl (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - negq %rcx +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - negq (%r10) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock negq (%r10) +# CHECK-NEXT: - - - - - - - - - - - - - nop +# CHECK-NEXT: - - - - - - - - - - - - - nopw %di +# CHECK-NEXT: - - - - - - - - - - - - - nopw (%rcx) +# CHECK-NEXT: - - - - - - - - - - - - - nopl %esi +# CHECK-NEXT: - - - - - - - - - - - - - nopl (%r8) +# CHECK-NEXT: - - - - - - - - - - - - - nopq %rdx +# CHECK-NEXT: - - - - - - - - - - - - - nopq (%r9) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - notb %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - notb (%r8) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock notb (%r8) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - notw %si +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - notw (%r9) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock notw (%r9) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - notl %edx +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - notl (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock notl (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - notq %rcx +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - notq (%r10) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock notq (%r10) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - orb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - orw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - orl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - orq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - orq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock orq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - orq (%rax), %rdi +# CHECK-NEXT: 19.00 16.00 1.67 1.67 0.50 16.50 13.50 0.50 0.50 0.50 1.00 1.67 - outb %al, $7 +# CHECK-NEXT: 19.00 16.00 1.67 1.67 0.50 16.00 14.00 0.50 0.50 0.50 1.00 1.67 - outb %al, %dx +# CHECK-NEXT: 21.30 15.80 2.33 2.33 0.50 17.30 14.80 0.50 0.50 0.50 0.80 2.33 - outw %ax, $7 +# CHECK-NEXT: 20.70 16.20 2.33 2.33 0.50 17.20 14.70 0.50 0.50 0.50 1.20 2.33 - outw %ax, %dx +# CHECK-NEXT: 22.30 15.80 3.00 3.00 0.50 19.30 15.80 0.50 0.50 0.50 0.80 3.00 - outl %eax, $7 +# CHECK-NEXT: 21.70 16.20 3.00 3.00 0.50 19.20 15.70 0.50 0.50 0.50 1.20 3.00 - outl %eax, %dx +# CHECK-NEXT: 20.70 17.20 2.33 2.33 0.50 18.20 13.70 0.50 0.50 0.50 1.20 2.33 - outsb (%rsi), %dx +# CHECK-NEXT: 21.00 17.50 2.67 2.67 0.50 19.00 14.50 0.50 0.50 0.50 1.00 2.67 - outsw (%rsi), %dx +# CHECK-NEXT: 22.20 17.20 3.33 3.33 0.50 21.20 15.20 0.50 0.50 0.50 1.20 3.33 - outsl (%rsi), %dx +# CHECK-NEXT: 0.50 - - - - 1.00 0.50 - - - - - - pause +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclb %dil +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrb %dil +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclb (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrb (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclb $7, %dil +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrb $7, %dil +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclb $7, (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrb $7, (%rax) +# CHECK-NEXT: 2.90 2.40 - - - 0.40 2.90 - - - 0.40 - - rclb %cl, %dil +# CHECK-NEXT: 2.60 3.60 - - - 0.60 2.60 - - - 0.60 - - rcrb %cl, %dil +# CHECK-NEXT: 2.70 2.20 0.33 0.33 0.50 0.20 2.70 0.50 0.50 0.50 0.20 0.33 - rclb %cl, (%rax) +# CHECK-NEXT: 2.40 3.40 0.33 0.33 0.50 0.40 2.40 0.50 0.50 0.50 0.40 0.33 - rcrb %cl, (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclw %di +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrw %di +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclw (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrw (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclw $7, %di +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrw $7, %di +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclw $7, (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrw $7, (%rax) +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rclw %cl, %di +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rcrw %cl, %di +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rclw %cl, (%rax) +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rcrw %cl, (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcll %edi +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrl %edi +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcll (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrl (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcll $7, %edi +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrl $7, %edi +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcll $7, (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrl $7, (%rax) +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rcll %cl, %edi +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rcrl %cl, %edi +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rcll %cl, (%rax) +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rcrl %cl, (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclq %rdi +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrq %rdi +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclq (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrq (%rax) +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rclq $7, %rdi +# CHECK-NEXT: 1.20 0.20 - - - 0.20 1.20 - - - 0.20 - - rcrq $7, %rdi +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rclq $7, (%rax) +# CHECK-NEXT: 1.20 0.20 0.33 0.33 0.50 0.20 1.20 0.50 0.50 0.50 0.20 0.33 - rcrq $7, (%rax) +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rclq %cl, %rdi +# CHECK-NEXT: 1.90 2.40 - - - 0.40 1.90 - - - 0.40 - - rcrq %cl, %rdi +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rclq %cl, (%rax) +# CHECK-NEXT: 1.90 2.40 0.33 0.33 0.50 0.40 1.90 0.50 0.50 0.50 0.40 0.33 - rcrq %cl, (%rax) +# CHECK-NEXT: 16.33 13.33 - - - 10.67 13.33 - - - 0.33 - - rdmsr +# CHECK-NEXT: 4.80 3.80 - - - 2.80 4.80 - - - 1.80 - - rdpmc +# CHECK-NEXT: 4.00 4.00 - - - 2.00 4.00 - - - 1.00 - - rdtsc +# CHECK-NEXT: 7.50 5.33 - - - 4.00 4.17 - - - - - - rdtscp +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolb %dil +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorb %dil +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolb (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorb (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolb $7, %dil +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorb $7, %dil +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolb $7, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorb $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolb %cl, %dil +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorb %cl, %dil +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolb %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorb %cl, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolw %di +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorw %di +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolw (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorw (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolw $7, %di +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorw $7, %di +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolw $7, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorw $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolw %cl, %di +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorw %cl, %di +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolw %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorw %cl, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - roll %edi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorl %edi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - roll (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorl (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - roll $7, %edi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorl $7, %edi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - roll $7, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorl $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - roll %cl, %edi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorl %cl, %edi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - roll %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorl %cl, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolq %rdi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorq %rdi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolq (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorq (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolq $7, %rdi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorq $7, %rdi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolq $7, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorq $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rolq %cl, %rdi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - rorq %cl, %rdi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rolq %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - rorq %cl, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sahf +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarb %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlb %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrb %dil +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarb (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlb (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrb (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarb $7, %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlb $7, %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrb $7, %dil +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarb $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlb $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrb $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sarb %cl, %dil +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shlb %cl, %dil +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shrb %cl, %dil +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - sarb %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shlb %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shrb %cl, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarw %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlw %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrw %di +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarw (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlw (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrw (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarw $7, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlw $7, %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrw $7, %di +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarw $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlw $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrw $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sarw %cl, %di +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shlw %cl, %di +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shrw %cl, %di +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - sarw %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shlw %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shrw %cl, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarl %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shll %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrl %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarl (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shll (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrl (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarl $7, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shll $7, %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrl $7, %edi +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarl $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shll $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrl $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sarl %cl, %edi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shll %cl, %edi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shrl %cl, %edi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - sarl %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shll %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shrl %cl, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarq %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlq %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrq %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarq (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlq (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrq (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sarq $7, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shlq $7, %rdi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - shrq $7, %rdi +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - sarq $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shlq $7, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 0.50 - 0.50 0.50 0.50 0.50 - 0.33 - shrq $7, (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sarq %cl, %rdi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shlq %cl, %rdi +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - shrq %cl, %rdi +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - sarq %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shlq %cl, (%rax) +# CHECK-NEXT: 1.00 - 0.33 0.33 0.50 - 1.00 0.50 0.50 0.50 - 0.33 - shrq %cl, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbb $0, %al +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbb $0, %dil +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbb $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbb $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbb $7, %al +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbb $7, %dil +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbb $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbb $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbb %sil, %dil +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - sbbb %sil, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock sbbb %sil, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sbbb (%rax), %dil +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw $0, %ax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw $0, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbw $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbw $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw $511, %ax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw $511, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbw $511, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbw $511, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw $7, %di +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbw $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbw $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbw %si, %di +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - sbbw %si, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock sbbw %si, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sbbw (%rax), %di +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl $0, %eax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl $0, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbl $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbl $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl $665536, %eax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl $665536, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbl $665536, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbl $665536, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl $7, %edi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbl $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbl $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbl %esi, %edi +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - sbbl %esi, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock sbbl %esi, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sbbl (%rax), %edi +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq $0, %rax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq $0, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbq $0, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbq $0, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq $665536, %rax +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq $665536, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbq $665536, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbq $665536, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq $7, %rdi +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - sbbq $7, (%rax) +# CHECK-NEXT: 0.70 0.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - lock sbbq $7, (%rax) +# CHECK-NEXT: 0.50 - - - - - 0.50 - - - - - - sbbq %rsi, %rdi +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - sbbq %rsi, (%rax) +# CHECK-NEXT: 0.90 0.40 0.33 0.33 0.50 0.40 0.90 0.50 0.50 0.50 0.40 0.33 - lock sbbq %rsi, (%rax) +# CHECK-NEXT: 0.50 - 0.33 0.33 - - 0.50 - - - - 0.33 - sbbq (%rax), %rdi +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - scasb %es:(%rdi), %al +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - scasw %es:(%rdi), %ax +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - scasl %es:(%rdi), %eax +# CHECK-NEXT: 0.60 0.60 0.33 0.33 - 0.60 0.60 - - - 0.60 0.33 - scasq %es:(%rdi), %rax +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - seto %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - seto (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setno %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setno (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setb %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setb (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setae %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setae (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sete %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - sete (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setne %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setne (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - seta %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - seta (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setbe %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setbe (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - sets %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - sets (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setns %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setns (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setp %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setp (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setnp %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setnp (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setl %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setl (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setge %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setge (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setg %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setg (%rax) +# CHECK-NEXT: 1.00 - - - - - 1.00 - - - - - - setle %al +# CHECK-NEXT: 1.00 - - - 0.50 - 1.00 0.50 0.50 0.50 - - - setle (%rax) +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shldw %cl, %si, %di +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shrdw %cl, %si, %di +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shldw %cl, %si, (%rax) +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shrdw %cl, %si, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shldw $7, %si, %di +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shrdw $7, %si, %di +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shldw $7, %si, (%rax) +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shrdw $7, %si, (%rax) +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shldl %cl, %esi, %edi +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shrdl %cl, %esi, %edi +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shldl %cl, %esi, (%rax) +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shrdl %cl, %esi, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shldl $7, %esi, %edi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shrdl $7, %esi, %edi +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shldl $7, %esi, (%rax) +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shrdl $7, %esi, (%rax) +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shldq %cl, %rsi, %rdi +# CHECK-NEXT: 0.70 1.20 - - - 0.20 0.70 - - - 0.20 - - shrdq %cl, %rsi, %rdi +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shldq %cl, %rsi, (%rax) +# CHECK-NEXT: 0.70 1.20 0.33 0.33 0.50 0.20 0.70 0.50 0.50 0.50 0.20 0.33 - shrdq %cl, %rsi, (%rax) +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shldq $7, %rsi, %rdi +# CHECK-NEXT: - 1.00 - - - - - - - - - - - shrdq $7, %rsi, %rdi +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shldq $7, %rsi, (%rax) +# CHECK-NEXT: 0.20 1.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - shrdq $7, %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - stc +# CHECK-NEXT: 0.70 0.20 - - - 0.20 0.70 - - - 0.20 - - std +# CHECK-NEXT: 0.40 0.40 - - 0.50 0.40 0.40 0.50 0.50 0.50 0.40 - - stosb %al, %es:(%rdi) +# CHECK-NEXT: 0.40 0.40 - - 0.50 0.40 0.40 0.50 0.50 0.50 0.40 - - stosw %ax, %es:(%rdi) +# CHECK-NEXT: 0.40 0.40 - - 0.50 0.40 0.40 0.50 0.50 0.50 0.40 - - stosl %eax, %es:(%rdi) +# CHECK-NEXT: 0.40 0.40 - - 0.50 0.40 0.40 0.50 0.50 0.50 0.40 - - stosq %rax, %es:(%rdi) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - subb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - subw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - subl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subq $665536, (%rax) +# CHECK-NEXT: - - - - - - - - - - - - - subq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - subq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - subq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock subq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - subq (%rax), %rdi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - testq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - testq %rsi, (%rax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - ud2 +# CHECK-NEXT: 52.00 31.50 - - 0.50 27.00 31.50 0.50 0.50 0.50 - - - wrmsr +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xaddb %bl, %cl +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - xaddb %bl, (%rcx) +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - lock xaddb %bl, (%rcx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xaddw %bx, %cx +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - xaddw %ax, (%rbx) +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - lock xaddw %ax, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xaddl %ebx, %ecx +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - xaddl %eax, (%rbx) +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - lock xaddl %eax, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xaddq %rbx, %rcx +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - xaddq %rax, (%rbx) +# CHECK-NEXT: 0.40 0.40 0.33 0.33 0.50 0.40 0.40 0.50 0.50 0.50 0.40 0.33 - lock xaddq %rax, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgb %bl, %cl +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - xchgb %bl, (%rbx) +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - lock xchgb %bl, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgw %bx, %ax +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgw %bx, %cx +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - xchgw %ax, (%rbx) +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - lock xchgw %ax, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgl %ebx, %eax +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgl %ebx, %ecx +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - xchgl %eax, (%rbx) +# CHECK-NEXT: 1.30 0.80 0.33 0.33 0.50 0.80 1.30 0.50 0.50 0.50 0.80 0.33 - lock xchgl %eax, (%rbx) +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgq %rbx, %rax +# CHECK-NEXT: 0.60 0.60 - - - 0.60 0.60 - - - 0.60 - - xchgq %rbx, %rcx +# CHECK-NEXT: 1.50 1.00 0.33 0.33 0.50 1.00 1.50 0.50 0.50 0.50 1.00 0.33 - xchgq %rax, (%rbx) +# CHECK-NEXT: 1.50 1.00 0.33 0.33 0.50 1.00 1.50 0.50 0.50 0.50 1.00 0.33 - lock xchgq %rax, (%rbx) +# CHECK-NEXT: 0.40 0.40 0.33 0.33 - 0.40 0.40 - - - 0.40 0.33 - xlatb +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorb $7, %al +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorb $7, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorb $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorb %sil, %dil +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorb %sil, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - xorb (%rax), %dil +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorw $511, %ax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorw $511, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorw $511, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorw $7, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorw $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorw %si, %di +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorw %si, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - xorw (%rax), %di +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorl $665536, %eax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorl $665536, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorl $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorl $7, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorl $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorl %esi, %edi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorl %esi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - xorl (%rax), %edi +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorq $665536, %rax +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorq $665536, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorq $665536, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorq $7, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorq $7, (%rax) +# CHECK-NEXT: 0.20 0.20 - - - 0.20 0.20 - - - 0.20 - - xorq %rsi, %rdi +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - xorq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 0.50 0.20 0.20 0.50 0.50 0.50 0.20 0.33 - lock xorq %rsi, (%rax) +# CHECK-NEXT: 0.20 0.20 0.33 0.33 - 0.20 0.20 - - - 0.20 0.33 - xorq (%rax), %rdi diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x87.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x87.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-x87.s @@ -0,0 +1,526 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +f2xm1 + +fabs + +fadd %st, %st(1) +fadd %st(2) +fadds (%ecx) +faddl (%ecx) +faddp %st(1) +faddp %st(2) +fiadds (%ecx) +fiaddl (%ecx) + +fbld (%ecx) +fbstp (%eax) + +fchs + +fnclex + +fcmovb %st(1), %st +fcmovbe %st(1), %st +fcmove %st(1), %st +fcmovnb %st(1), %st +fcmovnbe %st(1), %st +fcmovne %st(1), %st +fcmovnu %st(1), %st +fcmovu %st(1), %st + +fcom %st(1) +fcom %st(3) +fcoms (%ecx) +fcoml (%eax) +fcomp %st(1) +fcomp %st(3) +fcomps (%ecx) +fcompl (%eax) +fcompp + +fcomi %st(3) +fcompi %st(3) + +fcos + +fdecstp + +fdiv %st, %st(1) +fdiv %st(2) +fdivs (%ecx) +fdivl (%eax) +fdivp %st(1) +fdivp %st(2) +fidivs (%ecx) +fidivl (%eax) + +fdivr %st, %st(1) +fdivr %st(2) +fdivrs (%ecx) +fdivrl (%eax) +fdivrp %st(1) +fdivrp %st(2) +fidivrs (%ecx) +fidivrl (%eax) + +ffree %st(0) + +ficoms (%ecx) +ficoml (%eax) +ficomps (%ecx) +ficompl (%eax) + +filds (%edx) +fildl (%ecx) +fildll (%eax) + +fincstp + +fninit + +fists (%edx) +fistl (%ecx) +fistps (%edx) +fistpl (%ecx) +fistpll (%eax) + +fisttps (%edx) +fisttpl (%ecx) +fisttpll (%eax) + +fld %st(0) +flds (%edx) +fldl (%ecx) +fldt (%eax) + +fldcw (%eax) +fldenv (%eax) + +fld1 +fldl2e +fldl2t +fldlg2 +fldln2 +fldpi +fldz + +fmul %st, %st(1) +fmul %st(2) +fmuls (%ecx) +fmull (%eax) +fmulp %st(1) +fmulp %st(2) +fimuls (%ecx) +fimull (%eax) + +fnop + +fpatan + +fprem +fprem1 + +fptan + +frndint + +frstor (%eax) + +fnsave (%eax) + +fscale + +fsin + +fsincos + +fsqrt + +fst %st(0) +fsts (%edx) +fstl (%ecx) +fstp %st(0) +fstpl (%edx) +fstpl (%ecx) +fstpt (%eax) + +fnstcw (%eax) +fnstenv (%eax) +fnstsw (%eax) + +frstor (%eax) +fsave (%eax) + +fsub %st, %st(1) +fsub %st(2) +fsubs (%ecx) +fsubl (%eax) +fsubp %st(1) +fsubp %st(2) +fisubs (%ecx) +fisubl (%eax) + +fsubr %st, %st(1) +fsubr %st(2) +fsubrs (%ecx) +fsubrl (%eax) +fsubrp %st(1) +fsubrp %st(2) +fisubrs (%ecx) +fisubrl (%eax) + +ftst + +fucom %st(1) +fucom %st(3) +fucomp %st(1) +fucomp %st(3) +fucompp + +fucomi %st(3) +fucompi %st(3) + +fwait + +fxam + +fxch %st(1) +fxch %st(3) + +fxrstor (%eax) +fxsave (%eax) + +fxtract + +fyl2x +fyl2xp1 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 100 0.25 U f2xm1 +# CHECK-NEXT: 1 1 1.00 U fabs +# CHECK-NEXT: 1 3 1.00 U fadd %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U fadd %st(2), %st +# CHECK-NEXT: 2 10 1.00 * U fadds (%ecx) +# CHECK-NEXT: 2 10 1.00 * U faddl (%ecx) +# CHECK-NEXT: 1 3 1.00 U faddp %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U faddp %st, %st(2) +# CHECK-NEXT: 3 13 2.00 * U fiadds (%ecx) +# CHECK-NEXT: 3 13 2.00 * U fiaddl (%ecx) +# CHECK-NEXT: 1 100 0.25 * U fbld (%ecx) +# CHECK-NEXT: 2 1 1.00 * U fbstp (%eax) +# CHECK-NEXT: 1 1 1.00 U fchs +# CHECK-NEXT: 4 4 1.00 U fnclex +# CHECK-NEXT: 1 3 1.00 U fcmovb %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovbe %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmove %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovnb %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovnbe %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovne %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovnu %st(1), %st +# CHECK-NEXT: 1 3 1.00 U fcmovu %st(1), %st +# CHECK-NEXT: 1 1 1.00 U fcom %st(1) +# CHECK-NEXT: 1 1 1.00 U fcom %st(3) +# CHECK-NEXT: 2 8 1.00 * U fcoms (%ecx) +# CHECK-NEXT: 2 8 1.00 * U fcoml (%eax) +# CHECK-NEXT: 1 1 1.00 U fcomp %st(1) +# CHECK-NEXT: 1 1 1.00 U fcomp %st(3) +# CHECK-NEXT: 2 8 1.00 * U fcomps (%ecx) +# CHECK-NEXT: 2 8 1.00 * U fcompl (%eax) +# CHECK-NEXT: 1 100 0.25 U fcompp +# CHECK-NEXT: 1 1 1.00 U fcomi %st(3), %st +# CHECK-NEXT: 1 1 1.00 U fcompi %st(3), %st +# CHECK-NEXT: 1 100 0.25 U fcos +# CHECK-NEXT: 2 2 1.00 U fdecstp +# CHECK-NEXT: 1 15 1.00 U fdiv %st, %st(1) +# CHECK-NEXT: 1 20 1.00 U fdiv %st(2), %st +# CHECK-NEXT: 2 22 1.00 * U fdivs (%ecx) +# CHECK-NEXT: 2 22 1.00 * U fdivl (%eax) +# CHECK-NEXT: 1 15 1.00 U fdivp %st, %st(1) +# CHECK-NEXT: 1 15 1.00 U fdivp %st, %st(2) +# CHECK-NEXT: 3 25 1.00 * U fidivs (%ecx) +# CHECK-NEXT: 3 25 1.00 * U fidivl (%eax) +# CHECK-NEXT: 1 20 1.00 U fdivr %st, %st(1) +# CHECK-NEXT: 1 15 1.00 U fdivr %st(2), %st +# CHECK-NEXT: 2 27 1.00 * U fdivrs (%ecx) +# CHECK-NEXT: 2 27 1.00 * U fdivrl (%eax) +# CHECK-NEXT: 1 20 1.00 U fdivrp %st, %st(1) +# CHECK-NEXT: 1 20 1.00 U fdivrp %st, %st(2) +# CHECK-NEXT: 3 30 1.00 * U fidivrs (%ecx) +# CHECK-NEXT: 3 30 1.00 * U fidivrl (%eax) +# CHECK-NEXT: 1 100 0.25 U ffree %st(0) +# CHECK-NEXT: 3 11 2.00 * U ficoms (%ecx) +# CHECK-NEXT: 3 11 2.00 * U ficoml (%eax) +# CHECK-NEXT: 3 11 2.00 * U ficomps (%ecx) +# CHECK-NEXT: 3 11 2.00 * U ficompl (%eax) +# CHECK-NEXT: 2 10 1.00 * U filds (%edx) +# CHECK-NEXT: 2 10 1.00 * U fildl (%ecx) +# CHECK-NEXT: 2 10 1.00 * U fildll (%eax) +# CHECK-NEXT: 1 1 0.50 U fincstp +# CHECK-NEXT: 15 75 6.00 U fninit +# CHECK-NEXT: 3 4 1.00 * U fists (%edx) +# CHECK-NEXT: 3 4 1.00 * U fistl (%ecx) +# CHECK-NEXT: 3 4 1.00 * U fistps (%edx) +# CHECK-NEXT: 3 4 1.00 * U fistpl (%ecx) +# CHECK-NEXT: 3 4 1.00 * U fistpll (%eax) +# CHECK-NEXT: 3 4 1.00 * U fisttps (%edx) +# CHECK-NEXT: 3 4 1.00 * U fisttpl (%ecx) +# CHECK-NEXT: 3 4 1.00 * U fisttpll (%eax) +# CHECK-NEXT: 1 1 0.25 U fld %st(0) +# CHECK-NEXT: 1 7 0.33 * U flds (%edx) +# CHECK-NEXT: 1 7 0.33 * U fldl (%ecx) +# CHECK-NEXT: 1 7 0.33 * U fldt (%eax) +# CHECK-NEXT: 3 7 1.00 * U fldcw (%eax) +# CHECK-NEXT: 64 62 19.50 * U fldenv (%eax) +# CHECK-NEXT: 2 1 1.00 U fld1 +# CHECK-NEXT: 2 1 1.00 U fldl2e +# CHECK-NEXT: 2 1 1.00 U fldl2t +# CHECK-NEXT: 2 1 1.00 U fldlg2 +# CHECK-NEXT: 2 1 1.00 U fldln2 +# CHECK-NEXT: 2 1 1.00 U fldpi +# CHECK-NEXT: 1 1 0.50 U fldz +# CHECK-NEXT: 1 4 1.00 U fmul %st, %st(1) +# CHECK-NEXT: 1 4 1.00 U fmul %st(2), %st +# CHECK-NEXT: 2 11 1.00 * U fmuls (%ecx) +# CHECK-NEXT: 2 11 1.00 * U fmull (%eax) +# CHECK-NEXT: 1 4 1.00 U fmulp %st, %st(1) +# CHECK-NEXT: 1 4 1.00 U fmulp %st, %st(2) +# CHECK-NEXT: 3 14 1.00 * U fimuls (%ecx) +# CHECK-NEXT: 3 14 1.00 * U fimull (%eax) +# CHECK-NEXT: 1 1 0.50 U fnop +# CHECK-NEXT: 1 100 0.25 U fpatan +# CHECK-NEXT: 1 100 0.25 U fprem +# CHECK-NEXT: 1 100 0.25 U fprem1 +# CHECK-NEXT: 1 100 0.25 U fptan +# CHECK-NEXT: 1 100 0.25 U frndint +# CHECK-NEXT: 1 100 0.25 * U frstor (%eax) +# CHECK-NEXT: 1 100 0.25 * U fnsave (%eax) +# CHECK-NEXT: 1 100 0.25 U fscale +# CHECK-NEXT: 1 100 0.25 U fsin +# CHECK-NEXT: 1 100 0.25 U fsincos +# CHECK-NEXT: 1 21 7.00 U fsqrt +# CHECK-NEXT: 1 1 0.25 U fst %st(0) +# CHECK-NEXT: 1 1 1.00 * U fsts (%edx) +# CHECK-NEXT: 1 1 1.00 * U fstl (%ecx) +# CHECK-NEXT: 1 1 0.25 U fstp %st(0) +# CHECK-NEXT: 2 1 1.00 * U fstpl (%edx) +# CHECK-NEXT: 2 1 1.00 * U fstpl (%ecx) +# CHECK-NEXT: 2 1 1.00 * U fstpt (%eax) +# CHECK-NEXT: 3 2 1.00 * U fnstcw (%eax) +# CHECK-NEXT: 100 106 30.00 * U fnstenv (%eax) +# CHECK-NEXT: 3 3 1.00 * U fnstsw (%eax) +# CHECK-NEXT: 1 100 0.25 * U frstor (%eax) +# CHECK-NEXT: 2 2 0.50 U wait +# CHECK-NEXT: 1 100 0.25 * U fnsave (%eax) +# CHECK-NEXT: 1 3 1.00 U fsub %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U fsub %st(2), %st +# CHECK-NEXT: 2 10 1.00 * U fsubs (%ecx) +# CHECK-NEXT: 2 10 1.00 * U fsubl (%eax) +# CHECK-NEXT: 1 3 1.00 U fsubp %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U fsubp %st, %st(2) +# CHECK-NEXT: 3 13 2.00 * U fisubs (%ecx) +# CHECK-NEXT: 3 13 2.00 * U fisubl (%eax) +# CHECK-NEXT: 1 3 1.00 U fsubr %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U fsubr %st(2), %st +# CHECK-NEXT: 2 10 1.00 * U fsubrs (%ecx) +# CHECK-NEXT: 2 10 1.00 * U fsubrl (%eax) +# CHECK-NEXT: 1 3 1.00 U fsubrp %st, %st(1) +# CHECK-NEXT: 1 3 1.00 U fsubrp %st, %st(2) +# CHECK-NEXT: 3 13 2.00 * U fisubrs (%ecx) +# CHECK-NEXT: 3 13 2.00 * U fisubrl (%eax) +# CHECK-NEXT: 1 2 1.00 U ftst +# CHECK-NEXT: 1 1 1.00 U fucom %st(1) +# CHECK-NEXT: 1 1 1.00 U fucom %st(3) +# CHECK-NEXT: 1 1 1.00 U fucomp %st(1) +# CHECK-NEXT: 1 1 1.00 U fucomp %st(3) +# CHECK-NEXT: 1 2 1.00 U fucompp +# CHECK-NEXT: 1 1 1.00 U fucomi %st(3), %st +# CHECK-NEXT: 1 1 1.00 U fucompi %st(3), %st +# CHECK-NEXT: 2 2 0.50 U wait +# CHECK-NEXT: 1 2 1.00 U fxam +# CHECK-NEXT: 15 17 4.00 U fxch %st(1) +# CHECK-NEXT: 15 17 4.00 U fxch %st(3) +# CHECK-NEXT: 90 63 26.67 * * U fxrstor (%eax) +# CHECK-NEXT: 110 100 19.00 * * U fxsave (%eax) +# CHECK-NEXT: 1 100 0.25 U fxtract +# CHECK-NEXT: 1 100 0.25 U fyl2x +# CHECK-NEXT: 1 100 0.25 U fyl2xp1 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 105.00 36.50 70.33 70.33 78.50 133.00 48.50 19.00 19.00 32.50 1.00 27.33 7.00 + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - f2xm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fabs +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fadd %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fadd %st(2), %st +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fadds (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - faddl (%ecx) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - faddp %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - faddp %st, %st(2) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fiadds (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fiaddl (%ecx) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fbld (%ecx) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fbstp (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fchs +# CHECK-NEXT: 1.00 1.00 - - - 1.00 1.00 - - - - - - fnclex +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovb %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovbe %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmove %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovnb %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovnbe %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovne %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovnu %st(1), %st +# CHECK-NEXT: - 1.00 - - - - - - - - - - - fcmovu %st(1), %st +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcom %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcom %st(3) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fcoms (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fcoml (%eax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcomp %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcomp %st(3) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fcomps (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fcompl (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fcompp +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcomi %st(3), %st +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fcompi %st(3), %st +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fcos +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fdecstp +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdiv %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdiv %st(2), %st +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fdivs (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fdivl (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivp %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivp %st, %st(2) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fidivs (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fidivl (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivr %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivr %st(2), %st +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fdivrs (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fdivrl (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivrp %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fdivrp %st, %st(2) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fidivrs (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fidivrl (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - ffree %st(0) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - ficoms (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - ficoml (%eax) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - ficomps (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - ficompl (%eax) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - filds (%edx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fildl (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fildll (%eax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - fincstp +# CHECK-NEXT: 3.00 1.50 - - - 9.00 1.50 - - - - - - fninit +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fists (%edx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fistl (%ecx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fistps (%edx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fistpl (%ecx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fistpll (%eax) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fisttps (%edx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fisttpl (%ecx) +# CHECK-NEXT: - - - - 1.50 1.00 - - - 0.50 - - - fisttpll (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fld %st(0) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - flds (%edx) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - fldl (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - - - - - - - 0.33 - fldt (%eax) +# CHECK-NEXT: 1.50 - 0.33 0.33 - 0.50 - - - - - 0.33 - fldcw (%eax) +# CHECK-NEXT: 9.50 - 22.17 22.17 - 2.50 5.00 - - - - 2.67 - fldenv (%eax) +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fld1 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fldl2e +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fldl2t +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fldlg2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fldln2 +# CHECK-NEXT: 1.00 - - - - 1.00 - - - - - - - fldpi +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - fldz +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fmul %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fmul %st(2), %st +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fmuls (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - - - - - - - 0.33 - fmull (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fmulp %st, %st(1) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fmulp %st, %st(2) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fimuls (%ecx) +# CHECK-NEXT: 1.00 - 0.33 0.33 - 1.00 - - - - - 0.33 - fimull (%eax) +# CHECK-NEXT: 0.50 - - - - 0.50 - - - - - - - fnop +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fpatan +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fprem +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fprem1 +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fptan +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - frndint +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - frstor (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fnsave (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fscale +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fsin +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fsincos +# CHECK-NEXT: 1.00 - - - - - - - - - - - 7.00 fsqrt +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fst %st(0) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fsts (%edx) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fstl (%ecx) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fstp %st(0) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fstpl (%edx) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fstpl (%ecx) +# CHECK-NEXT: - - - - 1.50 - - - - 0.50 - - - fstpt (%eax) +# CHECK-NEXT: - - - - 1.50 - 1.00 - - 0.50 - - - fnstcw (%eax) +# CHECK-NEXT: 22.25 3.75 - - 35.50 18.75 14.25 - - 5.50 - - - fnstenv (%eax) +# CHECK-NEXT: 1.00 - - - 1.50 - - - - 0.50 - - - fnstsw (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - frstor (%eax) +# CHECK-NEXT: 0.50 0.50 - - - 0.50 0.50 - - - - - - wait +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fnsave (%eax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsub %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsub %st(2), %st +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fsubs (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fsubl (%eax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubp %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubp %st, %st(2) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fisubs (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fisubl (%eax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubr %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubr %st(2), %st +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fsubrs (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 1.00 - - - - - 0.33 - fsubrl (%eax) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubrp %st, %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fsubrp %st, %st(2) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fisubrs (%ecx) +# CHECK-NEXT: - - 0.33 0.33 - 2.00 - - - - - 0.33 - fisubrl (%eax) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - ftst +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucom %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucom %st(3) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucomp %st(1) +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucomp %st(3) +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fucompp +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucomi %st(3), %st +# CHECK-NEXT: - - - - - 1.00 - - - - - - - fucompi %st(3), %st +# CHECK-NEXT: 0.50 0.50 - - - 0.50 0.50 - - - - - - wait +# CHECK-NEXT: 1.00 - - - - - - - - - - - - fxam +# CHECK-NEXT: 4.00 2.00 - - - 4.00 5.00 - - - - - - fxch %st(1) +# CHECK-NEXT: 4.00 2.00 - - - 4.00 5.00 - - - - - - fxch %st(3) +# CHECK-NEXT: 5.50 0.50 34.50 34.50 - 1.00 3.00 - - - - 11.00 - fxrstor (%eax) +# CHECK-NEXT: 8.00 11.00 0.67 0.67 19.00 6.00 6.00 19.00 19.00 19.00 1.00 0.67 - fxsave (%eax) +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fxtract +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fyl2x +# CHECK-NEXT: 0.25 0.25 - - - 0.25 0.25 - - - - - - fyl2xp1 diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-xsave.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-xsave.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/resources-xsave.s @@ -0,0 +1,54 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -instruction-tables < %s | FileCheck %s + +xgetbv + +xrstor (%rax) + +xrstors (%rax) + +xsave (%rax) + +xsetbv + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 23 4 5.00 U xgetbv +# CHECK-NEXT: 31 37 10.50 * * U xrstor (%rax) +# CHECK-NEXT: 31 37 10.50 * * U xrstors (%rax) +# CHECK-NEXT: 140 42 33.50 * * U xsave (%rax) +# CHECK-NEXT: 54 5 10.80 * * U xsetbv + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 61.50 61.17 23.00 23.00 0.50 43.33 56.67 0.50 0.50 0.50 6.33 2.00 - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: 6.40 6.40 - - - 2.40 6.40 - - - 1.40 - - xgetbv +# CHECK-NEXT: - 1.00 10.83 10.83 - - 8.00 - - - - 0.33 - xrstor (%rax) +# CHECK-NEXT: - 1.00 10.83 10.83 - - 8.00 - - - - 0.33 - xrstors (%rax) +# CHECK-NEXT: 41.50 38.50 1.33 1.33 0.50 32.00 22.00 0.50 0.50 0.50 - 1.33 - xsave (%rax) +# CHECK-NEXT: 13.60 14.27 - - - 8.93 12.27 - - - 4.93 - - xsetbv diff --git a/llvm/test/tools/llvm-mca/X86/SapphireRapids/zero-idioms.s b/llvm/test/tools/llvm-mca/X86/SapphireRapids/zero-idioms.s new file mode 100644 --- /dev/null +++ b/llvm/test/tools/llvm-mca/X86/SapphireRapids/zero-idioms.s @@ -0,0 +1,782 @@ +# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py +# RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sapphirerapids -timeline -register-file-stats -iterations=1 < %s | FileCheck %s + +# On SKX, renamer-based zeroing does not work for: +# - 16 and 8-bit GPRs +# - MMX +# - ANDN variants + +subl %eax, %eax +subq %rax, %rax +xorl %eax, %eax +xorq %rax, %rax + +pcmpgtb %mm2, %mm2 +pcmpgtd %mm2, %mm2 +# pcmpgtq %mm2, %mm2 # invalid operand for instruction +pcmpgtw %mm2, %mm2 + +pcmpgtb %xmm2, %xmm2 +pcmpgtd %xmm2, %xmm2 +pcmpgtq %xmm2, %xmm2 +pcmpgtw %xmm2, %xmm2 + +vpcmpgtb %xmm3, %xmm3, %xmm3 +vpcmpgtd %xmm3, %xmm3, %xmm3 +vpcmpgtq %xmm3, %xmm3, %xmm3 +vpcmpgtw %xmm3, %xmm3, %xmm3 + +vpcmpgtb %xmm3, %xmm3, %xmm5 +vpcmpgtd %xmm3, %xmm3, %xmm5 +vpcmpgtq %xmm3, %xmm3, %xmm5 +vpcmpgtw %xmm3, %xmm3, %xmm5 + +vpcmpgtb %ymm3, %ymm3, %ymm3 +vpcmpgtd %ymm3, %ymm3, %ymm3 +vpcmpgtq %ymm3, %ymm3, %ymm3 +vpcmpgtw %ymm3, %ymm3, %ymm3 + +vpcmpgtb %ymm3, %ymm3, %ymm5 +vpcmpgtd %ymm3, %ymm3, %ymm5 +vpcmpgtq %ymm3, %ymm3, %ymm5 +vpcmpgtw %ymm3, %ymm3, %ymm5 + +psubb %mm2, %mm2 +psubd %mm2, %mm2 +psubq %mm2, %mm2 +psubw %mm2, %mm2 +psubb %xmm2, %xmm2 +psubd %xmm2, %xmm2 +psubq %xmm2, %xmm2 +psubw %xmm2, %xmm2 +vpsubb %xmm3, %xmm3, %xmm3 +vpsubd %xmm3, %xmm3, %xmm3 +vpsubq %xmm3, %xmm3, %xmm3 +vpsubw %xmm3, %xmm3, %xmm3 +vpsubb %ymm3, %ymm3, %ymm3 +vpsubd %ymm3, %ymm3, %ymm3 +vpsubq %ymm3, %ymm3, %ymm3 +vpsubw %ymm3, %ymm3, %ymm3 + +vpsubb %xmm3, %xmm3, %xmm5 +vpsubd %xmm3, %xmm3, %xmm5 +vpsubq %xmm3, %xmm3, %xmm5 +vpsubw %xmm3, %xmm3, %xmm5 +vpsubb %ymm3, %ymm3, %ymm5 +vpsubd %ymm3, %ymm3, %ymm5 +vpsubq %ymm3, %ymm3, %ymm5 +vpsubw %ymm3, %ymm3, %ymm5 + +vpsubb %xmm19, %xmm19, %xmm19 +vpsubd %xmm19, %xmm19, %xmm19 +vpsubq %xmm19, %xmm19, %xmm19 +vpsubw %xmm19, %xmm19, %xmm19 +vpsubb %ymm19, %ymm19, %ymm19 +vpsubd %ymm19, %ymm19, %ymm19 +vpsubq %ymm19, %ymm19, %ymm19 +vpsubw %ymm19, %ymm19, %ymm19 +vpsubb %zmm19, %zmm19, %zmm19 +vpsubd %zmm19, %zmm19, %zmm19 +vpsubq %zmm19, %zmm19, %zmm19 +vpsubw %zmm19, %zmm19, %zmm19 + +vpsubb %xmm19, %xmm19, %xmm21 +vpsubd %xmm19, %xmm19, %xmm21 +vpsubq %xmm19, %xmm19, %xmm21 +vpsubw %xmm19, %xmm19, %xmm21 +vpsubb %ymm19, %ymm19, %ymm21 +vpsubd %ymm19, %ymm19, %ymm21 +vpsubq %ymm19, %ymm19, %ymm21 +vpsubw %ymm19, %ymm19, %ymm21 +vpsubb %zmm19, %zmm19, %zmm21 +vpsubd %zmm19, %zmm19, %zmm21 +vpsubq %zmm19, %zmm19, %zmm21 +vpsubw %zmm19, %zmm19, %zmm21 + +andnps %xmm0, %xmm0 +andnpd %xmm1, %xmm1 +vandnps %xmm2, %xmm2, %xmm2 +vandnpd %xmm1, %xmm1, %xmm1 +vandnps %ymm2, %ymm2, %ymm2 +vandnpd %ymm1, %ymm1, %ymm1 +vandnps %zmm2, %zmm2, %zmm2 +vandnpd %zmm1, %zmm1, %zmm1 +pandn %mm2, %mm2 +pandn %xmm2, %xmm2 +vpandn %xmm3, %xmm3, %xmm3 +vpandn %ymm3, %ymm3, %ymm3 + +vpandnd %xmm19, %xmm19, %xmm19 +vpandnq %xmm19, %xmm19, %xmm19 +vpandnd %ymm19, %ymm19, %ymm19 +vpandnq %ymm19, %ymm19, %ymm19 +vpandnd %zmm19, %zmm19, %zmm19 +vpandnq %zmm19, %zmm19, %zmm19 + +vandnps %xmm2, %xmm2, %xmm5 +vandnpd %xmm1, %xmm1, %xmm5 +vpandn %xmm3, %xmm3, %xmm5 +vandnps %ymm2, %ymm2, %ymm5 +vandnpd %ymm1, %ymm1, %ymm5 +vpandn %ymm3, %ymm3, %ymm5 +vandnps %zmm2, %zmm2, %zmm5 +vandnpd %zmm1, %zmm1, %zmm5 + +vpandnd %xmm19, %xmm19, %xmm21 +vpandnq %xmm19, %xmm19, %xmm21 +vpandnd %ymm19, %ymm19, %ymm21 +vpandnq %ymm19, %ymm19, %ymm21 +vpandnd %zmm19, %zmm19, %zmm21 +vpandnq %zmm19, %zmm19, %zmm21 + +xorps %xmm0, %xmm0 +xorpd %xmm1, %xmm1 +vxorps %xmm2, %xmm2, %xmm2 +vxorpd %xmm1, %xmm1, %xmm1 +vxorps %ymm2, %ymm2, %ymm2 +vxorpd %ymm1, %ymm1, %ymm1 +vxorps %zmm2, %zmm2, %zmm2 +vxorpd %zmm1, %zmm1, %zmm1 +pxor %mm2, %mm2 +pxor %xmm2, %xmm2 +vpxor %xmm3, %xmm3, %xmm3 +vpxor %ymm3, %ymm3, %ymm3 + +vpxord %xmm19, %xmm19, %xmm19 +vpxorq %xmm19, %xmm19, %xmm19 +vpxord %ymm19, %ymm19, %ymm19 +vpxorq %ymm19, %ymm19, %ymm19 +vpxord %zmm19, %zmm19, %zmm19 +vpxorq %zmm19, %zmm19, %zmm19 + +vxorps %xmm4, %xmm4, %xmm5 +vxorpd %xmm1, %xmm1, %xmm3 +vxorps %ymm4, %ymm4, %ymm5 +vxorpd %ymm1, %ymm1, %ymm3 +vxorps %zmm4, %zmm4, %zmm5 +vxorpd %zmm1, %zmm1, %zmm3 +vpxor %xmm3, %xmm3, %xmm5 +vpxor %ymm3, %ymm3, %ymm5 + +vpxord %xmm19, %xmm19, %xmm21 +vpxorq %xmm19, %xmm19, %xmm21 +vpxord %ymm19, %ymm19, %ymm21 +vpxorq %ymm19, %ymm19, %ymm21 +vpxord %zmm19, %zmm19, %zmm21 +vpxorq %zmm19, %zmm19, %zmm21 + +# CHECK: Iterations: 1 +# CHECK-NEXT: Instructions: 139 +# CHECK-NEXT: Total Cycles: 52 +# CHECK-NEXT: Total uOps: 139 + +# CHECK: Dispatch Width: 6 +# CHECK-NEXT: uOps Per Cycle: 2.67 +# CHECK-NEXT: IPC: 2.67 +# CHECK-NEXT: Block RThroughput: 27.3 + +# CHECK: Instruction Info: +# CHECK-NEXT: [1]: #uOps +# CHECK-NEXT: [2]: Latency +# CHECK-NEXT: [3]: RThroughput +# CHECK-NEXT: [4]: MayLoad +# CHECK-NEXT: [5]: MayStore +# CHECK-NEXT: [6]: HasSideEffects (U) + +# CHECK: [1] [2] [3] [4] [5] [6] Instructions: +# CHECK-NEXT: 1 1 0.20 subl %eax, %eax +# CHECK-NEXT: 1 1 0.20 subq %rax, %rax +# CHECK-NEXT: 1 2 0.20 xorl %eax, %eax +# CHECK-NEXT: 1 2 0.20 xorq %rax, %rax +# CHECK-NEXT: 1 1 1.00 pcmpgtb %mm2, %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpgtd %mm2, %mm2 +# CHECK-NEXT: 1 1 1.00 pcmpgtw %mm2, %mm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtb %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtd %xmm2, %xmm2 +# CHECK-NEXT: 1 3 1.00 pcmpgtq %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.50 pcmpgtw %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.50 vpcmpgtb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.50 vpcmpgtd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 3 1.00 vpcmpgtq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.50 vpcmpgtw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.50 psubb %mm2, %mm2 +# CHECK-NEXT: 1 1 0.50 psubd %mm2, %mm2 +# CHECK-NEXT: 1 1 0.50 psubq %mm2, %mm2 +# CHECK-NEXT: 1 1 0.50 psubw %mm2, %mm2 +# CHECK-NEXT: 1 1 0.33 psubb %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 psubd %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 psubq %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 psubw %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpsubb %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpsubw %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.33 vpsubb %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpsubd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpsubq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpsubw %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpsubb %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.33 vpsubd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.33 vpsubq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.33 vpsubw %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.50 vpsubb %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.50 vpsubd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.50 vpsubq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.50 vpsubw %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.33 andnps %xmm0, %xmm0 +# CHECK-NEXT: 1 1 0.33 andnpd %xmm1, %xmm1 +# CHECK-NEXT: 1 1 0.33 vandnps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 1 1 0.33 vandnps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: 1 1 0.50 vandnps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 1 1 0.50 vandnpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 1 1 0.50 pandn %mm2, %mm2 +# CHECK-NEXT: 1 1 0.33 pandn %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpandn %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpandn %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpandnd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpandnq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpandnd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpandnq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpandnd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpandnq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.33 vandnps %xmm2, %xmm2, %xmm5 +# CHECK-NEXT: 1 1 0.33 vandnpd %xmm1, %xmm1, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpandn %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vandnps %ymm2, %ymm2, %ymm5 +# CHECK-NEXT: 1 1 0.33 vandnpd %ymm1, %ymm1, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpandn %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.50 vandnps %zmm2, %zmm2, %zmm5 +# CHECK-NEXT: 1 1 0.50 vandnpd %zmm1, %zmm1, %zmm5 +# CHECK-NEXT: 1 1 0.33 vpandnd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpandnq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpandnd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.33 vpandnq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.50 vpandnd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.50 vpandnq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.33 xorps %xmm0, %xmm0 +# CHECK-NEXT: 1 1 0.33 xorpd %xmm1, %xmm1 +# CHECK-NEXT: 1 1 0.33 vxorps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 1 1 0.33 vxorps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: 1 1 0.50 vxorps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 1 1 0.50 vxorpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 1 1 0.50 pxor %mm2, %mm2 +# CHECK-NEXT: 1 1 0.33 pxor %xmm2, %xmm2 +# CHECK-NEXT: 1 1 0.33 vpxor %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1 1 0.33 vpxor %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 1 1 0.33 vpxord %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpxorq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1 1 0.33 vpxord %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.33 vpxorq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1 1 0.50 vpxord %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.50 vpxorq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1 1 0.33 vxorps %xmm4, %xmm4, %xmm5 +# CHECK-NEXT: 1 1 0.33 vxorpd %xmm1, %xmm1, %xmm3 +# CHECK-NEXT: 1 1 0.33 vxorps %ymm4, %ymm4, %ymm5 +# CHECK-NEXT: 1 1 0.33 vxorpd %ymm1, %ymm1, %ymm3 +# CHECK-NEXT: 1 1 0.50 vxorps %zmm4, %zmm4, %zmm5 +# CHECK-NEXT: 1 1 0.50 vxorpd %zmm1, %zmm1, %zmm3 +# CHECK-NEXT: 1 1 0.33 vpxor %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1 1 0.33 vpxor %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1 1 0.33 vpxord %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpxorq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1 1 0.33 vpxord %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.33 vpxorq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1 1 0.50 vpxord %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 1 0.50 vpxorq %zmm19, %zmm19, %zmm21 + +# CHECK: Register File statistics: +# CHECK-NEXT: Total number of mappings created: 143 +# CHECK-NEXT: Max number of mappings used: 101 + +# CHECK: Resources: +# CHECK-NEXT: [0] - SPRPort00 +# CHECK-NEXT: [1] - SPRPort01 +# CHECK-NEXT: [2] - SPRPort02 +# CHECK-NEXT: [3] - SPRPort03 +# CHECK-NEXT: [4] - SPRPort04 +# CHECK-NEXT: [5] - SPRPort05 +# CHECK-NEXT: [6] - SPRPort06 +# CHECK-NEXT: [7] - SPRPort07 +# CHECK-NEXT: [8] - SPRPort08 +# CHECK-NEXT: [9] - SPRPort09 +# CHECK-NEXT: [10] - SPRPort10 +# CHECK-NEXT: [11] - SPRPort11 +# CHECK-NEXT: [12] - SPRPortInvalid + +# CHECK: Resource pressure per iteration: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] +# CHECK-NEXT: 46.00 44.00 - - - 46.00 1.00 - - - 2.00 - - + +# CHECK: Resource pressure by instruction: +# CHECK-NEXT: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] Instructions: +# CHECK-NEXT: - - - - - - - - - - 1.00 - - subl %eax, %eax +# CHECK-NEXT: - - - - - - 1.00 - - - - - - subq %rax, %rax +# CHECK-NEXT: - - - - - 1.00 - - - - - - - xorl %eax, %eax +# CHECK-NEXT: - - - - - - - - - - 1.00 - - xorq %rax, %rax +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtb %mm2, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtd %mm2, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pcmpgtw %mm2, %mm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pcmpgtb %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pcmpgtd %xmm2, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - pcmpgtq %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pcmpgtw %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpcmpgtd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpcmpgtd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpcmpgtw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpcmpgtd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpcmpgtq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpcmpgtw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psubb %mm2, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubd %mm2, %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psubq %mm2, %mm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - psubw %mm2, %mm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - psubb %xmm2, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psubd %xmm2, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psubq %xmm2, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - psubw %xmm2, %xmm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubb %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubw %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubb %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubw %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubb %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubw %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubb %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubw %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubb %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpsubq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubw %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubb %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpsubq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpsubw %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - andnps %xmm0, %xmm0 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - andnpd %xmm1, %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vandnpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pandn %mm2, %mm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - pandn %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpandn %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandn %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpandnd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vandnps %xmm2, %xmm2, %xmm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vandnpd %xmm1, %xmm1, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpandn %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vandnps %ymm2, %ymm2, %ymm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vandnpd %ymm1, %ymm1, %ymm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpandn %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnps %zmm2, %zmm2, %zmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vandnpd %zmm1, %zmm1, %zmm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpandnq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpandnd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpandnd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpandnq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - xorps %xmm0, %xmm0 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - xorpd %xmm1, %xmm1 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vxorps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vxorps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vxorpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - pxor %mm2, %mm2 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - pxor %xmm2, %xmm2 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpxor %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpxor %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpxord %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpxorq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxord %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxorq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxord %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxorq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorps %xmm4, %xmm4, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vxorpd %xmm1, %xmm1, %xmm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorps %ymm4, %ymm4, %ymm5 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vxorpd %ymm1, %ymm1, %ymm3 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vxorps %zmm4, %zmm4, %zmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vxorpd %zmm1, %zmm1, %zmm3 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpxor %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpxor %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxord %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: - 1.00 - - - - - - - - - - - vpxorq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpxord %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxorq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 1.00 - - - - - - - - - - - - vpxord %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: - - - - - 1.00 - - - - - - - vpxorq %zmm19, %zmm19, %zmm21 + +# CHECK: Timeline view: +# CHECK-NEXT: 0123456789 0123456789 01 +# CHECK-NEXT: Index 0123456789 0123456789 0123456789 + +# CHECK: [0,0] DeER . . . . . . . . . .. subl %eax, %eax +# CHECK-NEXT: [0,1] D=eER. . . . . . . . . .. subq %rax, %rax +# CHECK-NEXT: [0,2] D==eeER . . . . . . . . .. xorl %eax, %eax +# CHECK-NEXT: [0,3] D====eeER . . . . . . . . .. xorq %rax, %rax +# CHECK-NEXT: [0,4] DeE-----R . . . . . . . . .. pcmpgtb %mm2, %mm2 +# CHECK-NEXT: [0,5] D=eE----R . . . . . . . . .. pcmpgtd %mm2, %mm2 +# CHECK-NEXT: [0,6] .D=eE---R . . . . . . . . .. pcmpgtw %mm2, %mm2 +# CHECK-NEXT: [0,7] .DeE----R . . . . . . . . .. pcmpgtb %xmm2, %xmm2 +# CHECK-NEXT: [0,8] .D=eE---R . . . . . . . . .. pcmpgtd %xmm2, %xmm2 +# CHECK-NEXT: [0,9] .D==eeeER . . . . . . . . .. pcmpgtq %xmm2, %xmm2 +# CHECK-NEXT: [0,10] .D=====eER. . . . . . . . .. pcmpgtw %xmm2, %xmm2 +# CHECK-NEXT: [0,11] .D==eE---R. . . . . . . . .. vpcmpgtb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,12] . D==eE--R. . . . . . . . .. vpcmpgtd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,13] . D===eeeER . . . . . . . .. vpcmpgtq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,14] . D======eER . . . . . . . .. vpcmpgtw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,15] . D=======eER . . . . . . . .. vpcmpgtb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,16] . D=======eER . . . . . . . .. vpcmpgtd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,17] . D=======eeeER. . . . . . . .. vpcmpgtq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,18] . D=======eE-R. . . . . . . .. vpcmpgtw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,19] . D=======eE-R. . . . . . . .. vpcmpgtb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,20] . D========eER. . . . . . . .. vpcmpgtd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,21] . D=========eeeER . . . . . . .. vpcmpgtq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,22] . D============eER . . . . . . .. vpcmpgtw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,23] . D=============eER. . . . . . .. vpcmpgtb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,24] . D============eER. . . . . . .. vpcmpgtd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,25] . D============eeeER . . . . . .. vpcmpgtq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,26] . D=============eE-R . . . . . .. vpcmpgtw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,27] . DeE--------------R . . . . . .. psubb %mm2, %mm2 +# CHECK-NEXT: [0,28] . D=eE-------------R . . . . . .. psubd %mm2, %mm2 +# CHECK-NEXT: [0,29] . D==eE------------R . . . . . .. psubq %mm2, %mm2 +# CHECK-NEXT: [0,30] . D==eE-----------R . . . . . .. psubw %mm2, %mm2 +# CHECK-NEXT: [0,31] . D==eE-----------R . . . . . .. psubb %xmm2, %xmm2 +# CHECK-NEXT: [0,32] . D===eE----------R . . . . . .. psubd %xmm2, %xmm2 +# CHECK-NEXT: [0,33] . D=====eE--------R . . . . . .. psubq %xmm2, %xmm2 +# CHECK-NEXT: [0,34] . D======eE-------R . . . . . .. psubw %xmm2, %xmm2 +# CHECK-NEXT: [0,35] . D============eE-R . . . . . .. vpsubb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,36] . .D============eER . . . . . .. vpsubd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,37] . .D=============eER . . . . . .. vpsubq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,38] . .D==============eER . . . . . .. vpsubw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,39] . .D===============eER. . . . . .. vpsubb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,40] . .D================eER . . . . .. vpsubd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,41] . .D=================eER . . . . .. vpsubq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,42] . . D=================eER . . . . .. vpsubw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,43] . . D==================eER . . . . .. vpsubb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,44] . . D==================eER . . . . .. vpsubd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,45] . . D==================eER . . . . .. vpsubq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,46] . . D===================eER. . . . .. vpsubw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,47] . . D===================eER. . . . .. vpsubb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,48] . . D==================eER. . . . .. vpsubd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,49] . . D===================eER . . . .. vpsubq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,50] . . D===================eER . . . .. vpsubw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,51] . . DeE-------------------R . . . .. vpsubb %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,52] . . D===eE----------------R . . . .. vpsubd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,53] . . D====eE---------------R . . . .. vpsubq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,54] . . D====eE--------------R . . . .. vpsubw %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,55] . . D=====eE-------------R . . . .. vpsubb %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,56] . . D======eE------------R . . . .. vpsubd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,57] . . D========eE----------R . . . .. vpsubq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,58] . . D=========eE---------R . . . .. vpsubw %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,59] . . D==========eE--------R . . . .. vpsubb %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,60] . . D==========eE-------R . . . .. vpsubd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,61] . . D===========eE------R . . . .. vpsubq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,62] . . D============eE-----R . . . .. vpsubw %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,63] . . D=============eE----R . . . .. vpsubb %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,64] . . D=============eE----R . . . .. vpsubd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,65] . . D==============eE---R . . . .. vpsubq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,66] . . .D=============eE---R . . . .. vpsubw %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,67] . . .D================eER . . . .. vpsubb %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,68] . . .D=================eER . . . .. vpsubd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,69] . . .D=================eER . . . .. vpsubq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,70] . . .D=================eER . . . .. vpsubw %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,71] . . .D==================eER . . . .. vpsubb %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,72] . . . D=================eER . . . .. vpsubd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,73] . . . D==================eER . . . .. vpsubq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,74] . . . D==================eER . . . .. vpsubw %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,75] . . . DeE------------------R . . . .. andnps %xmm0, %xmm0 +# CHECK-NEXT: [0,76] . . . D=eE-----------------R . . . .. andnpd %xmm1, %xmm1 +# CHECK-NEXT: [0,77] . . . D=eE-----------------R . . . .. vandnps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: [0,78] . . . D=eE----------------R . . . .. vandnpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: [0,79] . . . D=eE----------------R . . . .. vandnps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: [0,80] . . . D==eE---------------R . . . .. vandnpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: [0,81] . . . D=========eE--------R . . . .. vandnps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: [0,82] . . . D=====eE------------R . . . .. vandnpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: [0,83] . . . D==================eER. . . .. pandn %mm2, %mm2 +# CHECK-NEXT: [0,84] . . . D===============eE--R. . . .. pandn %xmm2, %xmm2 +# CHECK-NEXT: [0,85] . . . D================eE-R. . . .. vpandn %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,86] . . . D=================eER. . . .. vpandn %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,87] . . . D=================eER. . . .. vpandnd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,88] . . . D==================eER . . .. vpandnq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,89] . . . D===================eER . . .. vpandnd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,90] . . . D===================eER . . .. vpandnq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,91] . . . D====================eER . . .. vpandnd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,92] . . . D=====================eER. . .. vpandnq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,93] . . . D=================eE----R. . .. vandnps %xmm2, %xmm2, %xmm5 +# CHECK-NEXT: [0,94] . . . D====eE-----------------R. . .. vandnpd %xmm1, %xmm1, %xmm5 +# CHECK-NEXT: [0,95] . . . D=================eE----R. . .. vpandn %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,96] . . . .D=================eE---R. . .. vandnps %ymm2, %ymm2, %ymm5 +# CHECK-NEXT: [0,97] . . . .D====eE----------------R. . .. vandnpd %ymm1, %ymm1, %ymm5 +# CHECK-NEXT: [0,98] . . . .D=================eE---R. . .. vpandn %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,99] . . . .D==================eE--R. . .. vandnps %zmm2, %zmm2, %zmm5 +# CHECK-NEXT: [0,100] . . . .D===================eE-R. . .. vandnpd %zmm1, %zmm1, %zmm5 +# CHECK-NEXT: [0,101] . . . .D=====================eER . .. vpandnd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,102] . . . . D====================eER . .. vpandnq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,103] . . . . D====================eER . .. vpandnd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,104] . . . . D=====================eER . .. vpandnq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,105] . . . . D=====================eER . .. vpandnd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,106] . . . . D======================eER . .. vpandnq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,107] . . . . D=================eE-----R . .. xorps %xmm0, %xmm0 +# CHECK-NEXT: [0,108] . . . . D===eE------------------R . .. xorpd %xmm1, %xmm1 +# CHECK-NEXT: [0,109] . . . . D=================eE----R . .. vxorps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: [0,110] . . . . D==================eE---R . .. vxorpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: [0,111] . . . . D==================eE---R . .. vxorps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: [0,112] . . . . D====================eE-R . .. vxorpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: [0,113] . . . . D======================eER . .. vxorps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: [0,114] . . . . D====================eE-R . .. vxorpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: [0,115] . . . . D=====================eER . .. pxor %mm2, %mm2 +# CHECK-NEXT: [0,116] . . . . D======================eER. .. pxor %xmm2, %xmm2 +# CHECK-NEXT: [0,117] . . . . D====================eE--R. .. vpxor %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: [0,118] . . . . D======================eER. .. vpxor %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: [0,119] . . . . D=====================eE-R. .. vpxord %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,120] . . . . D=====================eER. .. vpxorq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: [0,121] . . . . D======================eER .. vpxord %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,122] . . . . D=======================eER .. vpxorq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: [0,123] . . . . D========================eER .. vpxord %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,124] . . . . D=========================eER .. vpxorq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: [0,125] . . . . D======================eE---R .. vxorps %xmm4, %xmm4, %xmm5 +# CHECK-NEXT: [0,126] . . . . .D=====================eE---R .. vxorpd %xmm1, %xmm1, %xmm3 +# CHECK-NEXT: [0,127] . . . . .D======================eE--R .. vxorps %ymm4, %ymm4, %ymm5 +# CHECK-NEXT: [0,128] . . . . .D=======================eE-R .. vxorpd %ymm1, %ymm1, %ymm3 +# CHECK-NEXT: [0,129] . . . . .D=======================eE-R .. vxorps %zmm4, %zmm4, %zmm5 +# CHECK-NEXT: [0,130] . . . . .D======================eE--R .. vxorpd %zmm1, %zmm1, %zmm3 +# CHECK-NEXT: [0,131] . . . . .D========================eER .. vpxor %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: [0,132] . . . . . D=======================eER .. vpxor %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: [0,133] . . . . . D========================eER.. vpxord %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,134] . . . . . D========================eER.. vpxorq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: [0,135] . . . . . D========================eER.. vpxord %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,136] . . . . . D=========================eER. vpxorq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: [0,137] . . . . . D=========================eER. vpxord %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: [0,138] . . . . . D=========================eER vpxorq %zmm19, %zmm19, %zmm21 + +# CHECK: Average Wait times (based on the timeline view): +# CHECK-NEXT: [0]: Executions +# CHECK-NEXT: [1]: Average time spent waiting in a scheduler's queue +# CHECK-NEXT: [2]: Average time spent waiting in a scheduler's queue while ready +# CHECK-NEXT: [3]: Average time elapsed from WB until retire stage + +# CHECK: [0] [1] [2] [3] +# CHECK-NEXT: 0. 1 1.0 1.0 0.0 subl %eax, %eax +# CHECK-NEXT: 1. 1 2.0 0.0 0.0 subq %rax, %rax +# CHECK-NEXT: 2. 1 3.0 0.0 0.0 xorl %eax, %eax +# CHECK-NEXT: 3. 1 5.0 0.0 0.0 xorq %rax, %rax +# CHECK-NEXT: 4. 1 1.0 1.0 5.0 pcmpgtb %mm2, %mm2 +# CHECK-NEXT: 5. 1 2.0 0.0 4.0 pcmpgtd %mm2, %mm2 +# CHECK-NEXT: 6. 1 2.0 0.0 3.0 pcmpgtw %mm2, %mm2 +# CHECK-NEXT: 7. 1 1.0 1.0 4.0 pcmpgtb %xmm2, %xmm2 +# CHECK-NEXT: 8. 1 2.0 0.0 3.0 pcmpgtd %xmm2, %xmm2 +# CHECK-NEXT: 9. 1 3.0 0.0 0.0 pcmpgtq %xmm2, %xmm2 +# CHECK-NEXT: 10. 1 6.0 0.0 0.0 pcmpgtw %xmm2, %xmm2 +# CHECK-NEXT: 11. 1 3.0 3.0 3.0 vpcmpgtb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 12. 1 3.0 0.0 2.0 vpcmpgtd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 13. 1 4.0 0.0 0.0 vpcmpgtq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 14. 1 7.0 0.0 0.0 vpcmpgtw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 15. 1 8.0 0.0 0.0 vpcmpgtb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 16. 1 8.0 0.0 0.0 vpcmpgtd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 17. 1 8.0 0.0 0.0 vpcmpgtq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 18. 1 8.0 1.0 1.0 vpcmpgtw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 19. 1 8.0 1.0 1.0 vpcmpgtb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 20. 1 9.0 0.0 0.0 vpcmpgtd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 21. 1 10.0 0.0 0.0 vpcmpgtq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 22. 1 13.0 0.0 0.0 vpcmpgtw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 23. 1 14.0 0.0 0.0 vpcmpgtb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 24. 1 13.0 0.0 0.0 vpcmpgtd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 25. 1 13.0 0.0 0.0 vpcmpgtq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 26. 1 14.0 1.0 1.0 vpcmpgtw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 27. 1 1.0 1.0 14.0 psubb %mm2, %mm2 +# CHECK-NEXT: 28. 1 2.0 0.0 13.0 psubd %mm2, %mm2 +# CHECK-NEXT: 29. 1 3.0 0.0 12.0 psubq %mm2, %mm2 +# CHECK-NEXT: 30. 1 3.0 0.0 11.0 psubw %mm2, %mm2 +# CHECK-NEXT: 31. 1 3.0 0.0 11.0 psubb %xmm2, %xmm2 +# CHECK-NEXT: 32. 1 4.0 0.0 10.0 psubd %xmm2, %xmm2 +# CHECK-NEXT: 33. 1 6.0 1.0 8.0 psubq %xmm2, %xmm2 +# CHECK-NEXT: 34. 1 7.0 0.0 7.0 psubw %xmm2, %xmm2 +# CHECK-NEXT: 35. 1 13.0 1.0 1.0 vpsubb %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 36. 1 13.0 0.0 0.0 vpsubd %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 37. 1 14.0 0.0 0.0 vpsubq %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 38. 1 15.0 0.0 0.0 vpsubw %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 39. 1 16.0 0.0 0.0 vpsubb %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 40. 1 17.0 0.0 0.0 vpsubd %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 41. 1 18.0 0.0 0.0 vpsubq %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 42. 1 18.0 0.0 0.0 vpsubw %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 43. 1 19.0 0.0 0.0 vpsubb %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 44. 1 19.0 0.0 0.0 vpsubd %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 45. 1 19.0 0.0 0.0 vpsubq %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 46. 1 20.0 1.0 0.0 vpsubw %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 47. 1 20.0 1.0 0.0 vpsubb %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 48. 1 19.0 1.0 0.0 vpsubd %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 49. 1 20.0 2.0 0.0 vpsubq %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 50. 1 20.0 2.0 0.0 vpsubw %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 51. 1 1.0 1.0 19.0 vpsubb %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 52. 1 4.0 2.0 16.0 vpsubd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 53. 1 5.0 0.0 15.0 vpsubq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 54. 1 5.0 0.0 14.0 vpsubw %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 55. 1 6.0 0.0 13.0 vpsubb %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 56. 1 7.0 0.0 12.0 vpsubd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 57. 1 9.0 1.0 10.0 vpsubq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 58. 1 10.0 0.0 9.0 vpsubw %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 59. 1 11.0 0.0 8.0 vpsubb %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 60. 1 11.0 0.0 7.0 vpsubd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 61. 1 12.0 0.0 6.0 vpsubq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 62. 1 13.0 0.0 5.0 vpsubw %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 63. 1 14.0 0.0 4.0 vpsubb %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 64. 1 14.0 0.0 4.0 vpsubd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 65. 1 15.0 1.0 3.0 vpsubq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 66. 1 14.0 1.0 3.0 vpsubw %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 67. 1 17.0 4.0 0.0 vpsubb %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 68. 1 18.0 5.0 0.0 vpsubd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 69. 1 18.0 5.0 0.0 vpsubq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 70. 1 18.0 5.0 0.0 vpsubw %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 71. 1 19.0 6.0 0.0 vpsubb %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 72. 1 18.0 6.0 0.0 vpsubd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 73. 1 19.0 7.0 0.0 vpsubq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 74. 1 19.0 7.0 0.0 vpsubw %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 75. 1 1.0 1.0 18.0 andnps %xmm0, %xmm0 +# CHECK-NEXT: 76. 1 2.0 2.0 17.0 andnpd %xmm1, %xmm1 +# CHECK-NEXT: 77. 1 2.0 1.0 17.0 vandnps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: 78. 1 2.0 0.0 16.0 vandnpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 79. 1 2.0 0.0 16.0 vandnps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: 80. 1 3.0 0.0 15.0 vandnpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: 81. 1 10.0 7.0 8.0 vandnps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 82. 1 6.0 2.0 12.0 vandnpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 83. 1 19.0 19.0 0.0 pandn %mm2, %mm2 +# CHECK-NEXT: 84. 1 16.0 6.0 2.0 pandn %xmm2, %xmm2 +# CHECK-NEXT: 85. 1 17.0 5.0 1.0 vpandn %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 86. 1 18.0 0.0 0.0 vpandn %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 87. 1 18.0 8.0 0.0 vpandnd %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 88. 1 19.0 0.0 0.0 vpandnq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 89. 1 20.0 0.0 0.0 vpandnd %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 90. 1 20.0 0.0 0.0 vpandnq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 91. 1 21.0 0.0 0.0 vpandnd %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 92. 1 22.0 0.0 0.0 vpandnq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 93. 1 18.0 2.0 4.0 vandnps %xmm2, %xmm2, %xmm5 +# CHECK-NEXT: 94. 1 5.0 0.0 17.0 vandnpd %xmm1, %xmm1, %xmm5 +# CHECK-NEXT: 95. 1 18.0 0.0 4.0 vpandn %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 96. 1 18.0 3.0 3.0 vandnps %ymm2, %ymm2, %ymm5 +# CHECK-NEXT: 97. 1 5.0 1.0 16.0 vandnpd %ymm1, %ymm1, %ymm5 +# CHECK-NEXT: 98. 1 18.0 1.0 3.0 vpandn %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 99. 1 19.0 4.0 2.0 vandnps %zmm2, %zmm2, %zmm5 +# CHECK-NEXT: 100. 1 20.0 16.0 1.0 vandnpd %zmm1, %zmm1, %zmm5 +# CHECK-NEXT: 101. 1 22.0 0.0 0.0 vpandnd %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 102. 1 21.0 0.0 0.0 vpandnq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 103. 1 21.0 0.0 0.0 vpandnd %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 104. 1 22.0 1.0 0.0 vpandnq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 105. 1 22.0 1.0 0.0 vpandnd %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 106. 1 23.0 2.0 0.0 vpandnq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 107. 1 18.0 18.0 5.0 xorps %xmm0, %xmm0 +# CHECK-NEXT: 108. 1 4.0 2.0 18.0 xorpd %xmm1, %xmm1 +# CHECK-NEXT: 109. 1 18.0 5.0 4.0 vxorps %xmm2, %xmm2, %xmm2 +# CHECK-NEXT: 110. 1 19.0 14.0 3.0 vxorpd %xmm1, %xmm1, %xmm1 +# CHECK-NEXT: 111. 1 19.0 0.0 3.0 vxorps %ymm2, %ymm2, %ymm2 +# CHECK-NEXT: 112. 1 21.0 1.0 1.0 vxorpd %ymm1, %ymm1, %ymm1 +# CHECK-NEXT: 113. 1 23.0 3.0 0.0 vxorps %zmm2, %zmm2, %zmm2 +# CHECK-NEXT: 114. 1 21.0 0.0 1.0 vxorpd %zmm1, %zmm1, %zmm1 +# CHECK-NEXT: 115. 1 22.0 8.0 0.0 pxor %mm2, %mm2 +# CHECK-NEXT: 116. 1 23.0 0.0 0.0 pxor %xmm2, %xmm2 +# CHECK-NEXT: 117. 1 21.0 7.0 2.0 vpxor %xmm3, %xmm3, %xmm3 +# CHECK-NEXT: 118. 1 23.0 1.0 0.0 vpxor %ymm3, %ymm3, %ymm3 +# CHECK-NEXT: 119. 1 22.0 3.0 1.0 vpxord %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 120. 1 22.0 0.0 0.0 vpxorq %xmm19, %xmm19, %xmm19 +# CHECK-NEXT: 121. 1 23.0 0.0 0.0 vpxord %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 122. 1 24.0 0.0 0.0 vpxorq %ymm19, %ymm19, %ymm19 +# CHECK-NEXT: 123. 1 25.0 0.0 0.0 vpxord %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 124. 1 26.0 0.0 0.0 vpxorq %zmm19, %zmm19, %zmm19 +# CHECK-NEXT: 125. 1 23.0 23.0 3.0 vxorps %xmm4, %xmm4, %xmm5 +# CHECK-NEXT: 126. 1 22.0 2.0 3.0 vxorpd %xmm1, %xmm1, %xmm3 +# CHECK-NEXT: 127. 1 23.0 23.0 2.0 vxorps %ymm4, %ymm4, %ymm5 +# CHECK-NEXT: 128. 1 24.0 4.0 1.0 vxorpd %ymm1, %ymm1, %ymm3 +# CHECK-NEXT: 129. 1 24.0 24.0 1.0 vxorps %zmm4, %zmm4, %zmm5 +# CHECK-NEXT: 130. 1 23.0 3.0 2.0 vxorpd %zmm1, %zmm1, %zmm3 +# CHECK-NEXT: 131. 1 25.0 1.0 0.0 vpxor %xmm3, %xmm3, %xmm5 +# CHECK-NEXT: 132. 1 24.0 1.0 0.0 vpxor %ymm3, %ymm3, %ymm5 +# CHECK-NEXT: 133. 1 25.0 0.0 0.0 vpxord %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 134. 1 25.0 0.0 0.0 vpxorq %xmm19, %xmm19, %xmm21 +# CHECK-NEXT: 135. 1 25.0 0.0 0.0 vpxord %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 136. 1 26.0 1.0 0.0 vpxorq %ymm19, %ymm19, %ymm21 +# CHECK-NEXT: 137. 1 26.0 1.0 0.0 vpxord %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 138. 1 26.0 2.0 0.0 vpxorq %zmm19, %zmm19, %zmm21 +# CHECK-NEXT: 1 14.1 2.2 3.5