From: Craig Topper Date: Thu, 22 Mar 2018 04:23:41 +0000 (+0000) Subject: [X86][Skylake] Merge multiple InstrRW entries that map to the same SchedWriteRes... X-Git-Tag: llvmorg-7.0.0-rc1~9968 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=fc179c6dd59b0da8068ecb800095e79d2ec41bc6;p=platform%2Fupstream%2Fllvm.git [X86][Skylake] Merge multiple InstrRW entries that map to the same SchedWriteRes group (NFCI) (PR35955) I've also merged some VEX/non-VEX instregex strings with a (V?) prefix or (Y?) ymm variant - there are still a lot more of these to do. This reduces the size of the optimized llc binary on my computer by 400K. Presumably because we went from 5000+ scheduler classes per CPU to ~2000. llvm-svn: 328179 --- diff --git a/llvm/lib/Target/X86/X86SchedSkylakeClient.td b/llvm/lib/Target/X86/X86SchedSkylakeClient.td index d001b0c71810..99859e573777 100644 --- a/llvm/lib/Target/X86/X86SchedSkylakeClient.td +++ b/llvm/lib/Target/X86/X86SchedSkylakeClient.td @@ -278,203 +278,203 @@ def SKLWriteResGroup1 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PADDSBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PADDSWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PADDUSBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PADDUSWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PAVGBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PAVGWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPEQBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPEQDirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPEQWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPGTBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPGTDirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PCMPGTWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PMAXSWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PMAXUBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PMINSWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PMINUBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLDri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLDrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLQri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLQrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLWri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSLLWrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRADri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRADrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRAWri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRAWrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLDri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLDrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLQri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLQrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLWri")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSRLWrr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSUBSBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSUBSWirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSUBUSBirr")>; -def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PSUBUSWirr")>; +def: InstRW<[SKLWriteResGroup1], (instregex "MMX_PADDSBirr", + "MMX_PADDSWirr", + "MMX_PADDUSBirr", + "MMX_PADDUSWirr", + "MMX_PAVGBirr", + "MMX_PAVGWirr", + "MMX_PCMPEQBirr", + "MMX_PCMPEQDirr", + "MMX_PCMPEQWirr", + "MMX_PCMPGTBirr", + "MMX_PCMPGTDirr", + "MMX_PCMPGTWirr", + "MMX_PMAXSWirr", + "MMX_PMAXUBirr", + "MMX_PMINSWirr", + "MMX_PMINUBirr", + "MMX_PSLLDri", + "MMX_PSLLDrr", + "MMX_PSLLQri", + "MMX_PSLLQrr", + "MMX_PSLLWri", + "MMX_PSLLWrr", + "MMX_PSRADri", + "MMX_PSRADrr", + "MMX_PSRAWri", + "MMX_PSRAWrr", + "MMX_PSRLDri", + "MMX_PSRLDrr", + "MMX_PSRLQri", + "MMX_PSRLQrr", + "MMX_PSRLWri", + "MMX_PSRLWrr", + "MMX_PSUBSBirr", + "MMX_PSUBSWirr", + "MMX_PSUBUSBirr", + "MMX_PSUBUSWirr")>; def SKLWriteResGroup3 : SchedWriteRes<[SKLPort5]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup3], (instregex "COMP_FST0r")>; -def: InstRW<[SKLWriteResGroup3], (instregex "COM_FST0r")>; -def: InstRW<[SKLWriteResGroup3], (instregex "INSERTPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_MOVD64rr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_MOVD64to64rr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PALIGNRrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PSHUFBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PSHUFWri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKHBWirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKHDQirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKHWDirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKLBWirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKLDQirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MMX_PUNPCKLWDirr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOV64toPQIrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVDDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVDI2PDIrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVHLPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVLHPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVSDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVSHDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVSLDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVUPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "MOVUPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PACKSSDWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PACKSSWBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PACKUSDWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PACKUSWBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PALIGNRrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PBLENDWrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXBDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXBQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVSXWQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXBDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXBQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PMOVZXWQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSHUFBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSHUFDri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSHUFHWri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSHUFLWri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSLLDQri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PSRLDQri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKHBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKHDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKHQDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKHWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKLBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKLDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKLQDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "PUNPCKLWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "SHUFPDrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "SHUFPSrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UCOM_FPr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UCOM_Fr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UNPCKHPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UNPCKHPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UNPCKLPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "UNPCKLPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VBROADCASTSSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VINSERTPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOV64toPQIrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVDDUPYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVDDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVDI2PDIrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVHLPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVLHPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVSDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVSHDUPYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVSHDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVSLDUPYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVSLDUPrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVUPDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVUPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVUPSYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VMOVUPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKSSDWYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKSSDWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKSSWBYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKSSWBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKUSDWYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKUSDWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKUSWBYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPACKUSWBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPALIGNRYrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPALIGNRrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPBLENDWYrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPBLENDWrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPBROADCASTDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPBROADCASTQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPDYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPDri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPSYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPSYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPSri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPERMILPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXBDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXBQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVSXWQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXBDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXBQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPMOVZXWQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFBYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFBrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFDYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFDri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFHWYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFHWri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFLWYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSHUFLWri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSLLDQYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSLLDQri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSRLDQYri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPSRLDQri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHBWYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHDQYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHQDQYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHQDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHWDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKHWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLBWYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLBWrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLDQYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLQDQYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLQDQrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLWDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VPUNPCKLWDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VSHUFPDYrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VSHUFPDrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VSHUFPSYrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VSHUFPSrri")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKHPDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKHPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKHPSYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKHPSrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKLPDYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKLPDrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKLPSYrr")>; -def: InstRW<[SKLWriteResGroup3], (instregex "VUNPCKLPSrr")>; +def: InstRW<[SKLWriteResGroup3], (instregex "COMP_FST0r", + "COM_FST0r", + "INSERTPSrr", + "MMX_MOVD64rr", + "MMX_MOVD64to64rr", + "MMX_PALIGNRrri", + "MMX_PSHUFBrr", + "MMX_PSHUFWri", + "MMX_PUNPCKHBWirr", + "MMX_PUNPCKHDQirr", + "MMX_PUNPCKHWDirr", + "MMX_PUNPCKLBWirr", + "MMX_PUNPCKLDQirr", + "MMX_PUNPCKLWDirr", + "MOV64toPQIrr", + "MOVDDUPrr", + "MOVDI2PDIrr", + "MOVHLPSrr", + "MOVLHPSrr", + "MOVSDrr", + "MOVSHDUPrr", + "MOVSLDUPrr", + "MOVUPDrr", + "MOVUPSrr", + "PACKSSDWrr", + "PACKSSWBrr", + "PACKUSDWrr", + "PACKUSWBrr", + "PALIGNRrri", + "PBLENDWrri", + "PMOVSXBDrr", + "PMOVSXBQrr", + "PMOVSXBWrr", + "PMOVSXDQrr", + "PMOVSXWDrr", + "PMOVSXWQrr", + "PMOVZXBDrr", + "PMOVZXBQrr", + "PMOVZXBWrr", + "PMOVZXDQrr", + "PMOVZXWDrr", + "PMOVZXWQrr", + "PSHUFBrr", + "PSHUFDri", + "PSHUFHWri", + "PSHUFLWri", + "PSLLDQri", + "PSRLDQri", + "PUNPCKHBWrr", + "PUNPCKHDQrr", + "PUNPCKHQDQrr", + "PUNPCKHWDrr", + "PUNPCKLBWrr", + "PUNPCKLDQrr", + "PUNPCKLQDQrr", + "PUNPCKLWDrr", + "SHUFPDrri", + "SHUFPSrri", + "UCOM_FPr", + "UCOM_Fr", + "UNPCKHPDrr", + "UNPCKHPSrr", + "UNPCKLPDrr", + "UNPCKLPSrr", + "VBROADCASTSSrr", + "VINSERTPSrr", + "VMOV64toPQIrr", + "VMOVDDUPYrr", + "VMOVDDUPrr", + "VMOVDI2PDIrr", + "VMOVHLPSrr", + "VMOVLHPSrr", + "VMOVSDrr", + "VMOVSHDUPYrr", + "VMOVSHDUPrr", + "VMOVSLDUPYrr", + "VMOVSLDUPrr", + "VMOVUPDYrr", + "VMOVUPDrr", + "VMOVUPSYrr", + "VMOVUPSrr", + "VPACKSSDWYrr", + "VPACKSSDWrr", + "VPACKSSWBYrr", + "VPACKSSWBrr", + "VPACKUSDWYrr", + "VPACKUSDWrr", + "VPACKUSWBYrr", + "VPACKUSWBrr", + "VPALIGNRYrri", + "VPALIGNRrri", + "VPBLENDWYrri", + "VPBLENDWrri", + "VPBROADCASTDrr", + "VPBROADCASTQrr", + "VPERMILPDYri", + "VPERMILPDYrr", + "VPERMILPDri", + "VPERMILPDrr", + "VPERMILPSYri", + "VPERMILPSYrr", + "VPERMILPSri", + "VPERMILPSrr", + "VPMOVSXBDrr", + "VPMOVSXBQrr", + "VPMOVSXBWrr", + "VPMOVSXDQrr", + "VPMOVSXWDrr", + "VPMOVSXWQrr", + "VPMOVZXBDrr", + "VPMOVZXBQrr", + "VPMOVZXBWrr", + "VPMOVZXDQrr", + "VPMOVZXWDrr", + "VPMOVZXWQrr", + "VPSHUFBYrr", + "VPSHUFBrr", + "VPSHUFDYri", + "VPSHUFDri", + "VPSHUFHWYri", + "VPSHUFHWri", + "VPSHUFLWYri", + "VPSHUFLWri", + "VPSLLDQYri", + "VPSLLDQri", + "VPSRLDQYri", + "VPSRLDQri", + "VPUNPCKHBWYrr", + "VPUNPCKHBWrr", + "VPUNPCKHDQYrr", + "VPUNPCKHDQrr", + "VPUNPCKHQDQYrr", + "VPUNPCKHQDQrr", + "VPUNPCKHWDYrr", + "VPUNPCKHWDrr", + "VPUNPCKLBWYrr", + "VPUNPCKLBWrr", + "VPUNPCKLDQYrr", + "VPUNPCKLDQrr", + "VPUNPCKLQDQYrr", + "VPUNPCKLQDQrr", + "VPUNPCKLWDYrr", + "VPUNPCKLWDrr", + "VSHUFPDYrri", + "VSHUFPDrri", + "VSHUFPSYrri", + "VSHUFPSrri", + "VUNPCKHPDYrr", + "VUNPCKHPDrr", + "VUNPCKHPSYrr", + "VUNPCKHPSrr", + "VUNPCKLPDYrr", + "VUNPCKLPDrr", + "VUNPCKLPSYrr", + "VUNPCKLPSrr")>; def SKLWriteResGroup4 : SchedWriteRes<[SKLPort6]> { let Latency = 1; @@ -488,566 +488,566 @@ def SKLWriteResGroup5 : SchedWriteRes<[SKLPort01]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup5], (instregex "PABSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PABSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PABSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PADDSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PADDSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PADDUSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PADDUSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PAVGBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PAVGWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPEQBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPEQDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPEQQrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPEQWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPGTBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPGTDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PCMPGTWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXUBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXUDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMAXUWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINUBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINUDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PMINUWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSIGNBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSIGNDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSIGNWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSLLDri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSLLQri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSLLWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSRADri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSRAWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSRLDri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSRLQri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSRLWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSUBSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSUBSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSUBUSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "PSUBUSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPABSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDUSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDUSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDUSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPADDUSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPAVGBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPAVGBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPAVGWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPAVGWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQQYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQQrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPEQWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPCMPGTWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMAXUWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPMINUWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSIGNWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLDYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLDri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLQYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLQri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLVDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLVDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLVQYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLVQrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLWYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSLLWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRADYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRADri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRAVDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRAVDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRAWYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRAWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLDYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLDri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLQYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLQri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLVDYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLVDrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLVQYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLVQrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLWYri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSRLWri")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBSWrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBUSBYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBUSBrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBUSWYrr")>; -def: InstRW<[SKLWriteResGroup5], (instregex "VPSUBUSWrr")>; +def: InstRW<[SKLWriteResGroup5], (instregex "PABSBrr", + "PABSDrr", + "PABSWrr", + "PADDSBrr", + "PADDSWrr", + "PADDUSBrr", + "PADDUSWrr", + "PAVGBrr", + "PAVGWrr", + "PCMPEQBrr", + "PCMPEQDrr", + "PCMPEQQrr", + "PCMPEQWrr", + "PCMPGTBrr", + "PCMPGTDrr", + "PCMPGTWrr", + "PMAXSBrr", + "PMAXSDrr", + "PMAXSWrr", + "PMAXUBrr", + "PMAXUDrr", + "PMAXUWrr", + "PMINSBrr", + "PMINSDrr", + "PMINSWrr", + "PMINUBrr", + "PMINUDrr", + "PMINUWrr", + "PSIGNBrr", + "PSIGNDrr", + "PSIGNWrr", + "PSLLDri", + "PSLLQri", + "PSLLWri", + "PSRADri", + "PSRAWri", + "PSRLDri", + "PSRLQri", + "PSRLWri", + "PSUBSBrr", + "PSUBSWrr", + "PSUBUSBrr", + "PSUBUSWrr", + "VPABSBYrr", + "VPABSBrr", + "VPABSDYrr", + "VPABSDrr", + "VPABSWYrr", + "VPABSWrr", + "VPADDSBYrr", + "VPADDSBrr", + "VPADDSWYrr", + "VPADDSWrr", + "VPADDUSBYrr", + "VPADDUSBrr", + "VPADDUSWYrr", + "VPADDUSWrr", + "VPAVGBYrr", + "VPAVGBrr", + "VPAVGWYrr", + "VPAVGWrr", + "VPCMPEQBYrr", + "VPCMPEQBrr", + "VPCMPEQDYrr", + "VPCMPEQDrr", + "VPCMPEQQYrr", + "VPCMPEQQrr", + "VPCMPEQWYrr", + "VPCMPEQWrr", + "VPCMPGTBYrr", + "VPCMPGTBrr", + "VPCMPGTDYrr", + "VPCMPGTDrr", + "VPCMPGTWYrr", + "VPCMPGTWrr", + "VPMAXSBYrr", + "VPMAXSBrr", + "VPMAXSDYrr", + "VPMAXSDrr", + "VPMAXSWYrr", + "VPMAXSWrr", + "VPMAXUBYrr", + "VPMAXUBrr", + "VPMAXUDYrr", + "VPMAXUDrr", + "VPMAXUWYrr", + "VPMAXUWrr", + "VPMINSBYrr", + "VPMINSBrr", + "VPMINSDYrr", + "VPMINSDrr", + "VPMINSWYrr", + "VPMINSWrr", + "VPMINUBYrr", + "VPMINUBrr", + "VPMINUDYrr", + "VPMINUDrr", + "VPMINUWYrr", + "VPMINUWrr", + "VPSIGNBYrr", + "VPSIGNBrr", + "VPSIGNDYrr", + "VPSIGNDrr", + "VPSIGNWYrr", + "VPSIGNWrr", + "VPSLLDYri", + "VPSLLDri", + "VPSLLQYri", + "VPSLLQri", + "VPSLLVDYrr", + "VPSLLVDrr", + "VPSLLVQYrr", + "VPSLLVQrr", + "VPSLLWYri", + "VPSLLWri", + "VPSRADYri", + "VPSRADri", + "VPSRAVDYrr", + "VPSRAVDrr", + "VPSRAWYri", + "VPSRAWri", + "VPSRLDYri", + "VPSRLDri", + "VPSRLQYri", + "VPSRLQri", + "VPSRLVDYrr", + "VPSRLVDrr", + "VPSRLVQYrr", + "VPSRLVQrr", + "VPSRLWYri", + "VPSRLWri", + "VPSUBSBYrr", + "VPSUBSBrr", + "VPSUBSWYrr", + "VPSUBSWrr", + "VPSUBUSBYrr", + "VPSUBUSBrr", + "VPSUBUSWYrr", + "VPSUBUSWrr")>; def SKLWriteResGroup6 : SchedWriteRes<[SKLPort05]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup6], (instregex "FINCSTP")>; -def: InstRW<[SKLWriteResGroup6], (instregex "FNOP")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_MOVQ64rr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PABSBrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PABSDrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PABSWrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PADDBirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PADDDirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PADDQirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PADDWirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PANDNirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PANDirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PORirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSIGNBrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSIGNDrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSIGNWrr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSUBBirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSUBDirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSUBQirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PSUBWirr")>; -def: InstRW<[SKLWriteResGroup6], (instregex "MMX_PXORirr")>; +def: InstRW<[SKLWriteResGroup6], (instregex "FINCSTP", + "FNOP", + "MMX_MOVQ64rr", + "MMX_PABSBrr", + "MMX_PABSDrr", + "MMX_PABSWrr", + "MMX_PADDBirr", + "MMX_PADDDirr", + "MMX_PADDQirr", + "MMX_PADDWirr", + "MMX_PANDNirr", + "MMX_PANDirr", + "MMX_PORirr", + "MMX_PSIGNBrr", + "MMX_PSIGNDrr", + "MMX_PSIGNWrr", + "MMX_PSUBBirr", + "MMX_PSUBDirr", + "MMX_PSUBQirr", + "MMX_PSUBWirr", + "MMX_PXORirr")>; def SKLWriteResGroup7 : SchedWriteRes<[SKLPort06]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup7], (instregex "ADC(16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "ADC(16|32|64)i")>; -def: InstRW<[SKLWriteResGroup7], (instregex "ADC(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "ADCX(32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "ADOX(32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BT(16|32|64)ri8")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BT(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTC(16|32|64)ri8")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTC(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTR(16|32|64)ri8")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTR(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTS(16|32|64)ri8")>; -def: InstRW<[SKLWriteResGroup7], (instregex "BTS(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "CDQ")>; -def: InstRW<[SKLWriteResGroup7], (instregex "CLAC")>; -def: InstRW<[SKLWriteResGroup7], (instregex "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "CQO")>; -def: InstRW<[SKLWriteResGroup7], (instregex "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_1")>; -def: InstRW<[SKLWriteResGroup7], (instregex "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_4")>; -def: InstRW<[SKLWriteResGroup7], (instregex "JMP_1")>; -def: InstRW<[SKLWriteResGroup7], (instregex "JMP_4")>; -def: InstRW<[SKLWriteResGroup7], (instregex "RORX(32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SAR(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SAR(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SARX(32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SBB(16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SBB(16|32|64)i")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SBB(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SET(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)r")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHL(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHL(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHLX(32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHR(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHR(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup7], (instregex "SHRX(32|64)rr")>; -def: InstRW<[SKLWriteResGroup7], (instregex "STAC")>; +def: InstRW<[SKLWriteResGroup7], (instregex "ADC(16|32|64)ri", + "ADC(16|32|64)i", + "ADC(8|16|32|64)rr", + "ADCX(32|64)rr", + "ADOX(32|64)rr", + "BT(16|32|64)ri8", + "BT(16|32|64)rr", + "BTC(16|32|64)ri8", + "BTC(16|32|64)rr", + "BTR(16|32|64)ri8", + "BTR(16|32|64)rr", + "BTS(16|32|64)ri8", + "BTS(16|32|64)rr", + "CDQ", + "CLAC", + "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rr", + "CQO", + "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_1", + "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_4", + "JMP_1", + "JMP_4", + "RORX(32|64)ri", + "SAR(8|16|32|64)r1", + "SAR(8|16|32|64)ri", + "SARX(32|64)rr", + "SBB(16|32|64)ri", + "SBB(16|32|64)i", + "SBB(8|16|32|64)rr", + "SET(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)r", + "SHL(8|16|32|64)r1", + "SHL(8|16|32|64)ri", + "SHLX(32|64)rr", + "SHR(8|16|32|64)r1", + "SHR(8|16|32|64)ri", + "SHRX(32|64)rr", + "STAC")>; def SKLWriteResGroup8 : SchedWriteRes<[SKLPort15]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup8], (instregex "ANDN(32|64)rr")>; -def: InstRW<[SKLWriteResGroup8], (instregex "BLSI(32|64)rr")>; -def: InstRW<[SKLWriteResGroup8], (instregex "BLSMSK(32|64)rr")>; -def: InstRW<[SKLWriteResGroup8], (instregex "BLSR(32|64)rr")>; -def: InstRW<[SKLWriteResGroup8], (instregex "BZHI(32|64)rr")>; -def: InstRW<[SKLWriteResGroup8], (instregex "LEA(16|32|64)(_32)?r")>; +def: InstRW<[SKLWriteResGroup8], (instregex "ANDN(32|64)rr", + "BLSI(32|64)rr", + "BLSMSK(32|64)rr", + "BLSR(32|64)rr", + "BZHI(32|64)rr", + "LEA(16|32|64)(_32)?r")>; def SKLWriteResGroup9 : SchedWriteRes<[SKLPort015]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup9], (instregex "ANDNPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "ANDNPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "ANDPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "ANDPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "BLENDPDrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "BLENDPSrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVAPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVAPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVDQArr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVDQUrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVPQI2QIrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "MOVSSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "ORPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "ORPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PADDBrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PADDDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PADDQrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PADDWrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PANDNrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PANDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PORrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PSUBBrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PSUBDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PSUBQrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PSUBWrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "PXORrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDNPDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDNPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDNPSYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDNPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDPDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDPSYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VANDPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VBLENDPDYrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VBLENDPDrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VBLENDPSYrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VBLENDPSrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVAPDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVAPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVAPSYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVAPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVDQAYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVDQArr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVDQUYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVDQUrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVPQI2QIrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVSSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VMOVZPQILo2PQIrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VORPDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VORPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VORPSYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VORPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDBYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDBrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDQYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDQrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDWYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPADDWrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPANDNYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPANDNrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPANDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPANDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPBLENDDYrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPBLENDDrri")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPORYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPORrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBBYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBBrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBQYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBQrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBWYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPSUBWrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPXORYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VPXORrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VXORPDYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VXORPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VXORPSYrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "VXORPSrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "XORPDrr")>; -def: InstRW<[SKLWriteResGroup9], (instregex "XORPSrr")>; +def: InstRW<[SKLWriteResGroup9], (instregex "ANDNPDrr", + "ANDNPSrr", + "ANDPDrr", + "ANDPSrr", + "BLENDPDrri", + "BLENDPSrri", + "MOVAPDrr", + "MOVAPSrr", + "MOVDQArr", + "MOVDQUrr", + "MOVPQI2QIrr", + "MOVSSrr", + "ORPDrr", + "ORPSrr", + "PADDBrr", + "PADDDrr", + "PADDQrr", + "PADDWrr", + "PANDNrr", + "PANDrr", + "PORrr", + "PSUBBrr", + "PSUBDrr", + "PSUBQrr", + "PSUBWrr", + "PXORrr", + "VANDNPDYrr", + "VANDNPDrr", + "VANDNPSYrr", + "VANDNPSrr", + "VANDPDYrr", + "VANDPDrr", + "VANDPSYrr", + "VANDPSrr", + "VBLENDPDYrri", + "VBLENDPDrri", + "VBLENDPSYrri", + "VBLENDPSrri", + "VMOVAPDYrr", + "VMOVAPDrr", + "VMOVAPSYrr", + "VMOVAPSrr", + "VMOVDQAYrr", + "VMOVDQArr", + "VMOVDQUYrr", + "VMOVDQUrr", + "VMOVPQI2QIrr", + "VMOVSSrr", + "VMOVZPQILo2PQIrr", + "VORPDYrr", + "VORPDrr", + "VORPSYrr", + "VORPSrr", + "VPADDBYrr", + "VPADDBrr", + "VPADDDYrr", + "VPADDDrr", + "VPADDQYrr", + "VPADDQrr", + "VPADDWYrr", + "VPADDWrr", + "VPANDNYrr", + "VPANDNrr", + "VPANDYrr", + "VPANDrr", + "VPBLENDDYrri", + "VPBLENDDrri", + "VPORYrr", + "VPORrr", + "VPSUBBYrr", + "VPSUBBrr", + "VPSUBDYrr", + "VPSUBDrr", + "VPSUBQYrr", + "VPSUBQrr", + "VPSUBWYrr", + "VPSUBWrr", + "VPXORYrr", + "VPXORrr", + "VXORPDYrr", + "VXORPDrr", + "VXORPSYrr", + "VXORPSrr", + "XORPDrr", + "XORPSrr")>; def SKLWriteResGroup10 : SchedWriteRes<[SKLPort0156]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup10], (instregex "ADD(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "ADD(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "ADD(8|16|32|64)i")>; -def: InstRW<[SKLWriteResGroup10], (instregex "AND(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "AND(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "AND(8|16|32|64)i")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CBW")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CLC")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CMC")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CMP(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CMP(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "CMP(8|16|32|64)i")>; def: InstRW<[SKLWriteResGroup10], (instrs CWDE)>; -def: InstRW<[SKLWriteResGroup10], (instregex "DEC(8|16|32|64)r")>; -def: InstRW<[SKLWriteResGroup10], (instregex "INC(8|16|32|64)r")>; -def: InstRW<[SKLWriteResGroup10], (instregex "LAHF")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOV(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOV(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOVSX(16|32|64)rr16")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOVSX(16|32|64)rr32")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOVSX(16|32|64)rr8")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOVZX(16|32|64)rr16")>; -def: InstRW<[SKLWriteResGroup10], (instregex "MOVZX(16|32|64)rr8")>; -def: InstRW<[SKLWriteResGroup10], (instregex "NEG(8|16|32|64)r")>; -def: InstRW<[SKLWriteResGroup10], (instregex "NOOP")>; -def: InstRW<[SKLWriteResGroup10], (instregex "NOT(8|16|32|64)r")>; -def: InstRW<[SKLWriteResGroup10], (instregex "OR(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "OR(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "OR(8|16|32|64)i")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SAHF")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SGDT64m")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SIDT64m")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SLDT64m")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SMSW16m")>; -def: InstRW<[SKLWriteResGroup10], (instregex "STC")>; -def: InstRW<[SKLWriteResGroup10], (instregex "STRm")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SUB(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SUB(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SUB(8|16|32|64)i")>; -def: InstRW<[SKLWriteResGroup10], (instregex "SYSCALL")>; -def: InstRW<[SKLWriteResGroup10], (instregex "TEST(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "TEST(8|16|32|64)i")>; -def: InstRW<[SKLWriteResGroup10], (instregex "TEST(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "XCHG(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "XOR(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup10], (instregex "XOR(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup10], (instregex "XOR(8|16|32|64)i")>; +def: InstRW<[SKLWriteResGroup10], (instregex "ADD(8|16|32|64)ri", + "ADD(8|16|32|64)rr", + "ADD(8|16|32|64)i", + "AND(8|16|32|64)ri", + "AND(8|16|32|64)rr", + "AND(8|16|32|64)i", + "CBW", + "CLC", + "CMC", + "CMP(8|16|32|64)ri", + "CMP(8|16|32|64)rr", + "CMP(8|16|32|64)i", + "DEC(8|16|32|64)r", + "INC(8|16|32|64)r", + "LAHF", + "MOV(8|16|32|64)rr", + "MOV(8|16|32|64)ri", + "MOVSX(16|32|64)rr16", + "MOVSX(16|32|64)rr32", + "MOVSX(16|32|64)rr8", + "MOVZX(16|32|64)rr16", + "MOVZX(16|32|64)rr8", + "NEG(8|16|32|64)r", + "NOOP", + "NOT(8|16|32|64)r", + "OR(8|16|32|64)ri", + "OR(8|16|32|64)rr", + "OR(8|16|32|64)i", + "SAHF", + "SGDT64m", + "SIDT64m", + "SLDT64m", + "SMSW16m", + "STC", + "STRm", + "SUB(8|16|32|64)ri", + "SUB(8|16|32|64)rr", + "SUB(8|16|32|64)i", + "SYSCALL", + "TEST(8|16|32|64)rr", + "TEST(8|16|32|64)i", + "TEST(8|16|32|64)ri", + "XCHG(16|32|64)rr", + "XOR(8|16|32|64)ri", + "XOR(8|16|32|64)rr", + "XOR(8|16|32|64)i")>; def SKLWriteResGroup11 : SchedWriteRes<[SKLPort4,SKLPort237]> { let Latency = 1; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup11], (instregex "FBSTPm")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MMX_MOVD64from64rm")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MMX_MOVD64mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MMX_MOVNTQmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MMX_MOVQ64mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOV(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOV8mi")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVAPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVAPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVDQAmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVDQUmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVHPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVHPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVLPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVLPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVNTDQmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVNTI_64mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVNTImr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVNTPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVNTPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVPDI2DImr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVPQI2QImr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVPQIto64mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVSDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVSSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVUPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "MOVUPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "ST_FP32m")>; -def: InstRW<[SKLWriteResGroup11], (instregex "ST_FP64m")>; -def: InstRW<[SKLWriteResGroup11], (instregex "ST_FP80m")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VEXTRACTF128mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VEXTRACTI128mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVAPDYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVAPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVAPSYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVAPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVDQAYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVDQAmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVDQUYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVDQUmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVHPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVHPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVLPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVLPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTDQYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTDQmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTPDYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTPSYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVNTPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVPDI2DImr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVPQI2QImr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVPQIto64mr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVSDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVSSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVUPDYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVUPDmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVUPSYmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMOVUPSmr")>; -def: InstRW<[SKLWriteResGroup11], (instregex "VMPTRSTm")>; +def: InstRW<[SKLWriteResGroup11], (instregex "FBSTPm", + "MMX_MOVD64from64rm", + "MMX_MOVD64mr", + "MMX_MOVNTQmr", + "MMX_MOVQ64mr", + "MOV(8|16|32|64)mr", + "MOV8mi", + "MOVAPDmr", + "MOVAPSmr", + "MOVDQAmr", + "MOVDQUmr", + "MOVHPDmr", + "MOVHPSmr", + "MOVLPDmr", + "MOVLPSmr", + "MOVNTDQmr", + "MOVNTI_64mr", + "MOVNTImr", + "MOVNTPDmr", + "MOVNTPSmr", + "MOVPDI2DImr", + "MOVPQI2QImr", + "MOVPQIto64mr", + "MOVSDmr", + "MOVSSmr", + "MOVUPDmr", + "MOVUPSmr", + "ST_FP32m", + "ST_FP64m", + "ST_FP80m", + "VEXTRACTF128mr", + "VEXTRACTI128mr", + "VMOVAPDYmr", + "VMOVAPDmr", + "VMOVAPSYmr", + "VMOVAPSmr", + "VMOVDQAYmr", + "VMOVDQAmr", + "VMOVDQUYmr", + "VMOVDQUmr", + "VMOVHPDmr", + "VMOVHPSmr", + "VMOVLPDmr", + "VMOVLPSmr", + "VMOVNTDQYmr", + "VMOVNTDQmr", + "VMOVNTPDYmr", + "VMOVNTPDmr", + "VMOVNTPSYmr", + "VMOVNTPSmr", + "VMOVPDI2DImr", + "VMOVPQI2QImr", + "VMOVPQIto64mr", + "VMOVSDmr", + "VMOVSSmr", + "VMOVUPDYmr", + "VMOVUPDmr", + "VMOVUPSYmr", + "VMOVUPSmr", + "VMPTRSTm")>; def SKLWriteResGroup12 : SchedWriteRes<[SKLPort0]> { let Latency = 2; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup12], (instregex "COMISDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "COMISSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MMX_MOVD64from64rr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MMX_MOVD64grr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MMX_PMOVMSKBrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MOVMSKPDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MOVMSKPSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MOVPDI2DIrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "MOVPQIto64rr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "PMOVMSKBrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "UCOMISDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "UCOMISSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VCOMISDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VCOMISSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVMSKPDYrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVMSKPDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVMSKPSYrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVMSKPSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVPDI2DIrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VMOVPQIto64rr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VPMOVMSKBYrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VPMOVMSKBrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VTESTPDYrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VTESTPDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VTESTPSYrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VTESTPSrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VUCOMISDrr")>; -def: InstRW<[SKLWriteResGroup12], (instregex "VUCOMISSrr")>; +def: InstRW<[SKLWriteResGroup12], (instregex "COMISDrr", + "COMISSrr", + "MMX_MOVD64from64rr", + "MMX_MOVD64grr", + "MMX_PMOVMSKBrr", + "MOVMSKPDrr", + "MOVMSKPSrr", + "MOVPDI2DIrr", + "MOVPQIto64rr", + "PMOVMSKBrr", + "UCOMISDrr", + "UCOMISSrr", + "VCOMISDrr", + "VCOMISSrr", + "VMOVMSKPDYrr", + "VMOVMSKPDrr", + "VMOVMSKPSYrr", + "VMOVMSKPSrr", + "VMOVPDI2DIrr", + "VMOVPQIto64rr", + "VPMOVMSKBYrr", + "VPMOVMSKBrr", + "VTESTPDYrr", + "VTESTPDrr", + "VTESTPSYrr", + "VTESTPSrr", + "VUCOMISDrr", + "VUCOMISSrr")>; def SKLWriteResGroup13 : SchedWriteRes<[SKLPort5]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup13], (instregex "MMX_MOVQ2DQrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "MMX_PINSRWrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "PINSRBrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "PINSRDrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "PINSRQrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "PINSRWrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "VPINSRBrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "VPINSRDrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "VPINSRQrr")>; -def: InstRW<[SKLWriteResGroup13], (instregex "VPINSRWrr")>; +def: InstRW<[SKLWriteResGroup13], (instregex "MMX_MOVQ2DQrr", + "MMX_PINSRWrr", + "PINSRBrr", + "PINSRDrr", + "PINSRQrr", + "PINSRWrr", + "VPINSRBrr", + "VPINSRDrr", + "VPINSRQrr", + "VPINSRWrr")>; def SKLWriteResGroup14 : SchedWriteRes<[SKLPort05]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup14], (instregex "FDECSTP")>; -def: InstRW<[SKLWriteResGroup14], (instregex "MMX_MOVDQ2Qrr")>; +def: InstRW<[SKLWriteResGroup14], (instregex "FDECSTP", + "MMX_MOVDQ2Qrr")>; def SKLWriteResGroup15 : SchedWriteRes<[SKLPort06]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup15], (instregex "CMOV(A|BE)(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup15], (instregex "ROL(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup15], (instregex "ROL(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup15], (instregex "ROR(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup15], (instregex "ROR(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup15], (instregex "SET(A|BE)r")>; +def: InstRW<[SKLWriteResGroup15], (instregex "CMOV(A|BE)(16|32|64)rr", + "ROL(8|16|32|64)r1", + "ROL(8|16|32|64)ri", + "ROR(8|16|32|64)r1", + "ROR(8|16|32|64)ri", + "SET(A|BE)r")>; def SKLWriteResGroup16 : SchedWriteRes<[SKLPort015]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup16], (instregex "BLENDVPDrr0")>; -def: InstRW<[SKLWriteResGroup16], (instregex "BLENDVPSrr0")>; -def: InstRW<[SKLWriteResGroup16], (instregex "PBLENDVBrr0")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VBLENDVPDYrr")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VBLENDVPDrr")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VBLENDVPSYrr")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VBLENDVPSrr")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VPBLENDVBYrr")>; -def: InstRW<[SKLWriteResGroup16], (instregex "VPBLENDVBrr")>; +def: InstRW<[SKLWriteResGroup16], (instregex "BLENDVPDrr0", + "BLENDVPSrr0", + "PBLENDVBrr0", + "VBLENDVPDYrr", + "VBLENDVPDrr", + "VBLENDVPSYrr", + "VBLENDVPSrr", + "VPBLENDVBYrr", + "VPBLENDVBrr")>; def SKLWriteResGroup17 : SchedWriteRes<[SKLPort0156]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup17], (instregex "LFENCE")>; -def: InstRW<[SKLWriteResGroup17], (instregex "WAIT")>; -def: InstRW<[SKLWriteResGroup17], (instregex "XGETBV")>; +def: InstRW<[SKLWriteResGroup17], (instregex "LFENCE", + "WAIT", + "XGETBV")>; def SKLWriteResGroup18 : SchedWriteRes<[SKLPort0,SKLPort237]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup18], (instregex "VMASKMOVPDYmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VMASKMOVPDmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VMASKMOVPSYmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VMASKMOVPSmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VPMASKMOVDYmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VPMASKMOVDmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VPMASKMOVQYmr")>; -def: InstRW<[SKLWriteResGroup18], (instregex "VPMASKMOVQmr")>; +def: InstRW<[SKLWriteResGroup18], (instregex "VMASKMOVPDYmr", + "VMASKMOVPDmr", + "VMASKMOVPSYmr", + "VMASKMOVPSmr", + "VPMASKMOVDYmr", + "VPMASKMOVDmr", + "VPMASKMOVQYmr", + "VPMASKMOVQmr")>; def SKLWriteResGroup19 : SchedWriteRes<[SKLPort5,SKLPort01]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup19], (instregex "PSLLDrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSLLQrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSLLWrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSRADrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSRAWrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSRLDrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSRLQrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "PSRLWrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSLLDrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSLLQrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSLLWrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSRADrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSRAWrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSRLDrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSRLQrr")>; -def: InstRW<[SKLWriteResGroup19], (instregex "VPSRLWrr")>; +def: InstRW<[SKLWriteResGroup19], (instregex "PSLLDrr", + "PSLLQrr", + "PSLLWrr", + "PSRADrr", + "PSRAWrr", + "PSRLDrr", + "PSRLQrr", + "PSRLWrr", + "VPSLLDrr", + "VPSLLQrr", + "VPSLLWrr", + "VPSRADrr", + "VPSRAWrr", + "VPSRLDrr", + "VPSRLQrr", + "VPSRLWrr")>; def SKLWriteResGroup20 : SchedWriteRes<[SKLPort6,SKLPort0156]> { let Latency = 2; @@ -1068,38 +1068,38 @@ def SKLWriteResGroup22 : SchedWriteRes<[SKLPort06,SKLPort15]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup22], (instregex "BEXTR(32|64)rr")>; -def: InstRW<[SKLWriteResGroup22], (instregex "BSWAP(16|32|64)r")>; +def: InstRW<[SKLWriteResGroup22], (instregex "BEXTR(32|64)rr", + "BSWAP(16|32|64)r")>; def SKLWriteResGroup23 : SchedWriteRes<[SKLPort06,SKLPort0156]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup23], (instregex "ADC8i8")>; -def: InstRW<[SKLWriteResGroup23], (instregex "ADC8ri")>; def: InstRW<[SKLWriteResGroup23], (instrs CWD)>; def: InstRW<[SKLWriteResGroup23], (instrs JCXZ, JECXZ, JRCXZ)>; -def: InstRW<[SKLWriteResGroup23], (instregex "SBB8i8")>; -def: InstRW<[SKLWriteResGroup23], (instregex "SBB8ri")>; +def: InstRW<[SKLWriteResGroup23], (instregex "ADC8i8", + "ADC8ri", + "SBB8i8", + "SBB8ri")>; def SKLWriteResGroup24 : SchedWriteRes<[SKLPort4,SKLPort5,SKLPort237]> { let Latency = 2; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup24], (instregex "EXTRACTPSmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "PEXTRBmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "PEXTRDmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "PEXTRQmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "PEXTRWmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "STMXCSR")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VEXTRACTPSmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VPEXTRBmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VPEXTRDmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VPEXTRQmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VPEXTRWmr")>; -def: InstRW<[SKLWriteResGroup24], (instregex "VSTMXCSR")>; +def: InstRW<[SKLWriteResGroup24], (instregex "EXTRACTPSmr", + "PEXTRBmr", + "PEXTRDmr", + "PEXTRQmr", + "PEXTRWmr", + "STMXCSR", + "VEXTRACTPSmr", + "VPEXTRBmr", + "VPEXTRDmr", + "VPEXTRQmr", + "VPEXTRWmr", + "VSTMXCSR")>; def SKLWriteResGroup25 : SchedWriteRes<[SKLPort4,SKLPort6,SKLPort237]> { let Latency = 2; @@ -1128,30 +1128,29 @@ def SKLWriteResGroup28 : SchedWriteRes<[SKLPort4,SKLPort237,SKLPort0156]> { let ResourceCycles = [1,1,1]; } def: InstRW<[SKLWriteResGroup28], (instrs PUSH16r, PUSH32r, PUSH64r)>; -def: InstRW<[SKLWriteResGroup28], (instregex "PUSH(16|32|64)rmr")>; -def: InstRW<[SKLWriteResGroup28], (instregex "PUSH64i8")>; -def: InstRW<[SKLWriteResGroup28], (instregex "STOSB")>; -def: InstRW<[SKLWriteResGroup28], (instregex "STOSL")>; -def: InstRW<[SKLWriteResGroup28], (instregex "STOSQ")>; -def: InstRW<[SKLWriteResGroup28], (instregex "STOSW")>; +def: InstRW<[SKLWriteResGroup28], (instregex "PUSH(16|32|64)rmr", + "PUSH64i8", + "STOSB", + "STOSL", + "STOSQ", + "STOSW")>; def SKLWriteResGroup29 : SchedWriteRes<[SKLPort1]> { let Latency = 3; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup29], (instregex "BSF(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup29], (instregex "BSR(16|32|64)rr")>; def: InstRW<[SKLWriteResGroup29], (instrs IMUL16rr, IMUL32rr, IMUL32rri, IMUL32rri8, IMUL64rr, IMUL64rri32, IMUL64rri8)>; -def: InstRW<[SKLWriteResGroup29], (instrs IMUL8r)>; -def: InstRW<[SKLWriteResGroup29], (instregex "LZCNT(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup29], (instrs MUL8r)>; -def: InstRW<[SKLWriteResGroup29], (instregex "PDEP(32|64)rr")>; -def: InstRW<[SKLWriteResGroup29], (instregex "PEXT(32|64)rr")>; -def: InstRW<[SKLWriteResGroup29], (instregex "POPCNT(16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup29], (instregex "SHLD(16|32|64)rri8")>; -def: InstRW<[SKLWriteResGroup29], (instregex "SHRD(16|32|64)rri8")>; -def: InstRW<[SKLWriteResGroup29], (instregex "TZCNT(16|32|64)rr")>; +def: InstRW<[SKLWriteResGroup29], (instrs IMUL8r, MUL8r)>; +def: InstRW<[SKLWriteResGroup29], (instregex "BSF(16|32|64)rr", + "BSR(16|32|64)rr", + "LZCNT(16|32|64)rr", + "PDEP(32|64)rr", + "PEXT(32|64)rr", + "POPCNT(16|32|64)rr", + "SHLD(16|32|64)rri8", + "SHRD(16|32|64)rri8", + "TZCNT(16|32|64)rr")>; def SKLWriteResGroup29_16i : SchedWriteRes<[SKLPort1, SKLPort0156]> { let Latency = 3; @@ -1165,72 +1164,72 @@ def SKLWriteResGroup30 : SchedWriteRes<[SKLPort5]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup30], (instregex "ADD_FPrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "ADD_FST0r")>; -def: InstRW<[SKLWriteResGroup30], (instregex "ADD_FrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "MMX_PSADBWirr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "PCMPGTQrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "PSADBWrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUBR_FPrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUBR_FST0r")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUBR_FrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUB_FPrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUB_FST0r")>; -def: InstRW<[SKLWriteResGroup30], (instregex "SUB_FrST0")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VBROADCASTSDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VBROADCASTSSYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VEXTRACTF128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VEXTRACTI128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VINSERTF128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VINSERTI128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTBYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTBrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTWYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPBROADCASTWrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPCMPGTQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPCMPGTQrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERM2F128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERM2I128rr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERMDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERMPDYri")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERMPSYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPERMQYri")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXBDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXBQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXBWYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXDQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXWDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVSXWQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXBDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXBQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXBWYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXDQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXWDYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPMOVZXWQYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPSADBWYrr")>; -def: InstRW<[SKLWriteResGroup30], (instregex "VPSADBWrr")>; +def: InstRW<[SKLWriteResGroup30], (instregex "ADD_FPrST0", + "ADD_FST0r", + "ADD_FrST0", + "MMX_PSADBWirr", + "PCMPGTQrr", + "PSADBWrr", + "SUBR_FPrST0", + "SUBR_FST0r", + "SUBR_FrST0", + "SUB_FPrST0", + "SUB_FST0r", + "SUB_FrST0", + "VBROADCASTSDYrr", + "VBROADCASTSSYrr", + "VEXTRACTF128rr", + "VEXTRACTI128rr", + "VINSERTF128rr", + "VINSERTI128rr", + "VPBROADCASTBYrr", + "VPBROADCASTBrr", + "VPBROADCASTDYrr", + "VPBROADCASTQYrr", + "VPBROADCASTWYrr", + "VPBROADCASTWrr", + "VPCMPGTQYrr", + "VPCMPGTQrr", + "VPERM2F128rr", + "VPERM2I128rr", + "VPERMDYrr", + "VPERMPDYri", + "VPERMPSYrr", + "VPERMQYri", + "VPMOVSXBDYrr", + "VPMOVSXBQYrr", + "VPMOVSXBWYrr", + "VPMOVSXDQYrr", + "VPMOVSXWDYrr", + "VPMOVSXWQYrr", + "VPMOVZXBDYrr", + "VPMOVZXBQYrr", + "VPMOVZXBWYrr", + "VPMOVZXDQYrr", + "VPMOVZXWDYrr", + "VPMOVZXWQYrr", + "VPSADBWYrr", + "VPSADBWrr")>; def SKLWriteResGroup31 : SchedWriteRes<[SKLPort0,SKLPort5]> { let Latency = 3; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup31], (instregex "EXTRACTPSrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "MMX_PEXTRWrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "PEXTRBrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "PEXTRDrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "PEXTRQrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "PEXTRWrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "PTESTrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VEXTRACTPSrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPEXTRBrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPEXTRDrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPEXTRQrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPEXTRWrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPTESTYrr")>; -def: InstRW<[SKLWriteResGroup31], (instregex "VPTESTrr")>; +def: InstRW<[SKLWriteResGroup31], (instregex "EXTRACTPSrr", + "MMX_PEXTRWrr", + "PEXTRBrr", + "PEXTRDrr", + "PEXTRQrr", + "PEXTRWrr", + "PTESTrr", + "VEXTRACTPSrr", + "VPEXTRBrr", + "VPEXTRDrr", + "VPEXTRQrr", + "VPEXTRWrr", + "VPTESTYrr", + "VPTESTrr")>; def SKLWriteResGroup32 : SchedWriteRes<[SKLPort0,SKLPort0156]> { let Latency = 3; @@ -1244,76 +1243,76 @@ def SKLWriteResGroup33 : SchedWriteRes<[SKLPort06]> { let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKLWriteResGroup33], (instregex "ROL(8|16|32|64)rCL")>; -def: InstRW<[SKLWriteResGroup33], (instregex "ROR(8|16|32|64)rCL")>; -def: InstRW<[SKLWriteResGroup33], (instregex "SAR(8|16|32|64)rCL")>; -def: InstRW<[SKLWriteResGroup33], (instregex "SHL(8|16|32|64)rCL")>; -def: InstRW<[SKLWriteResGroup33], (instregex "SHR(8|16|32|64)rCL")>; +def: InstRW<[SKLWriteResGroup33], (instregex "ROL(8|16|32|64)rCL", + "ROR(8|16|32|64)rCL", + "SAR(8|16|32|64)rCL", + "SHL(8|16|32|64)rCL", + "SHR(8|16|32|64)rCL")>; def SKLWriteResGroup34 : SchedWriteRes<[SKLPort0156]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKLWriteResGroup34], (instregex "XADD(8|16|32|64)rr")>; -def: InstRW<[SKLWriteResGroup34], (instregex "XCHG8rr")>; +def: InstRW<[SKLWriteResGroup34], (instregex "XADD(8|16|32|64)rr", + "XCHG8rr")>; def SKLWriteResGroup35 : SchedWriteRes<[SKLPort0,SKLPort5]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup35], (instregex "MMX_PHADDSWrr")>; -def: InstRW<[SKLWriteResGroup35], (instregex "MMX_PHSUBSWrr")>; +def: InstRW<[SKLWriteResGroup35], (instregex "MMX_PHADDSWrr", + "MMX_PHSUBSWrr")>; def SKLWriteResGroup36 : SchedWriteRes<[SKLPort5,SKLPort01]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup36], (instregex "PHADDSWrr")>; -def: InstRW<[SKLWriteResGroup36], (instregex "PHSUBSWrr")>; -def: InstRW<[SKLWriteResGroup36], (instregex "VPHADDSWrr")>; -def: InstRW<[SKLWriteResGroup36], (instregex "VPHADDSWYrr")>; -def: InstRW<[SKLWriteResGroup36], (instregex "VPHSUBSWrr")>; -def: InstRW<[SKLWriteResGroup36], (instregex "VPHSUBSWYrr")>; +def: InstRW<[SKLWriteResGroup36], (instregex "PHADDSWrr", + "PHSUBSWrr", + "VPHADDSWrr", + "VPHADDSWYrr", + "VPHSUBSWrr", + "VPHSUBSWYrr")>; def SKLWriteResGroup37 : SchedWriteRes<[SKLPort5,SKLPort05]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup37], (instregex "MMX_PHADDDrr")>; -def: InstRW<[SKLWriteResGroup37], (instregex "MMX_PHADDWrr")>; -def: InstRW<[SKLWriteResGroup37], (instregex "MMX_PHSUBDrr")>; -def: InstRW<[SKLWriteResGroup37], (instregex "MMX_PHSUBWrr")>; +def: InstRW<[SKLWriteResGroup37], (instregex "MMX_PHADDDrr", + "MMX_PHADDWrr", + "MMX_PHSUBDrr", + "MMX_PHSUBWrr")>; def SKLWriteResGroup38 : SchedWriteRes<[SKLPort5,SKLPort015]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup38], (instregex "PHADDDrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "PHADDWrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "PHSUBDrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "PHSUBWrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHADDDYrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHADDDrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHADDWYrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHADDWrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHSUBDYrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHSUBDrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHSUBWYrr")>; -def: InstRW<[SKLWriteResGroup38], (instregex "VPHSUBWrr")>; +def: InstRW<[SKLWriteResGroup38], (instregex "PHADDDrr", + "PHADDWrr", + "PHSUBDrr", + "PHSUBWrr", + "VPHADDDYrr", + "VPHADDDrr", + "VPHADDWYrr", + "VPHADDWrr", + "VPHSUBDYrr", + "VPHSUBDrr", + "VPHSUBWYrr", + "VPHSUBWrr")>; def SKLWriteResGroup39 : SchedWriteRes<[SKLPort5,SKLPort0156]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup39], (instregex "MMX_PACKSSDWirr")>; -def: InstRW<[SKLWriteResGroup39], (instregex "MMX_PACKSSWBirr")>; -def: InstRW<[SKLWriteResGroup39], (instregex "MMX_PACKUSWBirr")>; +def: InstRW<[SKLWriteResGroup39], (instregex "MMX_PACKSSDWirr", + "MMX_PACKSSWBirr", + "MMX_PACKUSWBirr")>; def SKLWriteResGroup40 : SchedWriteRes<[SKLPort6,SKLPort0156]> { let Latency = 3; @@ -1334,10 +1333,10 @@ def SKLWriteResGroup42 : SchedWriteRes<[SKLPort06,SKLPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup42], (instregex "RCL(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup42], (instregex "RCL(8|16|32|64)ri")>; -def: InstRW<[SKLWriteResGroup42], (instregex "RCR(8|16|32|64)r1")>; -def: InstRW<[SKLWriteResGroup42], (instregex "RCR(8|16|32|64)ri")>; +def: InstRW<[SKLWriteResGroup42], (instregex "RCL(8|16|32|64)r1", + "RCL(8|16|32|64)ri", + "RCR(8|16|32|64)r1", + "RCR(8|16|32|64)ri")>; def SKLWriteResGroup43 : SchedWriteRes<[SKLPort0,SKLPort4,SKLPort237]> { let Latency = 3; @@ -1372,76 +1371,76 @@ def SKLWriteResGroup47 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup47], (instregex "AESDECLASTrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "AESDECrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "AESENCLASTrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "AESENCrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMADDUBSWrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMADDWDirr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMULHRSWrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMULHUWirr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMULHWirr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMULLWirr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MMX_PMULUDQirr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MUL_FPrST0")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MUL_FST0r")>; -def: InstRW<[SKLWriteResGroup47], (instregex "MUL_FrST0")>; -def: InstRW<[SKLWriteResGroup47], (instregex "RCPPSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "RCPSSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "RSQRTPSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "RSQRTSSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VAESDECLASTrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VAESDECrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VAESENCLASTrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VAESENCrr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRCPPSYr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRCPPSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRCPSSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRSQRTPSYr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRSQRTPSr")>; -def: InstRW<[SKLWriteResGroup47], (instregex "VRSQRTSSr")>; +def: InstRW<[SKLWriteResGroup47], (instregex "AESDECLASTrr", + "AESDECrr", + "AESENCLASTrr", + "AESENCrr", + "MMX_PMADDUBSWrr", + "MMX_PMADDWDirr", + "MMX_PMULHRSWrr", + "MMX_PMULHUWirr", + "MMX_PMULHWirr", + "MMX_PMULLWirr", + "MMX_PMULUDQirr", + "MUL_FPrST0", + "MUL_FST0r", + "MUL_FrST0", + "RCPPSr", + "RCPSSr", + "RSQRTPSr", + "RSQRTSSr", + "VAESDECLASTrr", + "VAESDECrr", + "VAESENCLASTrr", + "VAESENCrr", + "VRCPPSYr", + "VRCPPSr", + "VRCPSSr", + "VRSQRTPSYr", + "VRSQRTPSr", + "VRSQRTSSr")>; def SKLWriteResGroup48 : SchedWriteRes<[SKLPort01]> { let Latency = 4; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup48], (instregex "ADDPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "ADDPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "ADDSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "ADDSSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "ADDSUBPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "ADDSUBPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "MULPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "MULPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "MULSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "MULSSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "SUBPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "SUBPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "SUBSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "SUBSSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDPDYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDPSYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSUBPDYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSUBPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSUBPSYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VADDSUBPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULPDYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULPSYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VMULSSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBPDYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBPDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBPSYrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBPSrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBSDrr")>; -def: InstRW<[SKLWriteResGroup48], (instregex "VSUBSSrr")>; +def: InstRW<[SKLWriteResGroup48], (instregex "ADDPDrr", + "ADDPSrr", + "ADDSDrr", + "ADDSSrr", + "ADDSUBPDrr", + "ADDSUBPSrr", + "MULPDrr", + "MULPSrr", + "MULSDrr", + "MULSSrr", + "SUBPDrr", + "SUBPSrr", + "SUBSDrr", + "SUBSSrr", + "VADDPDYrr", + "VADDPDrr", + "VADDPSYrr", + "VADDPSrr", + "VADDSDrr", + "VADDSSrr", + "VADDSUBPDYrr", + "VADDSUBPDrr", + "VADDSUBPSYrr", + "VADDSUBPSrr", + "VMULPDYrr", + "VMULPDrr", + "VMULPSYrr", + "VMULPSrr", + "VMULSDrr", + "VMULSSrr", + "VSUBPDYrr", + "VSUBPDrr", + "VSUBPSYrr", + "VSUBPSrr", + "VSUBSDrr", + "VSUBSSrr")>; def: InstRW<[SKLWriteResGroup48], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)(Y)?r", @@ -1452,124 +1451,122 @@ def SKLWriteResGroup49 : SchedWriteRes<[SKLPort015]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup49], (instregex "CMPPDrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CMPPSrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CMPSDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CMPSSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CVTDQ2PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CVTPS2DQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "CVTTPS2DQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MAX(C?)PDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MAX(C?)PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MAX(C?)SDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MAX(C?)SSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MIN(C?)PDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MIN(C?)PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MIN(C?)SDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "MIN(C?)SSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PHMINPOSUWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMADDUBSWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMADDWDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULDQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULHRSWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULHUWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULHWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULLWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "PMULUDQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPPDYrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPPDrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPPSYrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPPSrri")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPSDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCMPSSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTDQ2PSYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTDQ2PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTPS2DQYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTPS2DQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTTPS2DQYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VCVTTPS2DQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)PDYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)PDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)PSYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)SDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMAX(C?)SSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)PDYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)PDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)PSYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)PSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)SDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VMIN(C?)SSrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPHMINPOSUWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMADDUBSWYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMADDUBSWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMADDWDYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMADDWDrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULDQYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULDQrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHRSWYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHRSWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHUWYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHUWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHWYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULHWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULLWYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULLWrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULUDQYrr")>; -def: InstRW<[SKLWriteResGroup49], (instregex "VPMULUDQrr")>; +def: InstRW<[SKLWriteResGroup49], (instregex "CMPPDrri", + "CMPPSrri", + "CMPSDrr", + "CMPSSrr", + "CVTDQ2PSrr", + "CVTPS2DQrr", + "CVTTPS2DQrr", + "MAX(C?)PDrr", + "MAX(C?)PSrr", + "MAX(C?)SDrr", + "MAX(C?)SSrr", + "MIN(C?)PDrr", + "MIN(C?)PSrr", + "MIN(C?)SDrr", + "MIN(C?)SSrr", + "PHMINPOSUWrr", + "PMADDUBSWrr", + "PMADDWDrr", + "PMULDQrr", + "PMULHRSWrr", + "PMULHUWrr", + "PMULHWrr", + "PMULLWrr", + "PMULUDQrr", + "VCMPPDYrri", + "VCMPPDrri", + "VCMPPSYrri", + "VCMPPSrri", + "VCMPSDrr", + "VCMPSSrr", + "VCVTDQ2PSYrr", + "VCVTDQ2PSrr", + "VCVTPS2DQYrr", + "VCVTPS2DQrr", + "VCVTTPS2DQYrr", + "VCVTTPS2DQrr", + "VMAX(C?)PDYrr", + "VMAX(C?)PDrr", + "VMAX(C?)PSYrr", + "VMAX(C?)PSrr", + "VMAX(C?)SDrr", + "VMAX(C?)SSrr", + "VMIN(C?)PDYrr", + "VMIN(C?)PDrr", + "VMIN(C?)PSYrr", + "VMIN(C?)PSrr", + "VMIN(C?)SDrr", + "VMIN(C?)SSrr", + "VPHMINPOSUWrr", + "VPMADDUBSWYrr", + "VPMADDUBSWrr", + "VPMADDWDYrr", + "VPMADDWDrr", + "VPMULDQYrr", + "VPMULDQrr", + "VPMULHRSWYrr", + "VPMULHRSWrr", + "VPMULHUWYrr", + "VPMULHUWrr", + "VPMULHWYrr", + "VPMULHWrr", + "VPMULLWYrr", + "VPMULLWrr", + "VPMULUDQYrr", + "VPMULUDQrr")>; def SKLWriteResGroup50 : SchedWriteRes<[SKLPort5]> { let Latency = 4; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup50], (instregex "MPSADBWrri")>; -def: InstRW<[SKLWriteResGroup50], (instregex "VMPSADBWYrri")>; -def: InstRW<[SKLWriteResGroup50], (instregex "VMPSADBWrri")>; +def: InstRW<[SKLWriteResGroup50], (instregex "MPSADBWrri", + "VMPSADBWYrri", + "VMPSADBWrri")>; def SKLWriteResGroup51 : SchedWriteRes<[SKLPort1,SKLPort5]> { let Latency = 4; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup51], (instrs IMUL64r)>; -def: InstRW<[SKLWriteResGroup51], (instrs MUL64r)>; -def: InstRW<[SKLWriteResGroup51], (instrs MULX64rr)>; +def: InstRW<[SKLWriteResGroup51], (instrs IMUL64r, MUL64r, + MULX64rr)>; def SKLWriteResGroup51_16 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort0156]> { let Latency = 4; let NumMicroOps = 4; } -def: InstRW<[SKLWriteResGroup51_16], (instrs IMUL16r)>; -def: InstRW<[SKLWriteResGroup51_16], (instrs MUL16r)>; +def: InstRW<[SKLWriteResGroup51_16], (instrs IMUL16r, MUL16r)>; def SKLWriteResGroup52 : SchedWriteRes<[SKLPort5,SKLPort01]> { let Latency = 4; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup52], (instregex "VPSLLDYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSLLQYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSLLWYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSRADYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSRAWYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSRLDYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSRLQYrr")>; -def: InstRW<[SKLWriteResGroup52], (instregex "VPSRLWYrr")>; +def: InstRW<[SKLWriteResGroup52], (instregex "VPSLLDYrr", + "VPSLLQYrr", + "VPSLLWYrr", + "VPSRADYrr", + "VPSRAWYrr", + "VPSRLDYrr", + "VPSRLQYrr", + "VPSRLWYrr")>; def SKLWriteResGroup53 : SchedWriteRes<[SKLPort4,SKLPort5,SKLPort237]> { let Latency = 4; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup53], (instregex "ISTT_FP16m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "ISTT_FP32m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "ISTT_FP64m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "IST_F16m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "IST_F32m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "IST_FP16m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "IST_FP32m")>; -def: InstRW<[SKLWriteResGroup53], (instregex "IST_FP64m")>; +def: InstRW<[SKLWriteResGroup53], (instregex "ISTT_FP16m", + "ISTT_FP32m", + "ISTT_FP64m", + "IST_F16m", + "IST_F32m", + "IST_FP16m", + "IST_FP32m", + "IST_FP64m")>; def SKLWriteResGroup54 : SchedWriteRes<[SKLPort0156]> { let Latency = 4; @@ -1604,70 +1601,70 @@ def SKLWriteResGroup58 : SchedWriteRes<[SKLPort23]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup58], (instregex "MMX_MOVD64rm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MMX_MOVD64to64rm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MMX_MOVQ64rm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOV(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOV64toPQIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVDDUPrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVDI2PDIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVQI2PQIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVSDrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVSSrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVSX(16|32|64)rm16")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVSX(16|32|64)rm32")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVSX(16|32|64)rm8")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVZX(16|32|64)rm16")>; -def: InstRW<[SKLWriteResGroup58], (instregex "MOVZX(16|32|64)rm8")>; -def: InstRW<[SKLWriteResGroup58], (instregex "PREFETCHNTA")>; -def: InstRW<[SKLWriteResGroup58], (instregex "PREFETCHT0")>; -def: InstRW<[SKLWriteResGroup58], (instregex "PREFETCHT1")>; -def: InstRW<[SKLWriteResGroup58], (instregex "PREFETCHT2")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOV64toPQIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOVDDUPrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOVDI2PDIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOVQI2PQIrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOVSDrm")>; -def: InstRW<[SKLWriteResGroup58], (instregex "VMOVSSrm")>; +def: InstRW<[SKLWriteResGroup58], (instregex "MMX_MOVD64rm", + "MMX_MOVD64to64rm", + "MMX_MOVQ64rm", + "MOV(8|16|32|64)rm", + "MOV64toPQIrm", + "MOVDDUPrm", + "MOVDI2PDIrm", + "MOVQI2PQIrm", + "MOVSDrm", + "MOVSSrm", + "MOVSX(16|32|64)rm16", + "MOVSX(16|32|64)rm32", + "MOVSX(16|32|64)rm8", + "MOVZX(16|32|64)rm16", + "MOVZX(16|32|64)rm8", + "PREFETCHNTA", + "PREFETCHT0", + "PREFETCHT1", + "PREFETCHT2", + "VMOV64toPQIrm", + "VMOVDDUPrm", + "VMOVDI2PDIrm", + "VMOVQI2PQIrm", + "VMOVSDrm", + "VMOVSSrm")>; def SKLWriteResGroup59 : SchedWriteRes<[SKLPort0,SKLPort5]> { let Latency = 5; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup59], (instregex "CVTDQ2PDrr")>; -def: InstRW<[SKLWriteResGroup59], (instregex "MMX_CVTPI2PDirr")>; -def: InstRW<[SKLWriteResGroup59], (instregex "VCVTDQ2PDrr")>; +def: InstRW<[SKLWriteResGroup59], (instregex "CVTDQ2PDrr", + "MMX_CVTPI2PDirr", + "VCVTDQ2PDrr")>; def SKLWriteResGroup60 : SchedWriteRes<[SKLPort5,SKLPort015]> { let Latency = 5; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup60], (instregex "CVTPD2DQrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTPD2PSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTPS2PDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTSD2SSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTSI642SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTSI2SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTSI2SSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTSS2SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "CVTTPD2DQrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "MMX_CVTPD2PIirr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "MMX_CVTPS2PIirr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "MMX_CVTTPD2PIirr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "MMX_CVTTPS2PIirr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTPD2DQrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTPD2PSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTPH2PSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTPS2PDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTPS2PHrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTSD2SSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTSI642SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTSI2SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTSI2SSrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTSS2SDrr")>; -def: InstRW<[SKLWriteResGroup60], (instregex "VCVTTPD2DQrr")>; +def: InstRW<[SKLWriteResGroup60], (instregex "CVTPD2DQrr", + "CVTPD2PSrr", + "CVTPS2PDrr", + "CVTSD2SSrr", + "CVTSI642SDrr", + "CVTSI2SDrr", + "CVTSI2SSrr", + "CVTSS2SDrr", + "CVTTPD2DQrr", + "MMX_CVTPD2PIirr", + "MMX_CVTPS2PIirr", + "MMX_CVTTPD2PIirr", + "MMX_CVTTPS2PIirr", + "VCVTPD2DQrr", + "VCVTPD2PSrr", + "VCVTPH2PSrr", + "VCVTPS2PDrr", + "VCVTPS2PHrr", + "VCVTSD2SSrr", + "VCVTSI642SDrr", + "VCVTSI2SDrr", + "VCVTSI2SSrr", + "VCVTSS2SDrr", + "VCVTTPD2DQrr")>; def SKLWriteResGroup61 : SchedWriteRes<[SKLPort1,SKLPort6,SKLPort06]> { let Latency = 5; @@ -1681,8 +1678,7 @@ def SKLWriteResGroup62 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup62], (instrs IMUL32r)>; -def: InstRW<[SKLWriteResGroup62], (instrs MUL32r)>; +def: InstRW<[SKLWriteResGroup62], (instrs IMUL32r, MUL32r)>; def: InstRW<[SKLWriteResGroup62], (instrs MULX32rr)>; def SKLWriteResGroup63 : SchedWriteRes<[SKLPort06,SKLPort0156]> { @@ -1704,45 +1700,44 @@ def SKLWriteResGroup65 : SchedWriteRes<[SKLPort4,SKLPort237,SKLPort0156]> { let NumMicroOps = 6; let ResourceCycles = [1,1,4]; } -def: InstRW<[SKLWriteResGroup65], (instregex "PUSHF16")>; -def: InstRW<[SKLWriteResGroup65], (instregex "PUSHF64")>; +def: InstRW<[SKLWriteResGroup65], (instregex "PUSHF16", + "PUSHF64")>; def SKLWriteResGroup66 : SchedWriteRes<[SKLPort5]> { let Latency = 6; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup66], (instregex "PCLMULQDQrr")>; -def: InstRW<[SKLWriteResGroup66], (instregex "VPCLMULQDQrr")>; +def: InstRW<[SKLWriteResGroup66], (instregex "(V?)PCLMULQDQrr")>; def SKLWriteResGroup67 : SchedWriteRes<[SKLPort23]> { let Latency = 6; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup67], (instregex "LDDQUrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVAPDrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVAPSrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVDQArm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVDQUrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVNTDQArm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVSHDUPrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVSLDUPrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVUPDrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "MOVUPSrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VBROADCASTSSrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VLDDQUrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVAPDrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVAPSrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVDQArm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVDQUrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVNTDQArm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVSHDUPrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVSLDUPrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVUPDrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VMOVUPSrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VPBROADCASTDrm")>; -def: InstRW<[SKLWriteResGroup67], (instregex "VPBROADCASTQrm")>; +def: InstRW<[SKLWriteResGroup67], (instregex "LDDQUrm", + "MOVAPDrm", + "MOVAPSrm", + "MOVDQArm", + "MOVDQUrm", + "MOVNTDQArm", + "MOVSHDUPrm", + "MOVSLDUPrm", + "MOVUPDrm", + "MOVUPSrm", + "VBROADCASTSSrm", + "VLDDQUrm", + "VMOVAPDrm", + "VMOVAPSrm", + "VMOVDQArm", + "VMOVDQUrm", + "VMOVNTDQArm", + "VMOVSHDUPrm", + "VMOVSLDUPrm", + "VMOVUPDrm", + "VMOVUPSrm", + "VPBROADCASTDrm", + "VPBROADCASTQrm")>; def SKLWriteResGroup68 : SchedWriteRes<[SKLPort0]> { let Latency = 6; @@ -1756,220 +1751,219 @@ def SKLWriteResGroup69 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PADDSBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PADDSWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PADDUSBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PADDUSWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PAVGBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PAVGWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPEQBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPEQDirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPEQWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPGTBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPGTDirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PCMPGTWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PMAXSWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PMAXUBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PMINSWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PMINUBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSLLDrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSLLQrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSLLWrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSRADrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSRAWrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSRLDrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSRLQrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSRLWrm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSUBSBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSUBSWirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSUBUSBirm")>; -def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PSUBUSWirm")>; +def: InstRW<[SKLWriteResGroup69], (instregex "MMX_PADDSBirm", + "MMX_PADDSWirm", + "MMX_PADDUSBirm", + "MMX_PADDUSWirm", + "MMX_PAVGBirm", + "MMX_PAVGWirm", + "MMX_PCMPEQBirm", + "MMX_PCMPEQDirm", + "MMX_PCMPEQWirm", + "MMX_PCMPGTBirm", + "MMX_PCMPGTDirm", + "MMX_PCMPGTWirm", + "MMX_PMAXSWirm", + "MMX_PMAXUBirm", + "MMX_PMINSWirm", + "MMX_PMINUBirm", + "MMX_PSLLDrm", + "MMX_PSLLQrm", + "MMX_PSLLWrm", + "MMX_PSRADrm", + "MMX_PSRAWrm", + "MMX_PSRLDrm", + "MMX_PSRLQrm", + "MMX_PSRLWrm", + "MMX_PSUBSBirm", + "MMX_PSUBSWirm", + "MMX_PSUBUSBirm", + "MMX_PSUBUSWirm")>; def SKLWriteResGroup70 : SchedWriteRes<[SKLPort0,SKLPort015]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup70], (instregex "CVTSD2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "CVTSD2SIrr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "CVTSS2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "CVTSS2SIrr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "CVTTSD2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "CVTTSD2SIrr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTSD2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTSD2SIrr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTSS2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTSS2SIrr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTTSD2SI64rr")>; -def: InstRW<[SKLWriteResGroup70], (instregex "VCVTTSD2SIrr")>; +def: InstRW<[SKLWriteResGroup70], (instregex "CVTSD2SI64rr", + "CVTSD2SIrr", + "CVTSS2SI64rr", + "CVTSS2SIrr", + "CVTTSD2SI64rr", + "CVTTSD2SIrr", + "VCVTSD2SI64rr", + "VCVTSD2SIrr", + "VCVTSS2SI64rr", + "VCVTSS2SIrr", + "VCVTTSD2SI64rr", + "VCVTTSD2SIrr")>; def SKLWriteResGroup71 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PALIGNRrmi")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PINSRWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PSHUFBrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PSHUFWmi")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKHBWirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKHDQirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKHWDirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKLBWirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKLDQirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PUNPCKLWDirm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MOVHPDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MOVHPSrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MOVLPDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "MOVLPSrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PINSRBrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PINSRDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PINSRQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PINSRWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXBDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXBQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXBWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXDQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXWDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVSXWQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXBDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXBQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXBWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXDQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXWDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "PMOVZXWQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VMOVHPDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VMOVHPSrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VMOVLPDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VMOVLPSrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPINSRBrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPINSRDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPINSRQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPINSRWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXBDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXBQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXBWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXDQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXWDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVSXWQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXBDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXBQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXBWrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXDQrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXWDrm")>; -def: InstRW<[SKLWriteResGroup71], (instregex "VPMOVZXWQrm")>; +def: InstRW<[SKLWriteResGroup71], (instregex "MMX_PALIGNRrmi", + "MMX_PINSRWrm", + "MMX_PSHUFBrm", + "MMX_PSHUFWmi", + "MMX_PUNPCKHBWirm", + "MMX_PUNPCKHDQirm", + "MMX_PUNPCKHWDirm", + "MMX_PUNPCKLBWirm", + "MMX_PUNPCKLDQirm", + "MMX_PUNPCKLWDirm", + "MOVHPDrm", + "MOVHPSrm", + "MOVLPDrm", + "MOVLPSrm", + "PINSRBrm", + "PINSRDrm", + "PINSRQrm", + "PINSRWrm", + "PMOVSXBDrm", + "PMOVSXBQrm", + "PMOVSXBWrm", + "PMOVSXDQrm", + "PMOVSXWDrm", + "PMOVSXWQrm", + "PMOVZXBDrm", + "PMOVZXBQrm", + "PMOVZXBWrm", + "PMOVZXDQrm", + "PMOVZXWDrm", + "PMOVZXWQrm", + "VMOVHPDrm", + "VMOVHPSrm", + "VMOVLPDrm", + "VMOVLPSrm", + "VPINSRBrm", + "VPINSRDrm", + "VPINSRQrm", + "VPINSRWrm", + "VPMOVSXBDrm", + "VPMOVSXBQrm", + "VPMOVSXBWrm", + "VPMOVSXDQrm", + "VPMOVSXWDrm", + "VPMOVSXWQrm", + "VPMOVZXBDrm", + "VPMOVZXBQrm", + "VPMOVZXBWrm", + "VPMOVZXDQrm", + "VPMOVZXWDrm", + "VPMOVZXWQrm")>; def SKLWriteResGroup72 : SchedWriteRes<[SKLPort6,SKLPort23]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup72], (instregex "FARJMP64")>; -def: InstRW<[SKLWriteResGroup72], (instregex "JMP(16|32|64)m")>; +def: InstRW<[SKLWriteResGroup72], (instregex "FARJMP64", + "JMP(16|32|64)m")>; def SKLWriteResGroup73 : SchedWriteRes<[SKLPort23,SKLPort05]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PABSBrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PABSDrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PABSWrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PADDBirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PADDDirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PADDQirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PADDWirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PANDNirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PANDirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PORirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSIGNBrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSIGNDrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSIGNWrm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSUBBirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSUBDirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSUBQirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PSUBWirm")>; -def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PXORirm")>; +def: InstRW<[SKLWriteResGroup73], (instregex "MMX_PABSBrm", + "MMX_PABSDrm", + "MMX_PABSWrm", + "MMX_PADDBirm", + "MMX_PADDDirm", + "MMX_PADDQirm", + "MMX_PADDWirm", + "MMX_PANDNirm", + "MMX_PANDirm", + "MMX_PORirm", + "MMX_PSIGNBrm", + "MMX_PSIGNDrm", + "MMX_PSIGNWrm", + "MMX_PSUBBirm", + "MMX_PSUBDirm", + "MMX_PSUBQirm", + "MMX_PSUBWirm", + "MMX_PXORirm")>; def SKLWriteResGroup74 : SchedWriteRes<[SKLPort23,SKLPort06]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup74], (instregex "ADC(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "ADCX(32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "ADOX(32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "BT(16|32|64)mi8")>; -def: InstRW<[SKLWriteResGroup74], (instregex "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "RORX(32|64)mi")>; -def: InstRW<[SKLWriteResGroup74], (instregex "SARX(32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "SBB(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "SHLX(32|64)rm")>; -def: InstRW<[SKLWriteResGroup74], (instregex "SHRX(32|64)rm")>; +def: InstRW<[SKLWriteResGroup74], (instregex "ADC(8|16|32|64)rm", + "ADCX(32|64)rm", + "ADOX(32|64)rm", + "BT(16|32|64)mi8", + "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rm", + "RORX(32|64)mi", + "SARX(32|64)rm", + "SBB(8|16|32|64)rm", + "SHLX(32|64)rm", + "SHRX(32|64)rm")>; def SKLWriteResGroup75 : SchedWriteRes<[SKLPort23,SKLPort15]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup75], (instregex "ANDN(32|64)rm")>; -def: InstRW<[SKLWriteResGroup75], (instregex "BLSI(32|64)rm")>; -def: InstRW<[SKLWriteResGroup75], (instregex "BLSMSK(32|64)rm")>; -def: InstRW<[SKLWriteResGroup75], (instregex "BLSR(32|64)rm")>; -def: InstRW<[SKLWriteResGroup75], (instregex "BZHI(32|64)rm")>; -def: InstRW<[SKLWriteResGroup75], (instregex "MOVBE(16|32|64)rm")>; +def: InstRW<[SKLWriteResGroup75], (instregex "ANDN(32|64)rm", + "BLSI(32|64)rm", + "BLSMSK(32|64)rm", + "BLSR(32|64)rm", + "BZHI(32|64)rm", + "MOVBE(16|32|64)rm")>; def SKLWriteResGroup76 : SchedWriteRes<[SKLPort23,SKLPort0156]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup76], (instregex "ADD(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup76], (instregex "AND(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup76], (instregex "CMP(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup76], (instregex "CMP(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup76], (instregex "CMP(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup76], (instregex "OR(8|16|32|64)rm")>; def: InstRW<[SKLWriteResGroup76], (instrs POP16r, POP32r, POP64r)>; -def: InstRW<[SKLWriteResGroup76], (instregex "POP(16|32|64)rmr")>; -def: InstRW<[SKLWriteResGroup76], (instregex "SUB(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup76], (instregex "TEST(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup76], (instregex "TEST(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup76], (instregex "XOR(8|16|32|64)rm")>; +def: InstRW<[SKLWriteResGroup76], (instregex "ADD(8|16|32|64)rm", + "AND(8|16|32|64)rm", + "CMP(8|16|32|64)mi", + "CMP(8|16|32|64)mr", + "CMP(8|16|32|64)rm", + "OR(8|16|32|64)rm", + "POP(16|32|64)rmr", + "SUB(8|16|32|64)rm", + "TEST(8|16|32|64)mr", + "TEST(8|16|32|64)mi", + "XOR(8|16|32|64)rm")>; def SKLWriteResGroup77 : SchedWriteRes<[SKLPort5,SKLPort01]> { let Latency = 6; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup77], (instregex "HADDPDrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "HADDPSrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "HSUBPDrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "HSUBPSrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHADDPDYrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHADDPDrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHADDPSYrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHADDPSrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHSUBPDYrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHSUBPDrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHSUBPSYrr")>; -def: InstRW<[SKLWriteResGroup77], (instregex "VHSUBPSrr")>; +def: InstRW<[SKLWriteResGroup77], (instregex "HADDPDrr", + "HADDPSrr", + "HSUBPDrr", + "HSUBPSrr", + "VHADDPDYrr", + "VHADDPDrr", + "VHADDPSYrr", + "VHADDPSrr", + "VHSUBPDYrr", + "VHSUBPDrr", + "VHSUBPSYrr", + "VHSUBPSrr")>; def SKLWriteResGroup78 : SchedWriteRes<[SKLPort5,SKLPort015]> { let Latency = 6; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup78], (instregex "CVTSI642SSrr")>; -def: InstRW<[SKLWriteResGroup78], (instregex "VCVTSI642SSrr")>; +def: InstRW<[SKLWriteResGroup78], (instregex "(V?)CVTSI642SSrr")>; def SKLWriteResGroup79 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort0156]> { let Latency = 6; let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKLWriteResGroup79], (instregex "SHLD(16|32|64)rrCL")>; -def: InstRW<[SKLWriteResGroup79], (instregex "SHRD(16|32|64)rrCL")>; +def: InstRW<[SKLWriteResGroup79], (instregex "SHLD(16|32|64)rrCL", + "SHRD(16|32|64)rrCL")>; def SKLWriteResGroup80 : SchedWriteRes<[SKLPort1,SKLPort6,SKLPort06,SKLPort0156]> { let Latency = 6; @@ -1990,37 +1984,37 @@ def SKLWriteResGroup82 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06] let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKLWriteResGroup82], (instregex "BTC(16|32|64)mi8")>; -def: InstRW<[SKLWriteResGroup82], (instregex "BTR(16|32|64)mi8")>; -def: InstRW<[SKLWriteResGroup82], (instregex "BTS(16|32|64)mi8")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SAR(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SAR(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SHL(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SHL(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SHR(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup82], (instregex "SHR(8|16|32|64)mi")>; +def: InstRW<[SKLWriteResGroup82], (instregex "BTC(16|32|64)mi8", + "BTR(16|32|64)mi8", + "BTS(16|32|64)mi8", + "SAR(8|16|32|64)m1", + "SAR(8|16|32|64)mi", + "SHL(8|16|32|64)m1", + "SHL(8|16|32|64)mi", + "SHR(8|16|32|64)m1", + "SHR(8|16|32|64)mi")>; def SKLWriteResGroup83 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort0156]> { let Latency = 6; let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKLWriteResGroup83], (instregex "ADD(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup83], (instregex "ADD(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup83], (instregex "AND(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup83], (instregex "AND(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup83], (instregex "DEC(8|16|32|64)m")>; -def: InstRW<[SKLWriteResGroup83], (instregex "INC(8|16|32|64)m")>; -def: InstRW<[SKLWriteResGroup83], (instregex "NEG(8|16|32|64)m")>; -def: InstRW<[SKLWriteResGroup83], (instregex "NOT(8|16|32|64)m")>; -def: InstRW<[SKLWriteResGroup83], (instregex "OR(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup83], (instregex "OR(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup83], (instregex "POP(16|32|64)rmm")>; -def: InstRW<[SKLWriteResGroup83], (instregex "PUSH(16|32|64)rmm")>; -def: InstRW<[SKLWriteResGroup83], (instregex "SUB(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup83], (instregex "SUB(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup83], (instregex "XOR(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup83], (instregex "XOR(8|16|32|64)mr")>; +def: InstRW<[SKLWriteResGroup83], (instregex "ADD(8|16|32|64)mi", + "ADD(8|16|32|64)mr", + "AND(8|16|32|64)mi", + "AND(8|16|32|64)mr", + "DEC(8|16|32|64)m", + "INC(8|16|32|64)m", + "NEG(8|16|32|64)m", + "NOT(8|16|32|64)m", + "OR(8|16|32|64)mi", + "OR(8|16|32|64)mr", + "POP(16|32|64)rmm", + "PUSH(16|32|64)rmm", + "SUB(8|16|32|64)mi", + "SUB(8|16|32|64)mr", + "XOR(8|16|32|64)mi", + "XOR(8|16|32|64)mr")>; def SKLWriteResGroup84 : SchedWriteRes<[SKLPort6,SKLPort0156]> { let Latency = 6; @@ -2034,26 +2028,26 @@ def SKLWriteResGroup85 : SchedWriteRes<[SKLPort23]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup85], (instregex "LD_F32m")>; -def: InstRW<[SKLWriteResGroup85], (instregex "LD_F64m")>; -def: InstRW<[SKLWriteResGroup85], (instregex "LD_F80m")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VBROADCASTF128")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VBROADCASTI128")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VBROADCASTSDYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VBROADCASTSSYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VLDDQUYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVAPDYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVAPSYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVDDUPYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVDQAYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVDQUYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVNTDQAYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVSHDUPYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVSLDUPYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVUPDYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VMOVUPSYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VPBROADCASTDYrm")>; -def: InstRW<[SKLWriteResGroup85], (instregex "VPBROADCASTQYrm")>; +def: InstRW<[SKLWriteResGroup85], (instregex "LD_F32m", + "LD_F64m", + "LD_F80m", + "VBROADCASTF128", + "VBROADCASTI128", + "VBROADCASTSDYrm", + "VBROADCASTSSYrm", + "VLDDQUYrm", + "VMOVAPDYrm", + "VMOVAPSYrm", + "VMOVDDUPYrm", + "VMOVDQAYrm", + "VMOVDQUYrm", + "VMOVNTDQAYrm", + "VMOVSHDUPYrm", + "VMOVSLDUPYrm", + "VMOVUPDYrm", + "VMOVUPSYrm", + "VPBROADCASTDYrm", + "VPBROADCASTQYrm")>; def SKLWriteResGroup86 : SchedWriteRes<[SKLPort0,SKLPort5]> { let Latency = 7; @@ -2067,251 +2061,251 @@ def SKLWriteResGroup87 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup87], (instregex "COMISDrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "COMISSrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "UCOMISDrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "UCOMISSrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "VCOMISDrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "VCOMISSrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "VUCOMISDrm")>; -def: InstRW<[SKLWriteResGroup87], (instregex "VUCOMISSrm")>; +def: InstRW<[SKLWriteResGroup87], (instregex "COMISDrm", + "COMISSrm", + "UCOMISDrm", + "UCOMISSrm", + "VCOMISDrm", + "VCOMISSrm", + "VUCOMISDrm", + "VUCOMISSrm")>; def SKLWriteResGroup88 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup88], (instregex "INSERTPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PACKSSDWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PACKSSWBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PACKUSDWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PACKUSWBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PALIGNRrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PBLENDWrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PSHUFBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PSHUFDmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PSHUFHWmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PSHUFLWmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKHBWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKHDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKHQDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKHWDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKLBWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKLDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKLQDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "PUNPCKLWDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "SHUFPDrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "SHUFPSrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "UNPCKHPDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "UNPCKHPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "UNPCKLPDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "UNPCKLPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VINSERTPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPACKSSDWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPACKSSWBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPACKUSDWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPACKUSWBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPALIGNRrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPBLENDWrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPBROADCASTBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPBROADCASTWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPERMILPDmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPERMILPDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPERMILPSmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPERMILPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPSHUFBrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPSHUFDmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPSHUFHWmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPSHUFLWmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKHBWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKHDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKHQDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKHWDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKLBWrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKLDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKLQDQrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VPUNPCKLWDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VSHUFPDrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VSHUFPSrmi")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VUNPCKHPDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VUNPCKHPSrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VUNPCKLPDrm")>; -def: InstRW<[SKLWriteResGroup88], (instregex "VUNPCKLPSrm")>; +def: InstRW<[SKLWriteResGroup88], (instregex "INSERTPSrm", + "PACKSSDWrm", + "PACKSSWBrm", + "PACKUSDWrm", + "PACKUSWBrm", + "PALIGNRrmi", + "PBLENDWrmi", + "PSHUFBrm", + "PSHUFDmi", + "PSHUFHWmi", + "PSHUFLWmi", + "PUNPCKHBWrm", + "PUNPCKHDQrm", + "PUNPCKHQDQrm", + "PUNPCKHWDrm", + "PUNPCKLBWrm", + "PUNPCKLDQrm", + "PUNPCKLQDQrm", + "PUNPCKLWDrm", + "SHUFPDrmi", + "SHUFPSrmi", + "UNPCKHPDrm", + "UNPCKHPSrm", + "UNPCKLPDrm", + "UNPCKLPSrm", + "VINSERTPSrm", + "VPACKSSDWrm", + "VPACKSSWBrm", + "VPACKUSDWrm", + "VPACKUSWBrm", + "VPALIGNRrmi", + "VPBLENDWrmi", + "VPBROADCASTBrm", + "VPBROADCASTWrm", + "VPERMILPDmi", + "VPERMILPDrm", + "VPERMILPSmi", + "VPERMILPSrm", + "VPSHUFBrm", + "VPSHUFDmi", + "VPSHUFHWmi", + "VPSHUFLWmi", + "VPUNPCKHBWrm", + "VPUNPCKHDQrm", + "VPUNPCKHQDQrm", + "VPUNPCKHWDrm", + "VPUNPCKLBWrm", + "VPUNPCKLDQrm", + "VPUNPCKLQDQrm", + "VPUNPCKLWDrm", + "VSHUFPDrmi", + "VSHUFPSrmi", + "VUNPCKHPDrm", + "VUNPCKHPSrm", + "VUNPCKLPDrm", + "VUNPCKLPSrm")>; def SKLWriteResGroup89 : SchedWriteRes<[SKLPort5,SKLPort015]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPD2DQYrr")>; -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPD2PSYrr")>; -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPH2PSYrr")>; -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPS2PDYrr")>; -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPS2PHYrr")>; -def: InstRW<[SKLWriteResGroup89], (instregex "VCVTTPD2DQYrr")>; +def: InstRW<[SKLWriteResGroup89], (instregex "VCVTPD2DQYrr", + "VCVTPD2PSYrr", + "VCVTPH2PSYrr", + "VCVTPS2PDYrr", + "VCVTPS2PHYrr", + "VCVTTPD2DQYrr")>; def SKLWriteResGroup90 : SchedWriteRes<[SKLPort01,SKLPort23]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup90], (instregex "PABSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PABSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PABSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PADDSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PADDSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PADDUSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PADDUSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PAVGBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PAVGWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPEQBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPEQDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPEQQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPEQWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPGTBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPGTDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PCMPGTWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXUBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXUDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMAXUWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINUBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINUDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PMINUWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSIGNBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSIGNDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSIGNWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSLLDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSLLQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSLLWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSRADrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSRAWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSRLDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSRLQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSRLWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSUBSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSUBSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSUBUSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "PSUBUSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPABSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPABSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPABSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPADDSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPADDSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPADDUSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPADDUSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPAVGBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPAVGWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPEQBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPEQDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPEQQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPEQWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPGTBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPGTDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPCMPGTWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXUBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXUDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMAXUWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINSDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINUBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINUDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPMINUWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSIGNBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSIGNDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSIGNWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSLLDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSLLQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSLLVDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSLLVQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSLLWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRADrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRAVDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRAWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRLDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRLQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRLVDrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRLVQrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSRLWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSUBSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSUBSWrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSUBUSBrm")>; -def: InstRW<[SKLWriteResGroup90], (instregex "VPSUBUSWrm")>; +def: InstRW<[SKLWriteResGroup90], (instregex "PABSBrm", + "PABSDrm", + "PABSWrm", + "PADDSBrm", + "PADDSWrm", + "PADDUSBrm", + "PADDUSWrm", + "PAVGBrm", + "PAVGWrm", + "PCMPEQBrm", + "PCMPEQDrm", + "PCMPEQQrm", + "PCMPEQWrm", + "PCMPGTBrm", + "PCMPGTDrm", + "PCMPGTWrm", + "PMAXSBrm", + "PMAXSDrm", + "PMAXSWrm", + "PMAXUBrm", + "PMAXUDrm", + "PMAXUWrm", + "PMINSBrm", + "PMINSDrm", + "PMINSWrm", + "PMINUBrm", + "PMINUDrm", + "PMINUWrm", + "PSIGNBrm", + "PSIGNDrm", + "PSIGNWrm", + "PSLLDrm", + "PSLLQrm", + "PSLLWrm", + "PSRADrm", + "PSRAWrm", + "PSRLDrm", + "PSRLQrm", + "PSRLWrm", + "PSUBSBrm", + "PSUBSWrm", + "PSUBUSBrm", + "PSUBUSWrm", + "VPABSBrm", + "VPABSDrm", + "VPABSWrm", + "VPADDSBrm", + "VPADDSWrm", + "VPADDUSBrm", + "VPADDUSWrm", + "VPAVGBrm", + "VPAVGWrm", + "VPCMPEQBrm", + "VPCMPEQDrm", + "VPCMPEQQrm", + "VPCMPEQWrm", + "VPCMPGTBrm", + "VPCMPGTDrm", + "VPCMPGTWrm", + "VPMAXSBrm", + "VPMAXSDrm", + "VPMAXSWrm", + "VPMAXUBrm", + "VPMAXUDrm", + "VPMAXUWrm", + "VPMINSBrm", + "VPMINSDrm", + "VPMINSWrm", + "VPMINUBrm", + "VPMINUDrm", + "VPMINUWrm", + "VPSIGNBrm", + "VPSIGNDrm", + "VPSIGNWrm", + "VPSLLDrm", + "VPSLLQrm", + "VPSLLVDrm", + "VPSLLVQrm", + "VPSLLWrm", + "VPSRADrm", + "VPSRAVDrm", + "VPSRAWrm", + "VPSRLDrm", + "VPSRLQrm", + "VPSRLVDrm", + "VPSRLVQrm", + "VPSRLWrm", + "VPSUBSBrm", + "VPSUBSWrm", + "VPSUBUSBrm", + "VPSUBUSWrm")>; def SKLWriteResGroup91 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup91], (instregex "ANDNPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "ANDNPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "ANDPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "ANDPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "BLENDPDrmi")>; -def: InstRW<[SKLWriteResGroup91], (instregex "BLENDPSrmi")>; -def: InstRW<[SKLWriteResGroup91], (instregex "ORPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "ORPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PADDBrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PADDDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PADDQrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PADDWrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PANDNrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PANDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PORrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PSUBBrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PSUBDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PSUBQrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PSUBWrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "PXORrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VANDNPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VANDNPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VANDPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VANDPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VBLENDPDrmi")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VBLENDPSrmi")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VINSERTF128rm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VINSERTI128rm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VMASKMOVPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VMASKMOVPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VORPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VORPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPADDBrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPADDDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPADDQrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPADDWrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPANDNrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPANDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPBLENDDrmi")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPMASKMOVDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPMASKMOVQrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPORrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPSUBBrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPSUBDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPSUBQrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPSUBWrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VPXORrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VXORPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "VXORPSrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "XORPDrm")>; -def: InstRW<[SKLWriteResGroup91], (instregex "XORPSrm")>; +def: InstRW<[SKLWriteResGroup91], (instregex "ANDNPDrm", + "ANDNPSrm", + "ANDPDrm", + "ANDPSrm", + "BLENDPDrmi", + "BLENDPSrmi", + "ORPDrm", + "ORPSrm", + "PADDBrm", + "PADDDrm", + "PADDQrm", + "PADDWrm", + "PANDNrm", + "PANDrm", + "PORrm", + "PSUBBrm", + "PSUBDrm", + "PSUBQrm", + "PSUBWrm", + "PXORrm", + "VANDNPDrm", + "VANDNPSrm", + "VANDPDrm", + "VANDPSrm", + "VBLENDPDrmi", + "VBLENDPSrmi", + "VINSERTF128rm", + "VINSERTI128rm", + "VMASKMOVPDrm", + "VMASKMOVPSrm", + "VORPDrm", + "VORPSrm", + "VPADDBrm", + "VPADDDrm", + "VPADDQrm", + "VPADDWrm", + "VPANDNrm", + "VPANDrm", + "VPBLENDDrmi", + "VPMASKMOVDrm", + "VPMASKMOVQrm", + "VPORrm", + "VPSUBBrm", + "VPSUBDrm", + "VPSUBQrm", + "VPSUBWrm", + "VPXORrm", + "VXORPDrm", + "VXORPSrm", + "XORPDrm", + "XORPSrm")>; def SKLWriteResGroup92 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup92], (instregex "MMX_PACKSSDWirm")>; -def: InstRW<[SKLWriteResGroup92], (instregex "MMX_PACKSSWBirm")>; -def: InstRW<[SKLWriteResGroup92], (instregex "MMX_PACKUSWBirm")>; +def: InstRW<[SKLWriteResGroup92], (instregex "MMX_PACKSSDWirm", + "MMX_PACKSSWBirm", + "MMX_PACKUSWBirm")>; def SKLWriteResGroup93 : SchedWriteRes<[SKLPort23,SKLPort06]> { let Latency = 7; @@ -2325,21 +2319,19 @@ def SKLWriteResGroup94 : SchedWriteRes<[SKLPort23,SKLPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup94], (instregex "LEAVE64")>; -def: InstRW<[SKLWriteResGroup94], (instregex "SCASB")>; -def: InstRW<[SKLWriteResGroup94], (instregex "SCASL")>; -def: InstRW<[SKLWriteResGroup94], (instregex "SCASQ")>; -def: InstRW<[SKLWriteResGroup94], (instregex "SCASW")>; +def: InstRW<[SKLWriteResGroup94], (instregex "LEAVE64", + "SCASB", + "SCASL", + "SCASQ", + "SCASW")>; def SKLWriteResGroup95 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort015]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup95], (instregex "CVTTSS2SI64rr")>; -def: InstRW<[SKLWriteResGroup95], (instregex "CVTTSS2SIrr")>; -def: InstRW<[SKLWriteResGroup95], (instregex "VCVTTSS2SI64rr")>; -def: InstRW<[SKLWriteResGroup95], (instregex "VCVTTSS2SIrr")>; +def: InstRW<[SKLWriteResGroup95], (instregex "(V?)CVTTSS2SI64rr", + "(V?)CVTTSS2SIrr")>; def SKLWriteResGroup96 : SchedWriteRes<[SKLPort0,SKLPort23,SKLPort05]> { let Latency = 7; @@ -2353,16 +2345,15 @@ def SKLWriteResGroup97 : SchedWriteRes<[SKLPort0,SKLPort23,SKLPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup97], (instregex "LDMXCSR")>; -def: InstRW<[SKLWriteResGroup97], (instregex "VLDMXCSR")>; +def: InstRW<[SKLWriteResGroup97], (instregex "(V?)LDMXCSR")>; def SKLWriteResGroup98 : SchedWriteRes<[SKLPort6,SKLPort23,SKLPort0156]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup98], (instregex "LRETQ")>; -def: InstRW<[SKLWriteResGroup98], (instregex "RETQ")>; +def: InstRW<[SKLWriteResGroup98], (instregex "LRETQ", + "RETQ")>; def SKLWriteResGroup99 : SchedWriteRes<[SKLPort23,SKLPort06,SKLPort15]> { let Latency = 7; @@ -2376,10 +2367,10 @@ def SKLWriteResGroup100 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06 let NumMicroOps = 5; let ResourceCycles = [1,1,1,2]; } -def: InstRW<[SKLWriteResGroup100], (instregex "ROL(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup100], (instregex "ROL(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup100], (instregex "ROR(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup100], (instregex "ROR(8|16|32|64)mi")>; +def: InstRW<[SKLWriteResGroup100], (instregex "ROL(8|16|32|64)m1", + "ROL(8|16|32|64)mi", + "ROR(8|16|32|64)m1", + "ROR(8|16|32|64)mi")>; def SKLWriteResGroup101 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort0156]> { let Latency = 7; @@ -2393,8 +2384,8 @@ def SKLWriteResGroup102 : SchedWriteRes<[SKLPort4,SKLPort6,SKLPort23,SKLPort237, let NumMicroOps = 5; let ResourceCycles = [1,1,1,1,1]; } -def: InstRW<[SKLWriteResGroup102], (instregex "CALL(16|32|64)m")>; -def: InstRW<[SKLWriteResGroup102], (instregex "FARCALL64")>; +def: InstRW<[SKLWriteResGroup102], (instregex "CALL(16|32|64)m", + "FARCALL64")>; def SKLWriteResGroup103 : SchedWriteRes<[SKLPort6,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 7; @@ -2408,59 +2399,56 @@ def SKLWriteResGroup104 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup104], (instregex "AESIMCrr")>; -def: InstRW<[SKLWriteResGroup104], (instregex "VAESIMCrr")>; +def: InstRW<[SKLWriteResGroup104], (instregex "(V?)AESIMCrr")>; def SKLWriteResGroup105 : SchedWriteRes<[SKLPort015]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup105], (instregex "ROUNDPDr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "ROUNDPSr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "ROUNDSDr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "ROUNDSSr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDPDr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDPSr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDSDr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDSSr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDYPDr")>; -def: InstRW<[SKLWriteResGroup105], (instregex "VROUNDYPSr")>; +def: InstRW<[SKLWriteResGroup105], (instregex "ROUNDPDr", + "ROUNDPSr", + "ROUNDSDr", + "ROUNDSSr", + "VROUNDPDr", + "VROUNDPSr", + "VROUNDSDr", + "VROUNDSSr", + "VROUNDYPDr", + "VROUNDYPSr")>; def SKLWriteResGroup105_2 : SchedWriteRes<[SKLPort01]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKLWriteResGroup105_2], (instregex "PMULLDrr")>; -def: InstRW<[SKLWriteResGroup105_2], (instregex "VPMULLDYrr")>; -def: InstRW<[SKLWriteResGroup105_2], (instregex "VPMULLDrr")>; +def: InstRW<[SKLWriteResGroup105_2], (instregex "PMULLDrr", + "VPMULLDYrr", + "VPMULLDrr")>; def SKLWriteResGroup106 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup106], (instregex "VTESTPDrm")>; -def: InstRW<[SKLWriteResGroup106], (instregex "VTESTPSrm")>; +def: InstRW<[SKLWriteResGroup106], (instregex "VTESTPDrm", + "VTESTPSrm")>; def SKLWriteResGroup107 : SchedWriteRes<[SKLPort1,SKLPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup107], (instregex "BSF(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instregex "BSR(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instrs IMUL64m)>; +def: InstRW<[SKLWriteResGroup107], (instrs IMUL64m, MUL64m)>; def: InstRW<[SKLWriteResGroup107], (instrs IMUL32rm, IMUL32rmi, IMUL32rmi8, IMUL64rm, IMUL64rmi32, IMUL64rmi8)>; -def: InstRW<[SKLWriteResGroup107], (instrs IMUL8m)>; -def: InstRW<[SKLWriteResGroup107], (instregex "LZCNT(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instrs MUL64m)>; -def: InstRW<[SKLWriteResGroup107], (instrs MUL8m)>; -def: InstRW<[SKLWriteResGroup107], (instregex "PDEP(32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instregex "PEXT(32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instregex "POPCNT(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup107], (instregex "TZCNT(16|32|64)rm")>; +def: InstRW<[SKLWriteResGroup107], (instrs IMUL8m, MUL8m)>; +def: InstRW<[SKLWriteResGroup107], (instregex "BSF(16|32|64)rm", + "BSR(16|32|64)rm", + "LZCNT(16|32|64)rm", + "PDEP(32|64)rm", + "PEXT(32|64)rm", + "POPCNT(16|32|64)rm", + "TZCNT(16|32|64)rm")>; def SKLWriteResGroup107_16 : SchedWriteRes<[SKLPort1, SKLPort0156, SKLPort23]> { let Latency = 8; @@ -2473,178 +2461,176 @@ def SKLWriteResGroup107_16_2 : SchedWriteRes<[SKLPort1, SKLPort0156, SKLPort23]> let Latency = 8; let NumMicroOps = 5; } -def: InstRW<[SKLWriteResGroup107_16_2], (instrs IMUL16m)>; -def: InstRW<[SKLWriteResGroup107_16_2], (instrs MUL16m)>; +def: InstRW<[SKLWriteResGroup107_16_2], (instrs IMUL16m, MUL16m)>; def SKLWriteResGroup107_32 : SchedWriteRes<[SKLPort1, SKLPort0156, SKLPort23]> { let Latency = 8; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup107_32], (instrs IMUL32m)>; -def: InstRW<[SKLWriteResGroup107_32], (instrs MUL32m)>; +def: InstRW<[SKLWriteResGroup107_32], (instrs IMUL32m, MUL32m)>; def SKLWriteResGroup108 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup108], (instregex "FCOM32m")>; -def: InstRW<[SKLWriteResGroup108], (instregex "FCOM64m")>; -def: InstRW<[SKLWriteResGroup108], (instregex "FCOMP32m")>; -def: InstRW<[SKLWriteResGroup108], (instregex "FCOMP64m")>; -def: InstRW<[SKLWriteResGroup108], (instregex "MMX_PSADBWirm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPACKSSDWYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPACKSSWBYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPACKUSDWYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPACKUSWBYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPALIGNRYrmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPBLENDWYrmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPBROADCASTBYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPBROADCASTWYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPERMILPDYmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPERMILPDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPERMILPSYmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPERMILPSYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPMOVSXBDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPMOVSXBQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPMOVSXWQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPSHUFBYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPSHUFDYmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPSHUFHWYmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPSHUFLWYmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKHBWYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKHDQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKHQDQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKHWDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKLBWYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKLDQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKLQDQYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VPUNPCKLWDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VSHUFPDYrmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VSHUFPSYrmi")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VUNPCKHPDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VUNPCKHPSYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VUNPCKLPDYrm")>; -def: InstRW<[SKLWriteResGroup108], (instregex "VUNPCKLPSYrm")>; +def: InstRW<[SKLWriteResGroup108], (instregex "FCOM32m", + "FCOM64m", + "FCOMP32m", + "FCOMP64m", + "MMX_PSADBWirm", + "VPACKSSDWYrm", + "VPACKSSWBYrm", + "VPACKUSDWYrm", + "VPACKUSWBYrm", + "VPALIGNRYrmi", + "VPBLENDWYrmi", + "VPBROADCASTBYrm", + "VPBROADCASTWYrm", + "VPERMILPDYmi", + "VPERMILPDYrm", + "VPERMILPSYmi", + "VPERMILPSYrm", + "VPMOVSXBDYrm", + "VPMOVSXBQYrm", + "VPMOVSXWQYrm", + "VPSHUFBYrm", + "VPSHUFDYmi", + "VPSHUFHWYmi", + "VPSHUFLWYmi", + "VPUNPCKHBWYrm", + "VPUNPCKHDQYrm", + "VPUNPCKHQDQYrm", + "VPUNPCKHWDYrm", + "VPUNPCKLBWYrm", + "VPUNPCKLDQYrm", + "VPUNPCKLQDQYrm", + "VPUNPCKLWDYrm", + "VSHUFPDYrmi", + "VSHUFPSYrmi", + "VUNPCKHPDYrm", + "VUNPCKHPSYrm", + "VUNPCKLPDYrm", + "VUNPCKLPSYrm")>; def SKLWriteResGroup109 : SchedWriteRes<[SKLPort01,SKLPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup109], (instregex "VPABSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPABSDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPABSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPADDSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPADDSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPADDUSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPADDUSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPAVGBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPAVGWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPEQBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPEQDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPEQQYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPEQWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPGTBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPGTDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPCMPGTWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXSDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXUBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXUDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMAXUWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINSDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINUBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINUDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPMINUWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSIGNBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSIGNDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSIGNWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSLLDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSLLQYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSLLVDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSLLVQYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSLLWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRADYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRAVDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRAWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRLDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRLQYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRLVDYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRLVQYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSRLWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSUBSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSUBSWYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSUBUSBYrm")>; -def: InstRW<[SKLWriteResGroup109], (instregex "VPSUBUSWYrm")>; +def: InstRW<[SKLWriteResGroup109], (instregex "VPABSBYrm", + "VPABSDYrm", + "VPABSWYrm", + "VPADDSBYrm", + "VPADDSWYrm", + "VPADDUSBYrm", + "VPADDUSWYrm", + "VPAVGBYrm", + "VPAVGWYrm", + "VPCMPEQBYrm", + "VPCMPEQDYrm", + "VPCMPEQQYrm", + "VPCMPEQWYrm", + "VPCMPGTBYrm", + "VPCMPGTDYrm", + "VPCMPGTWYrm", + "VPMAXSBYrm", + "VPMAXSDYrm", + "VPMAXSWYrm", + "VPMAXUBYrm", + "VPMAXUDYrm", + "VPMAXUWYrm", + "VPMINSBYrm", + "VPMINSDYrm", + "VPMINSWYrm", + "VPMINUBYrm", + "VPMINUDYrm", + "VPMINUWYrm", + "VPSIGNBYrm", + "VPSIGNDYrm", + "VPSIGNWYrm", + "VPSLLDYrm", + "VPSLLQYrm", + "VPSLLVDYrm", + "VPSLLVQYrm", + "VPSLLWYrm", + "VPSRADYrm", + "VPSRAVDYrm", + "VPSRAWYrm", + "VPSRLDYrm", + "VPSRLQYrm", + "VPSRLVDYrm", + "VPSRLVQYrm", + "VPSRLWYrm", + "VPSUBSBYrm", + "VPSUBSWYrm", + "VPSUBUSBYrm", + "VPSUBUSWYrm")>; def SKLWriteResGroup110 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup110], (instregex "VANDNPDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VANDNPSYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VANDPDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VANDPSYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VBLENDPDYrmi")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VBLENDPSYrmi")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VMASKMOVPDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VMASKMOVPSYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VORPDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VORPSYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPADDBYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPADDDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPADDQYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPADDWYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPANDNYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPANDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPBLENDDYrmi")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPMASKMOVDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPMASKMOVQYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPORYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPSUBBYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPSUBDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPSUBQYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPSUBWYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VPXORYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VXORPDYrm")>; -def: InstRW<[SKLWriteResGroup110], (instregex "VXORPSYrm")>; +def: InstRW<[SKLWriteResGroup110], (instregex "VANDNPDYrm", + "VANDNPSYrm", + "VANDPDYrm", + "VANDPSYrm", + "VBLENDPDYrmi", + "VBLENDPSYrmi", + "VMASKMOVPDYrm", + "VMASKMOVPSYrm", + "VORPDYrm", + "VORPSYrm", + "VPADDBYrm", + "VPADDDYrm", + "VPADDQYrm", + "VPADDWYrm", + "VPANDNYrm", + "VPANDYrm", + "VPBLENDDYrmi", + "VPMASKMOVDYrm", + "VPMASKMOVQYrm", + "VPORYrm", + "VPSUBBYrm", + "VPSUBDYrm", + "VPSUBQYrm", + "VPSUBWYrm", + "VPXORYrm", + "VXORPDYrm", + "VXORPSYrm")>; def SKLWriteResGroup111 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 8; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup111], (instregex "BLENDVPDrm0")>; -def: InstRW<[SKLWriteResGroup111], (instregex "BLENDVPSrm0")>; -def: InstRW<[SKLWriteResGroup111], (instregex "PBLENDVBrm0")>; -def: InstRW<[SKLWriteResGroup111], (instregex "VBLENDVPDrm")>; -def: InstRW<[SKLWriteResGroup111], (instregex "VBLENDVPSrm")>; -def: InstRW<[SKLWriteResGroup111], (instregex "VPBLENDVBYrm")>; -def: InstRW<[SKLWriteResGroup111], (instregex "VPBLENDVBrm")>; +def: InstRW<[SKLWriteResGroup111], (instregex "BLENDVPDrm0", + "BLENDVPSrm0", + "PBLENDVBrm0", + "VBLENDVPDrm", + "VBLENDVPSrm", + "VPBLENDVBYrm", + "VPBLENDVBrm")>; def SKLWriteResGroup112 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 8; let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKLWriteResGroup112], (instregex "MMX_PHADDSWrm")>; -def: InstRW<[SKLWriteResGroup112], (instregex "MMX_PHSUBSWrm")>; +def: InstRW<[SKLWriteResGroup112], (instregex "MMX_PHADDSWrm", + "MMX_PHSUBSWrm")>; def SKLWriteResGroup113 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort05]> { let Latency = 8; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup113], (instregex "MMX_PHADDDrm")>; -def: InstRW<[SKLWriteResGroup113], (instregex "MMX_PHADDWrm")>; -def: InstRW<[SKLWriteResGroup113], (instregex "MMX_PHSUBDrm")>; -def: InstRW<[SKLWriteResGroup113], (instregex "MMX_PHSUBWrm")>; +def: InstRW<[SKLWriteResGroup113], (instregex "MMX_PHADDDrm", + "MMX_PHADDWrm", + "MMX_PHSUBDrm", + "MMX_PHSUBWrm")>; def SKLWriteResGroup114 : SchedWriteRes<[SKLPort4,SKLPort5,SKLPort237,SKLPort015]> { let Latency = 8; @@ -2665,20 +2651,20 @@ def SKLWriteResGroup116 : SchedWriteRes<[SKLPort23,SKLPort237,SKLPort06,SKLPort0 let NumMicroOps = 5; let ResourceCycles = [1,1,1,2]; } -def: InstRW<[SKLWriteResGroup116], (instregex "RCL(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup116], (instregex "RCL(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup116], (instregex "RCR(8|16|32|64)m1")>; -def: InstRW<[SKLWriteResGroup116], (instregex "RCR(8|16|32|64)mi")>; +def: InstRW<[SKLWriteResGroup116], (instregex "RCL(8|16|32|64)m1", + "RCL(8|16|32|64)mi", + "RCR(8|16|32|64)m1", + "RCR(8|16|32|64)mi")>; def SKLWriteResGroup117 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06]> { let Latency = 8; let NumMicroOps = 6; let ResourceCycles = [1,1,1,3]; } -def: InstRW<[SKLWriteResGroup117], (instregex "ROL(8|16|32|64)mCL")>; -def: InstRW<[SKLWriteResGroup117], (instregex "SAR(8|16|32|64)mCL")>; -def: InstRW<[SKLWriteResGroup117], (instregex "SHL(8|16|32|64)mCL")>; -def: InstRW<[SKLWriteResGroup117], (instregex "SHR(8|16|32|64)mCL")>; +def: InstRW<[SKLWriteResGroup117], (instregex "ROL(8|16|32|64)mCL", + "SAR(8|16|32|64)mCL", + "SHL(8|16|32|64)mCL", + "SHR(8|16|32|64)mCL")>; def SKLWriteResGroup118 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort0156]> { let Latency = 8; @@ -2692,111 +2678,109 @@ def SKLWriteResGroup119 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06 let NumMicroOps = 6; let ResourceCycles = [1,1,1,2,1]; } -def: InstRW<[SKLWriteResGroup119], (instregex "ADC(8|16|32|64)mr")>; -def: InstRW<[SKLWriteResGroup119], (instregex "CMPXCHG(8|16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup119], (instregex "SBB(8|16|32|64)mi")>; -def: InstRW<[SKLWriteResGroup119], (instregex "SBB(8|16|32|64)mr")>; +def: InstRW<[SKLWriteResGroup119], (instregex "ADC(8|16|32|64)mr", + "CMPXCHG(8|16|32|64)rm", + "SBB(8|16|32|64)mi", + "SBB(8|16|32|64)mr")>; def SKLWriteResGroup120 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_CVTPI2PSirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMADDUBSWrm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMADDWDirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMULHRSWrm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMULHUWirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMULHWirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMULLWirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "MMX_PMULUDQirm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "RCPSSm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "RSQRTSSm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "VRCPSSm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "VRSQRTSSm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "VTESTPDYrm")>; -def: InstRW<[SKLWriteResGroup120], (instregex "VTESTPSYrm")>; +def: InstRW<[SKLWriteResGroup120], (instregex "MMX_CVTPI2PSirm", + "MMX_PMADDUBSWrm", + "MMX_PMADDWDirm", + "MMX_PMULHRSWrm", + "MMX_PMULHUWirm", + "MMX_PMULHWirm", + "MMX_PMULLWirm", + "MMX_PMULUDQirm", + "RCPSSm", + "RSQRTSSm", + "VRCPSSm", + "VRSQRTSSm", + "VTESTPDYrm", + "VTESTPSYrm")>; def SKLWriteResGroup121 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup121], (instregex "PCMPGTQrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "PSADBWrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPCMPGTQrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPMOVSXBWYrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPMOVSXDQYrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPMOVSXWDYrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPMOVZXWDYrm")>; -def: InstRW<[SKLWriteResGroup121], (instregex "VPSADBWrm")>; +def: InstRW<[SKLWriteResGroup121], (instregex "PCMPGTQrm", + "PSADBWrm", + "VPCMPGTQrm", + "VPMOVSXBWYrm", + "VPMOVSXDQYrm", + "VPMOVSXWDYrm", + "VPMOVZXWDYrm", + "VPSADBWrm")>; def SKLWriteResGroup122 : SchedWriteRes<[SKLPort01,SKLPort23]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup122], (instregex "ADDSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "ADDSSrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "MULSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "MULSSrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "SUBSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "SUBSSrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VADDSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VADDSSrm")>; +def: InstRW<[SKLWriteResGroup122], (instregex "ADDSDrm", + "ADDSSrm", + "MULSDrm", + "MULSSrm", + "SUBSDrm", + "SUBSSrm", + "VADDSDrm", + "VADDSSrm", + "VMULSDrm", + "VMULSSrm", + "VSUBSDrm", + "VSUBSSrm")>; def: InstRW<[SKLWriteResGroup122], (instregex "VF(N)?M(ADD|SUB)(132|213|231)S(D|S)m")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VMULSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VMULSSrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VSUBSDrm")>; -def: InstRW<[SKLWriteResGroup122], (instregex "VSUBSSrm")>; def SKLWriteResGroup123 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup123], (instregex "CMPSDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "CMPSSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "CVTPS2PDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MAX(C?)SDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MAX(C?)SSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MIN(C?)SDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MIN(C?)SSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MMX_CVTPS2PIirm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "MMX_CVTTPS2PIirm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VCMPSDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VCMPSSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VCVTPH2PSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VCVTPS2PDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VMAX(C?)SDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VMAX(C?)SSrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VMIN(C?)SDrm")>; -def: InstRW<[SKLWriteResGroup123], (instregex "VMIN(C?)SSrm")>; +def: InstRW<[SKLWriteResGroup123], (instregex "CMPSDrm", + "CMPSSrm", + "CVTPS2PDrm", + "MAX(C?)SDrm", + "MAX(C?)SSrm", + "MIN(C?)SDrm", + "MIN(C?)SSrm", + "MMX_CVTPS2PIirm", + "MMX_CVTTPS2PIirm", + "VCMPSDrm", + "VCMPSSrm", + "VCVTPH2PSrm", + "VCVTPS2PDrm", + "VMAX(C?)SDrm", + "VMAX(C?)SSrm", + "VMIN(C?)SDrm", + "VMIN(C?)SSrm")>; def SKLWriteResGroup124 : SchedWriteRes<[SKLPort5,SKLPort015]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup124], (instregex "DPPDrri")>; -def: InstRW<[SKLWriteResGroup124], (instregex "VDPPDrri")>; +def: InstRW<[SKLWriteResGroup124], (instregex "(V?)DPPDrri")>; def SKLWriteResGroup125 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup125], (instregex "VBLENDVPDYrm")>; -def: InstRW<[SKLWriteResGroup125], (instregex "VBLENDVPSYrm")>; +def: InstRW<[SKLWriteResGroup125], (instregex "VBLENDVPDYrm", + "VBLENDVPSYrm")>; def SKLWriteResGroup126 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup126], (instregex "PTESTrm")>; -def: InstRW<[SKLWriteResGroup126], (instregex "VPTESTrm")>; +def: InstRW<[SKLWriteResGroup126], (instregex "(V?)PTESTrm")>; def SKLWriteResGroup127 : SchedWriteRes<[SKLPort1,SKLPort5,SKLPort23]> { let Latency = 9; @@ -2810,207 +2794,191 @@ def SKLWriteResGroup128 : SchedWriteRes<[SKLPort5,SKLPort01,SKLPort23]> { let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup128], (instregex "PHADDSWrm")>; -def: InstRW<[SKLWriteResGroup128], (instregex "PHSUBSWrm")>; -def: InstRW<[SKLWriteResGroup128], (instregex "VPHADDSWrm")>; -def: InstRW<[SKLWriteResGroup128], (instregex "VPHSUBSWrm")>; +def: InstRW<[SKLWriteResGroup128], (instregex "(V?)PHADDSWrm", + "(V?)PHSUBSWrm")>; def SKLWriteResGroup129 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 9; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup129], (instregex "PHADDDrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "PHADDWrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "PHSUBDrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "PHSUBWrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "VPHADDDrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "VPHADDWrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "VPHSUBDrm")>; -def: InstRW<[SKLWriteResGroup129], (instregex "VPHSUBWrm")>; +def: InstRW<[SKLWriteResGroup129], (instregex "(V?)PHADDDrm", + "(V?)PHADDWrm", + "(V?)PHSUBDrm", + "(V?)PHSUBWrm")>; def SKLWriteResGroup130 : SchedWriteRes<[SKLPort1,SKLPort23,SKLPort237,SKLPort0156]> { let Latency = 9; let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKLWriteResGroup130], (instregex "SHLD(16|32|64)mri8")>; -def: InstRW<[SKLWriteResGroup130], (instregex "SHRD(16|32|64)mri8")>; +def: InstRW<[SKLWriteResGroup130], (instregex "SHLD(16|32|64)mri8", + "SHRD(16|32|64)mri8")>; def SKLWriteResGroup131 : SchedWriteRes<[SKLPort1,SKLPort6,SKLPort23,SKLPort0156]> { let Latency = 9; let NumMicroOps = 5; let ResourceCycles = [1,2,1,1]; } -def: InstRW<[SKLWriteResGroup131], (instregex "LAR(16|32|64)rm")>; -def: InstRW<[SKLWriteResGroup131], (instregex "LSL(16|32|64)rm")>; +def: InstRW<[SKLWriteResGroup131], (instregex "LAR(16|32|64)rm", + "LSL(16|32|64)rm")>; def SKLWriteResGroup132 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup132], (instregex "AESDECLASTrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "AESDECrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "AESENCLASTrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "AESENCrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "RCPPSm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "RSQRTPSm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VAESDECLASTrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VAESDECrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VAESENCLASTrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VAESENCrm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VRCPPSm")>; -def: InstRW<[SKLWriteResGroup132], (instregex "VRSQRTPSm")>; +def: InstRW<[SKLWriteResGroup132], (instregex "(V?)AESDECLASTrm", + "(V?)AESDECrm", + "(V?)AESENCLASTrm", + "(V?)AESENCrm", + "(V?)RCPPSm", + "(V?)RSQRTPSm")>; def SKLWriteResGroup133 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup133], (instregex "ADD_F32m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "ADD_F64m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "ILD_F16m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "ILD_F32m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "ILD_F64m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "SUBR_F32m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "SUBR_F64m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "SUB_F32m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "SUB_F64m")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPCMPGTQYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERM2F128rm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERM2I128rm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERMDYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERMPDYmi")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERMPSYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPERMQYmi")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPMOVZXBDYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPMOVZXBQYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPMOVZXBWYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPMOVZXDQYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPMOVZXWQYrm")>; -def: InstRW<[SKLWriteResGroup133], (instregex "VPSADBWYrm")>; +def: InstRW<[SKLWriteResGroup133], (instregex "ADD_F32m", + "ADD_F64m", + "ILD_F16m", + "ILD_F32m", + "ILD_F64m", + "SUBR_F32m", + "SUBR_F64m", + "SUB_F32m", + "SUB_F64m", + "VPCMPGTQYrm", + "VPERM2F128rm", + "VPERM2I128rm", + "VPERMDYrm", + "VPERMPDYmi", + "VPERMPSYrm", + "VPERMQYmi", + "VPMOVZXBDYrm", + "VPMOVZXBQYrm", + "VPMOVZXBWYrm", + "VPMOVZXDQYrm", + "VPMOVZXWQYrm", + "VPSADBWYrm")>; def SKLWriteResGroup134 : SchedWriteRes<[SKLPort01,SKLPort23]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup134], (instregex "ADDPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "ADDPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "ADDSUBPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "ADDSUBPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "MULPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "MULPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "SUBPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "SUBPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VADDPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VADDPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VADDSUBPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VADDSUBPSrm")>; +def: InstRW<[SKLWriteResGroup134], (instregex "ADDPDrm", + "ADDPSrm", + "ADDSUBPDrm", + "ADDSUBPSrm", + "MULPDrm", + "MULPSrm", + "SUBPDrm", + "SUBPSrm", + "VADDPDrm", + "VADDPSrm", + "VADDSUBPDrm", + "VADDSUBPSrm", + "VMULPDrm", + "VMULPSrm", + "VSUBPDrm", + "VSUBPSrm")>; def: InstRW<[SKLWriteResGroup134], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)m")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VMULPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VMULPSrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VSUBPDrm")>; -def: InstRW<[SKLWriteResGroup134], (instregex "VSUBPSrm")>; def SKLWriteResGroup135 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup135], (instregex "CMPPDrmi")>; -def: InstRW<[SKLWriteResGroup135], (instregex "CMPPSrmi")>; -def: InstRW<[SKLWriteResGroup135], (instregex "CVTDQ2PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "CVTPS2DQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "CVTSS2SDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "CVTTPS2DQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "MAX(C?)PDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "MAX(C?)PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "MIN(C?)PDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "MIN(C?)PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PHMINPOSUWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMADDUBSWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMADDWDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULDQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULHRSWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULHUWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULHWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULLWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "PMULUDQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCMPPDrmi")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCMPPSrmi")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCVTDQ2PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCVTPH2PSYrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCVTPS2DQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCVTSS2SDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VCVTTPS2DQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VMAX(C?)PDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VMAX(C?)PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VMIN(C?)PDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VMIN(C?)PSrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPHMINPOSUWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMADDUBSWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMADDWDrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULDQrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULHRSWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULHUWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULHWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULLWrm")>; -def: InstRW<[SKLWriteResGroup135], (instregex "VPMULUDQrm")>; +def: InstRW<[SKLWriteResGroup135], (instregex "CMPPDrmi", + "CMPPSrmi", + "CVTDQ2PSrm", + "CVTPS2DQrm", + "CVTSS2SDrm", + "CVTTPS2DQrm", + "MAX(C?)PDrm", + "MAX(C?)PSrm", + "MIN(C?)PDrm", + "MIN(C?)PSrm", + "PHMINPOSUWrm", + "PMADDUBSWrm", + "PMADDWDrm", + "PMULDQrm", + "PMULHRSWrm", + "PMULHUWrm", + "PMULHWrm", + "PMULLWrm", + "PMULUDQrm", + "VCMPPDrmi", + "VCMPPSrmi", + "VCVTDQ2PSrm", + "VCVTPH2PSYrm", + "VCVTPS2DQrm", + "VCVTSS2SDrm", + "VCVTTPS2DQrm", + "VMAX(C?)PDrm", + "VMAX(C?)PSrm", + "VMIN(C?)PDrm", + "VMIN(C?)PSrm", + "VPHMINPOSUWrm", + "VPMADDUBSWrm", + "VPMADDWDrm", + "VPMULDQrm", + "VPMULHRSWrm", + "VPMULHUWrm", + "VPMULHWrm", + "VPMULLWrm", + "VPMULUDQrm")>; def SKLWriteResGroup136 : SchedWriteRes<[SKLPort0]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKLWriteResGroup136], (instregex "PCMPISTRIrr")>; -def: InstRW<[SKLWriteResGroup136], (instregex "PCMPISTRM128rr")>; -def: InstRW<[SKLWriteResGroup136], (instregex "VPCMPISTRIrr")>; -def: InstRW<[SKLWriteResGroup136], (instregex "VPCMPISTRM128rr")>; +def: InstRW<[SKLWriteResGroup136], (instregex "(V?)PCMPISTRIrr", + "(V?)PCMPISTRM128rr")>; def SKLWriteResGroup137 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup137], (instregex "MPSADBWrmi")>; -def: InstRW<[SKLWriteResGroup137], (instregex "VMPSADBWrmi")>; +def: InstRW<[SKLWriteResGroup137], (instregex "(V?)MPSADBWrmi")>; def SKLWriteResGroup138 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup138], (instregex "MMX_CVTPI2PDirm")>; -def: InstRW<[SKLWriteResGroup138], (instregex "VPTESTYrm")>; +def: InstRW<[SKLWriteResGroup138], (instregex "MMX_CVTPI2PDirm", + "VPTESTYrm")>; def SKLWriteResGroup139 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup139], (instregex "CVTSD2SSrm")>; -def: InstRW<[SKLWriteResGroup139], (instregex "VCVTSD2SSrm")>; +def: InstRW<[SKLWriteResGroup139], (instregex "(V?)CVTSD2SSrm")>; def SKLWriteResGroup140 : SchedWriteRes<[SKLPort5,SKLPort01,SKLPort23]> { let Latency = 10; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup140], (instregex "VPHADDSWYrm")>; -def: InstRW<[SKLWriteResGroup140], (instregex "VPHSUBSWYrm")>; +def: InstRW<[SKLWriteResGroup140], (instregex "VPHADDSWYrm", + "VPHSUBSWYrm")>; def SKLWriteResGroup141 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 10; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup141], (instregex "VPHADDDYrm")>; -def: InstRW<[SKLWriteResGroup141], (instregex "VPHADDWYrm")>; -def: InstRW<[SKLWriteResGroup141], (instregex "VPHSUBDYrm")>; -def: InstRW<[SKLWriteResGroup141], (instregex "VPHSUBWYrm")>; +def: InstRW<[SKLWriteResGroup141], (instregex "VPHADDDYrm", + "VPHADDWYrm", + "VPHSUBDYrm", + "VPHSUBWYrm")>; def SKLWriteResGroup142 : SchedWriteRes<[SKLPort1,SKLPort23,SKLPort06,SKLPort0156]> { let Latency = 10; @@ -3038,128 +3006,127 @@ def SKLWriteResGroup145 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup145], (instregex "DIVPSrr")>; -def: InstRW<[SKLWriteResGroup145], (instregex "DIVSSrr")>; -def: InstRW<[SKLWriteResGroup145], (instregex "VDIVPSYrr")>; -def: InstRW<[SKLWriteResGroup145], (instregex "VDIVPSrr")>; -def: InstRW<[SKLWriteResGroup145], (instregex "VDIVSSrr")>; +def: InstRW<[SKLWriteResGroup145], (instregex "DIVPSrr", + "DIVSSrr", + "VDIVPSYrr", + "VDIVPSrr", + "VDIVSSrr")>; def SKLWriteResGroup146 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 11; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup146], (instregex "MUL_F32m")>; -def: InstRW<[SKLWriteResGroup146], (instregex "MUL_F64m")>; -def: InstRW<[SKLWriteResGroup146], (instregex "VRCPPSYm")>; -def: InstRW<[SKLWriteResGroup146], (instregex "VRSQRTPSYm")>; +def: InstRW<[SKLWriteResGroup146], (instregex "MUL_F32m", + "MUL_F64m", + "VRCPPSYm", + "VRSQRTPSYm")>; def SKLWriteResGroup147 : SchedWriteRes<[SKLPort01,SKLPort23]> { let Latency = 11; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup147], (instregex "VADDPDYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VADDPSYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VADDSUBPDYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VADDSUBPSYrm")>; +def: InstRW<[SKLWriteResGroup147], (instregex "VADDPDYrm", + "VADDPSYrm", + "VADDSUBPDYrm", + "VADDSUBPSYrm", + "VMULPDYrm", + "VMULPSYrm", + "VSUBPDYrm", + "VSUBPSYrm")>; def: InstRW<[SKLWriteResGroup147], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Ym")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VMULPDYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VMULPSYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VSUBPDYrm")>; -def: InstRW<[SKLWriteResGroup147], (instregex "VSUBPSYrm")>; def SKLWriteResGroup148 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 11; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup148], (instregex "VCMPPDYrmi")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VCMPPSYrmi")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VCVTDQ2PSYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VCVTPS2DQYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VCVTPS2PDYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VCVTTPS2DQYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VMAX(C?)PDYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VMAX(C?)PSYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VMIN(C?)PDYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VMIN(C?)PSYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMADDUBSWYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMADDWDYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULDQYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULHRSWYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULHUWYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULHWYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULLWYrm")>; -def: InstRW<[SKLWriteResGroup148], (instregex "VPMULUDQYrm")>; +def: InstRW<[SKLWriteResGroup148], (instregex "VCMPPDYrmi", + "VCMPPSYrmi", + "VCVTDQ2PSYrm", + "VCVTPS2DQYrm", + "VCVTPS2PDYrm", + "VCVTTPS2DQYrm", + "VMAX(C?)PDYrm", + "VMAX(C?)PSYrm", + "VMIN(C?)PDYrm", + "VMIN(C?)PSYrm", + "VPMADDUBSWYrm", + "VPMADDWDYrm", + "VPMULDQYrm", + "VPMULHRSWYrm", + "VPMULHUWYrm", + "VPMULHWYrm", + "VPMULLWYrm", + "VPMULUDQYrm")>; def SKLWriteResGroup149 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup149], (instregex "FICOM16m")>; -def: InstRW<[SKLWriteResGroup149], (instregex "FICOM32m")>; -def: InstRW<[SKLWriteResGroup149], (instregex "FICOMP16m")>; -def: InstRW<[SKLWriteResGroup149], (instregex "FICOMP32m")>; -def: InstRW<[SKLWriteResGroup149], (instregex "VMPSADBWYrmi")>; +def: InstRW<[SKLWriteResGroup149], (instregex "FICOM16m", + "FICOM32m", + "FICOMP16m", + "FICOMP32m", + "VMPSADBWYrmi")>; def SKLWriteResGroup150 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup150], (instregex "CVTDQ2PDrm")>; -def: InstRW<[SKLWriteResGroup150], (instregex "VCVTDQ2PDrm")>; +def: InstRW<[SKLWriteResGroup150], (instregex "(V?)CVTDQ2PDrm")>; def SKLWriteResGroup151 : SchedWriteRes<[SKLPort0,SKLPort23,SKLPort015]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup151], (instregex "CVTSD2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTSD2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTSS2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTSS2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTTSD2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTTSD2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "CVTTSS2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTSD2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTSD2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTSS2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTSS2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTTSD2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTTSD2SIrm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTTSS2SI64rm")>; -def: InstRW<[SKLWriteResGroup151], (instregex "VCVTTSS2SIrm")>; +def: InstRW<[SKLWriteResGroup151], (instregex "CVTSD2SI64rm", + "CVTSD2SIrm", + "CVTSS2SI64rm", + "CVTSS2SIrm", + "CVTTSD2SI64rm", + "CVTTSD2SIrm", + "CVTTSS2SIrm", + "VCVTSD2SI64rm", + "VCVTSD2SIrm", + "VCVTSS2SI64rm", + "VCVTSS2SIrm", + "VCVTTSD2SI64rm", + "VCVTTSD2SIrm", + "VCVTTSS2SI64rm", + "VCVTTSS2SIrm")>; def SKLWriteResGroup152 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup152], (instregex "CVTPD2DQrm")>; -def: InstRW<[SKLWriteResGroup152], (instregex "CVTPD2PSrm")>; -def: InstRW<[SKLWriteResGroup152], (instregex "CVTTPD2DQrm")>; -def: InstRW<[SKLWriteResGroup152], (instregex "MMX_CVTPD2PIirm")>; -def: InstRW<[SKLWriteResGroup152], (instregex "MMX_CVTTPD2PIirm")>; +def: InstRW<[SKLWriteResGroup152], (instregex "CVTPD2DQrm", + "CVTPD2PSrm", + "CVTTPD2DQrm", + "MMX_CVTPD2PIirm", + "MMX_CVTTPD2PIirm")>; def SKLWriteResGroup153 : SchedWriteRes<[SKLPort1,SKLPort23,SKLPort237,SKLPort06,SKLPort0156]> { let Latency = 11; let NumMicroOps = 6; let ResourceCycles = [1,1,1,2,1]; } -def: InstRW<[SKLWriteResGroup153], (instregex "SHLD(16|32|64)mrCL")>; -def: InstRW<[SKLWriteResGroup153], (instregex "SHRD(16|32|64)mrCL")>; +def: InstRW<[SKLWriteResGroup153], (instregex "SHLD(16|32|64)mrCL", + "SHRD(16|32|64)mrCL")>; def SKLWriteResGroup154 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort0156]> { let Latency = 11; let NumMicroOps = 7; let ResourceCycles = [2,3,2]; } -def: InstRW<[SKLWriteResGroup154], (instregex "RCL(16|32|64)rCL")>; -def: InstRW<[SKLWriteResGroup154], (instregex "RCR(16|32|64)rCL")>; +def: InstRW<[SKLWriteResGroup154], (instregex "RCL(16|32|64)rCL", + "RCR(16|32|64)rCL")>; def SKLWriteResGroup155 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 11; @@ -3173,39 +3140,33 @@ def SKLWriteResGroup156 : SchedWriteRes<[SKLPort06,SKLPort0156]> { let NumMicroOps = 11; let ResourceCycles = [2,9]; } -def: InstRW<[SKLWriteResGroup156], (instrs LOOPE)>; -def: InstRW<[SKLWriteResGroup156], (instrs LOOPNE)>; +def: InstRW<[SKLWriteResGroup156], (instrs LOOPE, LOOPNE)>; def SKLWriteResGroup157 : SchedWriteRes<[SKLPort0]> { let Latency = 12; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup157], (instregex "VSQRTPSYr")>; -def: InstRW<[SKLWriteResGroup157], (instregex "VSQRTPSr")>; -def: InstRW<[SKLWriteResGroup157], (instregex "VSQRTSSr")>; +def: InstRW<[SKLWriteResGroup157], (instregex "VSQRTPSYr", + "VSQRTPSr", + "VSQRTSSr")>; def SKLWriteResGroup158 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 12; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup158], (instregex "PCLMULQDQrm")>; -def: InstRW<[SKLWriteResGroup158], (instregex "VPCLMULQDQrm")>; +def: InstRW<[SKLWriteResGroup158], (instregex "(V?)PCLMULQDQrm")>; def SKLWriteResGroup159 : SchedWriteRes<[SKLPort5,SKLPort01,SKLPort23]> { let Latency = 12; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup159], (instregex "HADDPDrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "HADDPSrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "HSUBPDrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "HSUBPSrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "VHADDPDrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "VHADDPSrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "VHSUBPDrm")>; -def: InstRW<[SKLWriteResGroup159], (instregex "VHSUBPSrm")>; +def: InstRW<[SKLWriteResGroup159], (instregex "(V?)HADDPDrm", + "(V?)HADDPSrm", + "(V?)HSUBPDrm", + "(V?)HSUBPSrm")>; def SKLWriteResGroup160 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23,SKLPort015]> { let Latency = 12; @@ -3219,20 +3180,20 @@ def SKLWriteResGroup161 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup161], (instregex "SQRTPSr")>; -def: InstRW<[SKLWriteResGroup161], (instregex "SQRTSSr")>; +def: InstRW<[SKLWriteResGroup161], (instregex "SQRTPSr", + "SQRTSSr")>; def SKLWriteResGroup162 : SchedWriteRes<[SKLPort5,SKLPort23]> { let Latency = 13; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup162], (instregex "ADD_FI16m")>; -def: InstRW<[SKLWriteResGroup162], (instregex "ADD_FI32m")>; -def: InstRW<[SKLWriteResGroup162], (instregex "SUBR_FI16m")>; -def: InstRW<[SKLWriteResGroup162], (instregex "SUBR_FI32m")>; -def: InstRW<[SKLWriteResGroup162], (instregex "SUB_FI16m")>; -def: InstRW<[SKLWriteResGroup162], (instregex "SUB_FI32m")>; +def: InstRW<[SKLWriteResGroup162], (instregex "ADD_FI16m", + "ADD_FI32m", + "SUBR_FI16m", + "SUBR_FI32m", + "SUB_FI16m", + "SUB_FI32m")>; def SKLWriteResGroup163 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 13; @@ -3246,68 +3207,62 @@ def SKLWriteResGroup164 : SchedWriteRes<[SKLPort5,SKLPort015]> { let NumMicroOps = 4; let ResourceCycles = [1,3]; } -def: InstRW<[SKLWriteResGroup164], (instregex "DPPSrri")>; -def: InstRW<[SKLWriteResGroup164], (instregex "VDPPSYrri")>; -def: InstRW<[SKLWriteResGroup164], (instregex "VDPPSrri")>; +def: InstRW<[SKLWriteResGroup164], (instregex "DPPSrri", + "VDPPSYrri", + "VDPPSrri")>; def SKLWriteResGroup165 : SchedWriteRes<[SKLPort5,SKLPort01,SKLPort23]> { let Latency = 13; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKLWriteResGroup165], (instregex "VHADDPDYrm")>; -def: InstRW<[SKLWriteResGroup165], (instregex "VHADDPSYrm")>; -def: InstRW<[SKLWriteResGroup165], (instregex "VHSUBPDYrm")>; -def: InstRW<[SKLWriteResGroup165], (instregex "VHSUBPSYrm")>; +def: InstRW<[SKLWriteResGroup165], (instregex "VHADDPDYrm", + "VHADDPSYrm", + "VHSUBPDYrm", + "VHSUBPSYrm")>; def SKLWriteResGroup166 : SchedWriteRes<[SKLPort0]> { let Latency = 14; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup166], (instregex "DIVPDrr")>; -def: InstRW<[SKLWriteResGroup166], (instregex "DIVSDrr")>; -def: InstRW<[SKLWriteResGroup166], (instregex "VDIVPDYrr")>; -def: InstRW<[SKLWriteResGroup166], (instregex "VDIVPDrr")>; -def: InstRW<[SKLWriteResGroup166], (instregex "VDIVSDrr")>; +def: InstRW<[SKLWriteResGroup166], (instregex "DIVPDrr", + "DIVSDrr", + "VDIVPDYrr", + "VDIVPDrr", + "VDIVSDrr")>; def SKLWriteResGroup167 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKLWriteResGroup167], (instregex "AESIMCrm")>; -def: InstRW<[SKLWriteResGroup167], (instregex "VAESIMCrm")>; +def: InstRW<[SKLWriteResGroup167], (instregex "(V?)AESIMCrm")>; def SKLWriteResGroup168 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup168], (instregex "ROUNDPDm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "ROUNDPSm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "ROUNDSDm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "ROUNDSSm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "VROUNDPDm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "VROUNDPSm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "VROUNDSDm")>; -def: InstRW<[SKLWriteResGroup168], (instregex "VROUNDSSm")>; +def: InstRW<[SKLWriteResGroup168], (instregex "(V?)ROUNDPDm")>; +def: InstRW<[SKLWriteResGroup168], (instregex "(V?)ROUNDPSm")>; +def: InstRW<[SKLWriteResGroup168], (instregex "(V?)ROUNDSDm")>; +def: InstRW<[SKLWriteResGroup168], (instregex "(V?)ROUNDSSm")>; def SKLWriteResGroup168_2 : SchedWriteRes<[SKLPort23,SKLPort01]> { let Latency = 16; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup168_2], (instregex "PMULLDrm")>; -def: InstRW<[SKLWriteResGroup168_2], (instregex "VPMULLDrm")>; +def: InstRW<[SKLWriteResGroup168_2], (instregex "(V?)PMULLDrm")>; def SKLWriteResGroup169 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup169], (instregex "MUL_FI16m")>; -def: InstRW<[SKLWriteResGroup169], (instregex "MUL_FI32m")>; +def: InstRW<[SKLWriteResGroup169], (instregex "MUL_FI16m", + "MUL_FI32m")>; def SKLWriteResGroup170 : SchedWriteRes<[SKLPort1,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 14; @@ -3321,17 +3276,17 @@ def SKLWriteResGroup171 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup171], (instregex "DIVR_FPrST0")>; -def: InstRW<[SKLWriteResGroup171], (instregex "DIVR_FST0r")>; -def: InstRW<[SKLWriteResGroup171], (instregex "DIVR_FrST0")>; +def: InstRW<[SKLWriteResGroup171], (instregex "DIVR_FPrST0", + "DIVR_FST0r", + "DIVR_FrST0")>; def SKLWriteResGroup172 : SchedWriteRes<[SKLPort23,SKLPort015]> { let Latency = 15; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKLWriteResGroup172], (instregex "VROUNDYPDm")>; -def: InstRW<[SKLWriteResGroup172], (instregex "VROUNDYPSm")>; +def: InstRW<[SKLWriteResGroup172], (instregex "VROUNDYPDm", + "VROUNDYPSm")>; def SKLWriteResGroup172_2 : SchedWriteRes<[SKLPort23,SKLPort01]> { let Latency = 17; @@ -3345,8 +3300,7 @@ def SKLWriteResGroup173 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let NumMicroOps = 4; let ResourceCycles = [1,1,2]; } -def: InstRW<[SKLWriteResGroup173], (instregex "DPPDrmi")>; -def: InstRW<[SKLWriteResGroup173], (instregex "VDPPDrmi")>; +def: InstRW<[SKLWriteResGroup173], (instregex "(V?)DPPDrmi")>; def SKLWriteResGroup174 : SchedWriteRes<[SKLPort1,SKLPort23,SKLPort237,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 15; @@ -3360,18 +3314,15 @@ def SKLWriteResGroup175 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup175], (instregex "DIVSSrm")>; -def: InstRW<[SKLWriteResGroup175], (instregex "VDIVSSrm")>; +def: InstRW<[SKLWriteResGroup175], (instregex "(V?)DIVSSrm")>; def SKLWriteResGroup176 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 16; let NumMicroOps = 4; let ResourceCycles = [3,1]; } -def: InstRW<[SKLWriteResGroup176], (instregex "PCMPISTRIrm")>; -def: InstRW<[SKLWriteResGroup176], (instregex "PCMPISTRM128rm")>; -def: InstRW<[SKLWriteResGroup176], (instregex "VPCMPISTRIrm")>; -def: InstRW<[SKLWriteResGroup176], (instregex "VPCMPISTRM128rm")>; +def: InstRW<[SKLWriteResGroup176], (instregex "(V?)PCMPISTRIrm", + "(V?)PCMPISTRM128rm")>; def SKLWriteResGroup177 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 16; @@ -3392,9 +3343,8 @@ def SKLWriteResGroup179 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup179], (instregex "DIVPSrm")>; -def: InstRW<[SKLWriteResGroup179], (instregex "VDIVPSrm")>; -def: InstRW<[SKLWriteResGroup179], (instregex "VSQRTSSm")>; +def: InstRW<[SKLWriteResGroup179], (instregex "(V?)DIVPSrm", + "VSQRTSSm")>; def SKLWriteResGroup180 : SchedWriteRes<[SKLPort0,SKLPort1,SKLPort5,SKLPort6,SKLPort05,SKLPort0156]> { let Latency = 17; @@ -3408,34 +3358,32 @@ def SKLWriteResGroup181 : SchedWriteRes<[SKLPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup181], (instregex "VSQRTPDYr")>; -def: InstRW<[SKLWriteResGroup181], (instregex "VSQRTPDr")>; -def: InstRW<[SKLWriteResGroup181], (instregex "VSQRTSDr")>; +def: InstRW<[SKLWriteResGroup181], (instregex "VSQRTPDYr", + "VSQRTPDr", + "VSQRTSDr")>; def SKLWriteResGroup182 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 18; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup182], (instregex "SQRTSSm")>; -def: InstRW<[SKLWriteResGroup182], (instregex "VDIVPSYrm")>; -def: InstRW<[SKLWriteResGroup182], (instregex "VSQRTPSm")>; +def: InstRW<[SKLWriteResGroup182], (instregex "SQRTSSm", + "VDIVPSYrm", + "VSQRTPSm")>; def SKLWriteResGroup183 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort0156]> { let Latency = 18; let NumMicroOps = 8; let ResourceCycles = [4,3,1]; } -def: InstRW<[SKLWriteResGroup183], (instregex "PCMPESTRIrr")>; -def: InstRW<[SKLWriteResGroup183], (instregex "VPCMPESTRIrr")>; +def: InstRW<[SKLWriteResGroup183], (instregex "(V?)PCMPESTRIrr")>; def SKLWriteResGroup184 : SchedWriteRes<[SKLPort5,SKLPort6,SKLPort06,SKLPort0156]> { let Latency = 18; let NumMicroOps = 8; let ResourceCycles = [1,1,1,5]; } -def: InstRW<[SKLWriteResGroup184], (instregex "CPUID")>; -def: InstRW<[SKLWriteResGroup184], (instrs RDTSC)>; +def: InstRW<[SKLWriteResGroup184], (instrs CPUID, RDTSC)>; def SKLWriteResGroup185 : SchedWriteRes<[SKLPort1,SKLPort23,SKLPort237,SKLPort06,SKLPort15,SKLPort0156]> { let Latency = 18; @@ -3449,45 +3397,42 @@ def SKLWriteResGroup186 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup186], (instregex "DIVSDrm")>; -def: InstRW<[SKLWriteResGroup186], (instregex "SQRTPSm")>; -def: InstRW<[SKLWriteResGroup186], (instregex "VDIVSDrm")>; -def: InstRW<[SKLWriteResGroup186], (instregex "VSQRTPSYm")>; +def: InstRW<[SKLWriteResGroup186], (instregex "DIVSDrm", + "SQRTPSm", + "VDIVSDrm", + "VSQRTPSYm")>; def SKLWriteResGroup187 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 19; let NumMicroOps = 5; let ResourceCycles = [1,1,3]; } -def: InstRW<[SKLWriteResGroup187], (instregex "DPPSrmi")>; -def: InstRW<[SKLWriteResGroup187], (instregex "VDPPSrmi")>; +def: InstRW<[SKLWriteResGroup187], (instregex "(V?)DPPSrmi")>; def SKLWriteResGroup188 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort015,SKLPort0156]> { let Latency = 19; let NumMicroOps = 9; let ResourceCycles = [4,3,1,1]; } -def: InstRW<[SKLWriteResGroup188], (instregex "PCMPESTRM128rr")>; -def: InstRW<[SKLWriteResGroup188], (instregex "VPCMPESTRM128rr")>; +def: InstRW<[SKLWriteResGroup188], (instregex "(V?)PCMPESTRM128rr")>; def SKLWriteResGroup189 : SchedWriteRes<[SKLPort0]> { let Latency = 20; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKLWriteResGroup189], (instregex "DIV_FPrST0")>; -def: InstRW<[SKLWriteResGroup189], (instregex "DIV_FST0r")>; -def: InstRW<[SKLWriteResGroup189], (instregex "DIV_FrST0")>; -def: InstRW<[SKLWriteResGroup189], (instregex "SQRTPDr")>; -def: InstRW<[SKLWriteResGroup189], (instregex "SQRTSDr")>; +def: InstRW<[SKLWriteResGroup189], (instregex "DIV_FPrST0", + "DIV_FST0r", + "DIV_FrST0", + "SQRTPDr", + "SQRTSDr")>; def SKLWriteResGroup190 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 20; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup190], (instregex "DIVPDrm")>; -def: InstRW<[SKLWriteResGroup190], (instregex "VDIVPDrm")>; +def: InstRW<[SKLWriteResGroup190], (instregex "(V?)DIVPDrm")>; def SKLWriteResGroup191 : SchedWriteRes<[SKLPort5,SKLPort23,SKLPort015]> { let Latency = 20; @@ -3501,9 +3446,9 @@ def SKLWriteResGroup192 : SchedWriteRes<[SKLPort4,SKLPort5,SKLPort6,SKLPort23,SK let NumMicroOps = 8; let ResourceCycles = [1,1,1,1,1,1,2]; } -def: InstRW<[SKLWriteResGroup192], (instregex "INSB")>; -def: InstRW<[SKLWriteResGroup192], (instregex "INSL")>; -def: InstRW<[SKLWriteResGroup192], (instregex "INSW")>; +def: InstRW<[SKLWriteResGroup192], (instregex "INSB", + "INSL", + "INSW")>; def SKLWriteResGroup193 : SchedWriteRes<[SKLPort5,SKLPort6,SKLPort0156]> { let Latency = 20; @@ -3517,8 +3462,7 @@ def SKLWriteResGroup194 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort015]> { let NumMicroOps = 11; let ResourceCycles = [3,6,2]; } -def: InstRW<[SKLWriteResGroup194], (instregex "AESKEYGENASSIST128rr")>; -def: InstRW<[SKLWriteResGroup194], (instregex "VAESKEYGENASSIST128rr")>; +def: InstRW<[SKLWriteResGroup194], (instregex "(V?)AESKEYGENASSIST128rr")>; def SKLWriteResGroup195 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 21; @@ -3532,8 +3476,8 @@ def SKLWriteResGroup196 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup196], (instregex "DIV_F32m")>; -def: InstRW<[SKLWriteResGroup196], (instregex "DIV_F64m")>; +def: InstRW<[SKLWriteResGroup196], (instregex "DIV_F32m", + "DIV_F64m")>; def SKLWriteResGroup196_1 : SchedWriteRes<[SKLPort0, SKLPort23, SKLPort5, SKLPort015]> { let Latency = 22; @@ -3589,40 +3533,37 @@ def SKLWriteResGroup200 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23,SKLPort0156 let NumMicroOps = 9; let ResourceCycles = [4,3,1,1]; } -def: InstRW<[SKLWriteResGroup200], (instregex "PCMPESTRIrm")>; -def: InstRW<[SKLWriteResGroup200], (instregex "VPCMPESTRIrm")>; +def: InstRW<[SKLWriteResGroup200], (instregex "(V?)PCMPESTRIrm")>; def SKLWriteResGroup201 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 25; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup201], (instregex "SQRTSDm")>; -def: InstRW<[SKLWriteResGroup201], (instregex "VSQRTPDYm")>; +def: InstRW<[SKLWriteResGroup201], (instregex "SQRTSDm", + "VSQRTPDYm")>; def SKLWriteResGroup202 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let Latency = 25; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup202], (instregex "DIV_FI16m")>; -def: InstRW<[SKLWriteResGroup202], (instregex "DIV_FI32m")>; +def: InstRW<[SKLWriteResGroup202], (instregex "DIV_FI16m", + "DIV_FI32m")>; def SKLWriteResGroup203 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23,SKLPort015,SKLPort0156]> { let Latency = 25; let NumMicroOps = 10; let ResourceCycles = [4,3,1,1,1]; } -def: InstRW<[SKLWriteResGroup203], (instregex "PCMPESTRM128rm")>; -def: InstRW<[SKLWriteResGroup203], (instregex "VPCMPESTRM128rm")>; +def: InstRW<[SKLWriteResGroup203], (instregex "(V?)PCMPESTRM128rm")>; def SKLWriteResGroup204 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23,SKLPort015]> { let Latency = 25; let NumMicroOps = 11; let ResourceCycles = [3,6,1,1]; } -def: InstRW<[SKLWriteResGroup204], (instregex "AESKEYGENASSIST128rm")>; -def: InstRW<[SKLWriteResGroup204], (instregex "VAESKEYGENASSIST128rm")>; +def: InstRW<[SKLWriteResGroup204], (instregex "(V?)AESKEYGENASSIST128rm")>; def SKLWriteResGroup205 : SchedWriteRes<[SKLPort0,SKLPort23]> { let Latency = 26; @@ -3636,8 +3577,8 @@ def SKLWriteResGroup206 : SchedWriteRes<[SKLPort0,SKLPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKLWriteResGroup206], (instregex "DIVR_F32m")>; -def: InstRW<[SKLWriteResGroup206], (instregex "DIVR_F64m")>; +def: InstRW<[SKLWriteResGroup206], (instregex "DIVR_F32m", + "DIVR_F64m")>; def SKLWriteResGroup207 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23,SKLPort0156]> { let Latency = 28; @@ -3651,24 +3592,24 @@ def SKLWriteResGroup208 : SchedWriteRes<[SKLPort0,SKLPort5,SKLPort23]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKLWriteResGroup208], (instregex "DIVR_FI16m")>; -def: InstRW<[SKLWriteResGroup208], (instregex "DIVR_FI32m")>; +def: InstRW<[SKLWriteResGroup208], (instregex "DIVR_FI16m", + "DIVR_FI32m")>; def SKLWriteResGroup209 : SchedWriteRes<[SKLPort5,SKLPort6,SKLPort23,SKLPort06,SKLPort0156]> { let Latency = 35; let NumMicroOps = 23; let ResourceCycles = [1,5,3,4,10]; } -def: InstRW<[SKLWriteResGroup209], (instregex "IN(8|16|32)ri")>; -def: InstRW<[SKLWriteResGroup209], (instregex "IN(8|16|32)rr")>; +def: InstRW<[SKLWriteResGroup209], (instregex "IN(8|16|32)ri", + "IN(8|16|32)rr")>; def SKLWriteResGroup210 : SchedWriteRes<[SKLPort5,SKLPort6,SKLPort23,SKLPort237,SKLPort06,SKLPort0156]> { let Latency = 35; let NumMicroOps = 23; let ResourceCycles = [1,5,2,1,4,10]; } -def: InstRW<[SKLWriteResGroup210], (instregex "OUT(8|16|32)ir")>; -def: InstRW<[SKLWriteResGroup210], (instregex "OUT(8|16|32)rr")>; +def: InstRW<[SKLWriteResGroup210], (instregex "OUT(8|16|32)ir", + "OUT(8|16|32)rr")>; def SKLWriteResGroup211 : SchedWriteRes<[SKLPort1,SKLPort6,SKLPort23,SKLPort0156]> { let Latency = 37; diff --git a/llvm/lib/Target/X86/X86SchedSkylakeServer.td b/llvm/lib/Target/X86/X86SchedSkylakeServer.td index c567cff0e5ed..9d5e5804241f 100755 --- a/llvm/lib/Target/X86/X86SchedSkylakeServer.td +++ b/llvm/lib/Target/X86/X86SchedSkylakeServer.td @@ -278,351 +278,351 @@ def SKXWriteResGroup1 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup1], (instregex "KANDBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDNBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDNDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDNQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDNWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KANDWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KMOVBkk")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KMOVDkk")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KMOVQkk")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KMOVWkk")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KNOTBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KNOTDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KNOTQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KNOTWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KORBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KORDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KORQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KORWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXNORBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXNORDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXNORQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXNORWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXORBrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXORDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXORQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "KXORWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PADDSBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PADDSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PADDUSBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PADDUSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PAVGBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PAVGWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPEQBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPEQDirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPEQWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPGTBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPGTDirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PCMPGTWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PMAXSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PMAXUBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PMINSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PMINUBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLDri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLQri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLWri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSLLWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRADri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRADrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRAWri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRAWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLDri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLDrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLQri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLQrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLWri")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSRLWrr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSUBSBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSUBSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSUBUSBirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "MMX_PSUBUSWirr")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVB2MZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVB2MZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVB2MZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVD2MZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVD2MZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVD2MZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVQ2MZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVQ2MZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVQ2MZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVW2MZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVW2MZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup1], (instregex "VPMOVW2MZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup1], (instregex "KANDBrr", + "KANDDrr", + "KANDNBrr", + "KANDNDrr", + "KANDNQrr", + "KANDNWrr", + "KANDQrr", + "KANDWrr", + "KMOVBkk", + "KMOVDkk", + "KMOVQkk", + "KMOVWkk", + "KNOTBrr", + "KNOTDrr", + "KNOTQrr", + "KNOTWrr", + "KORBrr", + "KORDrr", + "KORQrr", + "KORWrr", + "KXNORBrr", + "KXNORDrr", + "KXNORQrr", + "KXNORWrr", + "KXORBrr", + "KXORDrr", + "KXORQrr", + "KXORWrr", + "MMX_PADDSBirr", + "MMX_PADDSWirr", + "MMX_PADDUSBirr", + "MMX_PADDUSWirr", + "MMX_PAVGBirr", + "MMX_PAVGWirr", + "MMX_PCMPEQBirr", + "MMX_PCMPEQDirr", + "MMX_PCMPEQWirr", + "MMX_PCMPGTBirr", + "MMX_PCMPGTDirr", + "MMX_PCMPGTWirr", + "MMX_PMAXSWirr", + "MMX_PMAXUBirr", + "MMX_PMINSWirr", + "MMX_PMINUBirr", + "MMX_PSLLDri", + "MMX_PSLLDrr", + "MMX_PSLLQri", + "MMX_PSLLQrr", + "MMX_PSLLWri", + "MMX_PSLLWrr", + "MMX_PSRADri", + "MMX_PSRADrr", + "MMX_PSRAWri", + "MMX_PSRAWrr", + "MMX_PSRLDri", + "MMX_PSRLDrr", + "MMX_PSRLQri", + "MMX_PSRLQrr", + "MMX_PSRLWri", + "MMX_PSRLWrr", + "MMX_PSUBSBirr", + "MMX_PSUBSWirr", + "MMX_PSUBUSBirr", + "MMX_PSUBUSWirr", + "VPMOVB2MZ128rr(b?)(k?)(z?)", + "VPMOVB2MZ256rr(b?)(k?)(z?)", + "VPMOVB2MZrr(b?)(k?)(z?)", + "VPMOVD2MZ128rr(b?)(k?)(z?)", + "VPMOVD2MZ256rr(b?)(k?)(z?)", + "VPMOVD2MZrr(b?)(k?)(z?)", + "VPMOVQ2MZ128rr(b?)(k?)(z?)", + "VPMOVQ2MZ256rr(b?)(k?)(z?)", + "VPMOVQ2MZrr(b?)(k?)(z?)", + "VPMOVW2MZ128rr(b?)(k?)(z?)", + "VPMOVW2MZ256rr(b?)(k?)(z?)", + "VPMOVW2MZrr(b?)(k?)(z?)")>; def SKXWriteResGroup3 : SchedWriteRes<[SKXPort5]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup3], (instregex "COMP_FST0r")>; -def: InstRW<[SKXWriteResGroup3], (instregex "COM_FST0r")>; -def: InstRW<[SKXWriteResGroup3], (instregex "INSERTPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "KMOVBkr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "KMOVDkr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "KMOVQkr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "KMOVWkr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_MOVD64rr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_MOVD64to64rr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PALIGNRrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PSHUFBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PSHUFWri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKHBWirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKHDQirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKHWDirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKLBWirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKLDQirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MMX_PUNPCKLWDirr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOV64toPQIrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVDDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVDI2PDIrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVHLPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVLHPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVSDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVSHDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVSLDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVUPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "MOVUPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PACKSSDWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PACKSSWBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PACKUSDWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PACKUSWBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PALIGNRrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PBLENDWrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXBDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXBQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVSXWQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXBDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXBQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PMOVZXWQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSHUFBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSHUFDri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSHUFHWri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSHUFLWri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSLLDQri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PSRLDQri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKHBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKHDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKHQDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKHWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKLBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKLDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKLQDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "PUNPCKLWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "SHUFPDrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "SHUFPSrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UCOM_FPr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UCOM_Fr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UNPCKHPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UNPCKHPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UNPCKLPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "UNPCKLPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VBROADCASTI32X2Z128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VBROADCASTSSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VINSERTPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VINSERTPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOV64toPQIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOV64toPQIrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDDUPYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDDUPZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDDUPZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDDUPZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDI2PDIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVDI2PDIrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVHLPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVHLPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVLHPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVLHPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSHDUPYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSHDUPZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSHDUPZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSHDUPZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSHDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSLDUPYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSLDUPZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSLDUPZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSLDUPZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSLDUPrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVSSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVUPDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVUPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVUPSYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VMOVUPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSDWYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSDWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSWBYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSWBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSWBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSWBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKSSWBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSDWYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSDWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSWBYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSWBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSWBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSWBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPACKUSWBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPALIGNRYrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPALIGNRZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPALIGNRZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPALIGNRZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPALIGNRrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPBLENDWYrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPBLENDWrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPBROADCASTDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPBROADCASTQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPERMILPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXBDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXBQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVSXWQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXBDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXBQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPMOVZXWQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFBYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFBrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFDYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFDri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFHWYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFHWZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFHWZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFHWZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFHWri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFLWYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFLWZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFLWZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFLWZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSHUFLWri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSLLDQYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSLLDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSLLDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSLLDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSLLDQri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSRLDQYri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSRLDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSRLDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSRLDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPSRLDQri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHBWYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHBWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHDQYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHQDQYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHQDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHQDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHQDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHQDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHWDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHWDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHWDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHWDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKHWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLBWYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLBWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLBWrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLDQYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLQDQYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLQDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLQDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLQDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLQDQrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLWDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLWDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLWDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLWDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VPUNPCKLWDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPDYrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPDrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPSYrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VSHUFPSrri")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPSYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKHPSrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPDYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPDrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPSYrr")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup3], (instregex "VUNPCKLPSrr")>; +def: InstRW<[SKXWriteResGroup3], (instregex "COMP_FST0r", + "COM_FST0r", + "INSERTPSrr", + "KMOVBkr", + "KMOVDkr", + "KMOVQkr", + "KMOVWkr", + "MMX_MOVD64rr", + "MMX_MOVD64to64rr", + "MMX_PALIGNRrri", + "MMX_PSHUFBrr", + "MMX_PSHUFWri", + "MMX_PUNPCKHBWirr", + "MMX_PUNPCKHDQirr", + "MMX_PUNPCKHWDirr", + "MMX_PUNPCKLBWirr", + "MMX_PUNPCKLDQirr", + "MMX_PUNPCKLWDirr", + "MOV64toPQIrr", + "MOVDDUPrr", + "MOVDI2PDIrr", + "MOVHLPSrr", + "MOVLHPSrr", + "MOVSDrr", + "MOVSHDUPrr", + "MOVSLDUPrr", + "MOVUPDrr", + "MOVUPSrr", + "PACKSSDWrr", + "PACKSSWBrr", + "PACKUSDWrr", + "PACKUSWBrr", + "PALIGNRrri", + "PBLENDWrri", + "PMOVSXBDrr", + "PMOVSXBQrr", + "PMOVSXBWrr", + "PMOVSXDQrr", + "PMOVSXWDrr", + "PMOVSXWQrr", + "PMOVZXBDrr", + "PMOVZXBQrr", + "PMOVZXBWrr", + "PMOVZXDQrr", + "PMOVZXWDrr", + "PMOVZXWQrr", + "PSHUFBrr", + "PSHUFDri", + "PSHUFHWri", + "PSHUFLWri", + "PSLLDQri", + "PSRLDQri", + "PUNPCKHBWrr", + "PUNPCKHDQrr", + "PUNPCKHQDQrr", + "PUNPCKHWDrr", + "PUNPCKLBWrr", + "PUNPCKLDQrr", + "PUNPCKLQDQrr", + "PUNPCKLWDrr", + "SHUFPDrri", + "SHUFPSrri", + "UCOM_FPr", + "UCOM_Fr", + "UNPCKHPDrr", + "UNPCKHPSrr", + "UNPCKLPDrr", + "UNPCKLPSrr", + "VBROADCASTI32X2Z128r(b?)(k?)(z?)", + "VBROADCASTSSrr", + "VINSERTPSZrr(b?)(k?)(z?)", + "VINSERTPSrr", + "VMOV64toPQIZrr(b?)(k?)(z?)", + "VMOV64toPQIrr", + "VMOVDDUPYrr", + "VMOVDDUPZ128rr(b?)(k?)(z?)", + "VMOVDDUPZ256rr(b?)(k?)(z?)", + "VMOVDDUPZrr(b?)(k?)(z?)", + "VMOVDDUPrr", + "VMOVDI2PDIZrr(b?)(k?)(z?)", + "VMOVDI2PDIrr", + "VMOVHLPSZrr(b?)(k?)(z?)", + "VMOVHLPSrr", + "VMOVLHPSZrr(b?)(k?)(z?)", + "VMOVLHPSrr", + "VMOVSDZrr(b?)(k?)(z?)", + "VMOVSDrr", + "VMOVSHDUPYrr", + "VMOVSHDUPZ128rr(b?)(k?)(z?)", + "VMOVSHDUPZ256rr(b?)(k?)(z?)", + "VMOVSHDUPZrr(b?)(k?)(z?)", + "VMOVSHDUPrr", + "VMOVSLDUPYrr", + "VMOVSLDUPZ128rr(b?)(k?)(z?)", + "VMOVSLDUPZ256rr(b?)(k?)(z?)", + "VMOVSLDUPZrr(b?)(k?)(z?)", + "VMOVSLDUPrr", + "VMOVSSZrr(b?)(k?)(z?)", + "VMOVUPDYrr", + "VMOVUPDrr", + "VMOVUPSYrr", + "VMOVUPSrr", + "VPACKSSDWYrr", + "VPACKSSDWZ128rr(b?)(k?)(z?)", + "VPACKSSDWZ256rr(b?)(k?)(z?)", + "VPACKSSDWZrr(b?)(k?)(z?)", + "VPACKSSDWrr", + "VPACKSSWBYrr", + "VPACKSSWBZ128rr(b?)(k?)(z?)", + "VPACKSSWBZ256rr(b?)(k?)(z?)", + "VPACKSSWBZrr(b?)(k?)(z?)", + "VPACKSSWBrr", + "VPACKUSDWYrr", + "VPACKUSDWZ128rr(b?)(k?)(z?)", + "VPACKUSDWZ256rr(b?)(k?)(z?)", + "VPACKUSDWZrr(b?)(k?)(z?)", + "VPACKUSDWrr", + "VPACKUSWBYrr", + "VPACKUSWBZ128rr(b?)(k?)(z?)", + "VPACKUSWBZ256rr(b?)(k?)(z?)", + "VPACKUSWBZrr(b?)(k?)(z?)", + "VPACKUSWBrr", + "VPALIGNRYrri", + "VPALIGNRZ128rri(b?)(k?)(z?)", + "VPALIGNRZ256rri(b?)(k?)(z?)", + "VPALIGNRZrri(b?)(k?)(z?)", + "VPALIGNRrri", + "VPBLENDWYrri", + "VPBLENDWrri", + "VPBROADCASTDrr", + "VPBROADCASTQrr", + "VPERMILPDYri", + "VPERMILPDYrr", + "VPERMILPDZ128r(b?)i(k?)(z?)", + "VPERMILPDZ128rr(b?)(k?)(z?)", + "VPERMILPDZ256r(b?)i(k?)(z?)", + "VPERMILPDZ256rr(b?)(k?)(z?)", + "VPERMILPDZri(b?)(k?)(z?)", + "VPERMILPDZrr(b?)(k?)(z?)", + "VPERMILPDri", + "VPERMILPDrr", + "VPERMILPSYri", + "VPERMILPSYrr", + "VPERMILPSZ128r(b?)i(k?)(z?)", + "VPERMILPSZ128rr(b?)(k?)(z?)", + "VPERMILPSZ256r(b?)i(k?)(z?)", + "VPERMILPSZ256rr(b?)(k?)(z?)", + "VPERMILPSZri(b?)(k?)(z?)", + "VPERMILPSZrr(b?)(k?)(z?)", + "VPERMILPSri", + "VPERMILPSrr", + "VPMOVSXBDrr", + "VPMOVSXBQrr", + "VPMOVSXBWrr", + "VPMOVSXDQrr", + "VPMOVSXWDrr", + "VPMOVSXWQrr", + "VPMOVZXBDrr", + "VPMOVZXBQrr", + "VPMOVZXBWrr", + "VPMOVZXDQrr", + "VPMOVZXWDrr", + "VPMOVZXWQrr", + "VPSHUFBYrr", + "VPSHUFBZ128rr(b?)(k?)(z?)", + "VPSHUFBZ256rr(b?)(k?)(z?)", + "VPSHUFBZrr(b?)(k?)(z?)", + "VPSHUFBrr", + "VPSHUFDYri", + "VPSHUFDZ128r(b?)i(k?)(z?)", + "VPSHUFDZ256r(b?)i(k?)(z?)", + "VPSHUFDZri(b?)(k?)(z?)", + "VPSHUFDri", + "VPSHUFHWYri", + "VPSHUFHWZ128r(b?)i(k?)(z?)", + "VPSHUFHWZ256r(b?)i(k?)(z?)", + "VPSHUFHWZri(b?)(k?)(z?)", + "VPSHUFHWri", + "VPSHUFLWYri", + "VPSHUFLWZ128r(b?)i(k?)(z?)", + "VPSHUFLWZ256r(b?)i(k?)(z?)", + "VPSHUFLWZri(b?)(k?)(z?)", + "VPSHUFLWri", + "VPSLLDQYri", + "VPSLLDQZ128rr(b?)(k?)(z?)", + "VPSLLDQZ256rr(b?)(k?)(z?)", + "VPSLLDQZrr(b?)(k?)(z?)", + "VPSLLDQri", + "VPSRLDQYri", + "VPSRLDQZ128rr(b?)(k?)(z?)", + "VPSRLDQZ256rr(b?)(k?)(z?)", + "VPSRLDQZrr(b?)(k?)(z?)", + "VPSRLDQri", + "VPUNPCKHBWYrr", + "VPUNPCKHBWZ128rr(b?)(k?)(z?)", + "VPUNPCKHBWZ256rr(b?)(k?)(z?)", + "VPUNPCKHBWZrr(b?)(k?)(z?)", + "VPUNPCKHBWrr", + "VPUNPCKHDQYrr", + "VPUNPCKHDQZ128rr(b?)(k?)(z?)", + "VPUNPCKHDQZ256rr(b?)(k?)(z?)", + "VPUNPCKHDQZrr(b?)(k?)(z?)", + "VPUNPCKHDQrr", + "VPUNPCKHQDQYrr", + "VPUNPCKHQDQZ128rr(b?)(k?)(z?)", + "VPUNPCKHQDQZ256rr(b?)(k?)(z?)", + "VPUNPCKHQDQZrr(b?)(k?)(z?)", + "VPUNPCKHQDQrr", + "VPUNPCKHWDYrr", + "VPUNPCKHWDZ128rr(b?)(k?)(z?)", + "VPUNPCKHWDZ256rr(b?)(k?)(z?)", + "VPUNPCKHWDZrr(b?)(k?)(z?)", + "VPUNPCKHWDrr", + "VPUNPCKLBWYrr", + "VPUNPCKLBWZ128rr(b?)(k?)(z?)", + "VPUNPCKLBWZ256rr(b?)(k?)(z?)", + "VPUNPCKLBWZrr(b?)(k?)(z?)", + "VPUNPCKLBWrr", + "VPUNPCKLDQYrr", + "VPUNPCKLDQZ128rr(b?)(k?)(z?)", + "VPUNPCKLDQZ256rr(b?)(k?)(z?)", + "VPUNPCKLDQZrr(b?)(k?)(z?)", + "VPUNPCKLDQrr", + "VPUNPCKLQDQYrr", + "VPUNPCKLQDQZ128rr(b?)(k?)(z?)", + "VPUNPCKLQDQZ256rr(b?)(k?)(z?)", + "VPUNPCKLQDQZrr(b?)(k?)(z?)", + "VPUNPCKLQDQrr", + "VPUNPCKLWDYrr", + "VPUNPCKLWDZ128rr(b?)(k?)(z?)", + "VPUNPCKLWDZ256rr(b?)(k?)(z?)", + "VPUNPCKLWDZrr(b?)(k?)(z?)", + "VPUNPCKLWDrr", + "VSHUFPDYrri", + "VSHUFPDZ128rri(b?)(k?)(z?)", + "VSHUFPDZ256rri(b?)(k?)(z?)", + "VSHUFPDZrri(b?)(k?)(z?)", + "VSHUFPDrri", + "VSHUFPSYrri", + "VSHUFPSZ128rri(b?)(k?)(z?)", + "VSHUFPSZ256rri(b?)(k?)(z?)", + "VSHUFPSZrri(b?)(k?)(z?)", + "VSHUFPSrri", + "VUNPCKHPDYrr", + "VUNPCKHPDZ128rr(b?)(k?)(z?)", + "VUNPCKHPDZ256rr(b?)(k?)(z?)", + "VUNPCKHPDZrr(b?)(k?)(z?)", + "VUNPCKHPDrr", + "VUNPCKHPSYrr", + "VUNPCKHPSZ128rr(b?)(k?)(z?)", + "VUNPCKHPSZ256rr(b?)(k?)(z?)", + "VUNPCKHPSZrr(b?)(k?)(z?)", + "VUNPCKHPSrr", + "VUNPCKLPDYrr", + "VUNPCKLPDZ128rr(b?)(k?)(z?)", + "VUNPCKLPDZ256rr(b?)(k?)(z?)", + "VUNPCKLPDZrr(b?)(k?)(z?)", + "VUNPCKLPDrr", + "VUNPCKLPSYrr", + "VUNPCKLPSZ128rr(b?)(k?)(z?)", + "VUNPCKLPSZ256rr(b?)(k?)(z?)", + "VUNPCKLPSZrr(b?)(k?)(z?)", + "VUNPCKLPSrr")>; def SKXWriteResGroup4 : SchedWriteRes<[SKXPort6]> { let Latency = 1; @@ -636,929 +636,929 @@ def SKXWriteResGroup5 : SchedWriteRes<[SKXPort01]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup5], (instregex "PABSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PABSDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PABSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PADDSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PADDSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PADDUSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PADDUSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PAVGBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PAVGWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPEQBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPEQDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPEQQrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPEQWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPGTBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPGTDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PCMPGTWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAXSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAX(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAXSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAXUBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAXUDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMAXUWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMINSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMIN(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMINSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMINUBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMINUDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PMINUWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSIGNBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSIGNDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSIGNWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSLLDri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSLLQri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSLLWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSRADri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSRAWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSRLDri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSRLQri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSRLWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSUBSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSUBSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSUBUSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "PSUBUSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPABSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPADDUSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPAVGWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQQYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQQrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPEQWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPCMPGTWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAX(C?)SDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAX(C?)SDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAX(C?)SDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAX(C?)SDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAX(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMAXUWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMIN(C?)SDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMIN(C?)SDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMIN(C?)SDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMIN(C?)SDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMIN(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPMINUWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLQZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPROLVQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORQZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPRORVQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSIGNWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLDYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLDri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLQYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLQZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLQri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVQYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVQrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLVWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLWYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLWZ128ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLWZ256ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLWZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSLLWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRADYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRADZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRADZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRADZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRADri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAQZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAVWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAWYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAWZ128ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAWZ256ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAWZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRAWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLDYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLDZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLDri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLQYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLQZ128r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLQri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVDYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVDrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVQYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVQrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLVWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLWYri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLWZ128ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLWZ256ri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLWZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSRLWri")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBSWrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSBYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSBrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSWYrr")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup5], (instregex "VPSUBUSWrr")>; +def: InstRW<[SKXWriteResGroup5], (instregex "PABSBrr", + "PABSDrr", + "PABSWrr", + "PADDSBrr", + "PADDSWrr", + "PADDUSBrr", + "PADDUSWrr", + "PAVGBrr", + "PAVGWrr", + "PCMPEQBrr", + "PCMPEQDrr", + "PCMPEQQrr", + "PCMPEQWrr", + "PCMPGTBrr", + "PCMPGTDrr", + "PCMPGTWrr", + "PMAXSBrr", + "PMAX(C?)SDrr", + "PMAXSWrr", + "PMAXUBrr", + "PMAXUDrr", + "PMAXUWrr", + "PMINSBrr", + "PMIN(C?)SDrr", + "PMINSWrr", + "PMINUBrr", + "PMINUDrr", + "PMINUWrr", + "PSIGNBrr", + "PSIGNDrr", + "PSIGNWrr", + "PSLLDri", + "PSLLQri", + "PSLLWri", + "PSRADri", + "PSRAWri", + "PSRLDri", + "PSRLQri", + "PSRLWri", + "PSUBSBrr", + "PSUBSWrr", + "PSUBUSBrr", + "PSUBUSWrr", + "VPABSBYrr", + "VPABSBZ128rr(b?)(k?)(z?)", + "VPABSBZ256rr(b?)(k?)(z?)", + "VPABSBZrr(b?)(k?)(z?)", + "VPABSBrr", + "VPABSDYrr", + "VPABSDZ128rr(b?)(k?)(z?)", + "VPABSDZ256rr(b?)(k?)(z?)", + "VPABSDZrr(b?)(k?)(z?)", + "VPABSDrr", + "VPABSQZ128rr(b?)(k?)(z?)", + "VPABSQZ256rr(b?)(k?)(z?)", + "VPABSQZrr(b?)(k?)(z?)", + "VPABSWYrr", + "VPABSWZ128rr(b?)(k?)(z?)", + "VPABSWZ256rr(b?)(k?)(z?)", + "VPABSWZrr(b?)(k?)(z?)", + "VPABSWrr", + "VPADDSBYrr", + "VPADDSBZ128rr(b?)(k?)(z?)", + "VPADDSBZ256rr(b?)(k?)(z?)", + "VPADDSBZrr(b?)(k?)(z?)", + "VPADDSBrr", + "VPADDSWYrr", + "VPADDSWZ128rr(b?)(k?)(z?)", + "VPADDSWZ256rr(b?)(k?)(z?)", + "VPADDSWZrr(b?)(k?)(z?)", + "VPADDSWrr", + "VPADDUSBYrr", + "VPADDUSBZ128rr(b?)(k?)(z?)", + "VPADDUSBZ256rr(b?)(k?)(z?)", + "VPADDUSBZrr(b?)(k?)(z?)", + "VPADDUSBrr", + "VPADDUSWYrr", + "VPADDUSWZ128rr(b?)(k?)(z?)", + "VPADDUSWZ256rr(b?)(k?)(z?)", + "VPADDUSWZrr(b?)(k?)(z?)", + "VPADDUSWrr", + "VPAVGBYrr", + "VPAVGBZ128rr(b?)(k?)(z?)", + "VPAVGBZ256rr(b?)(k?)(z?)", + "VPAVGBZrr(b?)(k?)(z?)", + "VPAVGBrr", + "VPAVGWYrr", + "VPAVGWZ128rr(b?)(k?)(z?)", + "VPAVGWZ256rr(b?)(k?)(z?)", + "VPAVGWZrr(b?)(k?)(z?)", + "VPAVGWrr", + "VPCMPEQBYrr", + "VPCMPEQBrr", + "VPCMPEQDYrr", + "VPCMPEQDrr", + "VPCMPEQQYrr", + "VPCMPEQQrr", + "VPCMPEQWYrr", + "VPCMPEQWrr", + "VPCMPGTBYrr", + "VPCMPGTBrr", + "VPCMPGTDYrr", + "VPCMPGTDrr", + "VPCMPGTWYrr", + "VPCMPGTWrr", + "VPMAXSBYrr", + "VPMAXSBZ128rr(b?)(k?)(z?)", + "VPMAXSBZ256rr(b?)(k?)(z?)", + "VPMAXSBZrr(b?)(k?)(z?)", + "VPMAXSBrr", + "VPMAX(C?)SDYrr", + "VPMAX(C?)SDZ128rr(b?)(k?)(z?)", + "VPMAX(C?)SDZ256rr(b?)(k?)(z?)", + "VPMAX(C?)SDZrr(b?)(k?)(z?)", + "VPMAX(C?)SDrr", + "VPMAXSWYrr", + "VPMAXSWZ128rr(b?)(k?)(z?)", + "VPMAXSWZ256rr(b?)(k?)(z?)", + "VPMAXSWZrr(b?)(k?)(z?)", + "VPMAXSWrr", + "VPMAXUBYrr", + "VPMAXUBZ128rr(b?)(k?)(z?)", + "VPMAXUBZ256rr(b?)(k?)(z?)", + "VPMAXUBZrr(b?)(k?)(z?)", + "VPMAXUBrr", + "VPMAXUDYrr", + "VPMAXUDZ128rr(b?)(k?)(z?)", + "VPMAXUDZ256rr(b?)(k?)(z?)", + "VPMAXUDZrr(b?)(k?)(z?)", + "VPMAXUDrr", + "VPMAXUWYrr", + "VPMAXUWZ128rr(b?)(k?)(z?)", + "VPMAXUWZ256rr(b?)(k?)(z?)", + "VPMAXUWZrr(b?)(k?)(z?)", + "VPMAXUWrr", + "VPMINSBYrr", + "VPMINSBZ128rr(b?)(k?)(z?)", + "VPMINSBZ256rr(b?)(k?)(z?)", + "VPMINSBZrr(b?)(k?)(z?)", + "VPMINSBrr", + "VPMIN(C?)SDYrr", + "VPMIN(C?)SDZ128rr(b?)(k?)(z?)", + "VPMIN(C?)SDZ256rr(b?)(k?)(z?)", + "VPMIN(C?)SDZrr(b?)(k?)(z?)", + "VPMIN(C?)SDrr", + "VPMINSWYrr", + "VPMINSWZ128rr(b?)(k?)(z?)", + "VPMINSWZ256rr(b?)(k?)(z?)", + "VPMINSWZrr(b?)(k?)(z?)", + "VPMINSWrr", + "VPMINUBYrr", + "VPMINUBZ128rr(b?)(k?)(z?)", + "VPMINUBZ256rr(b?)(k?)(z?)", + "VPMINUBZrr(b?)(k?)(z?)", + "VPMINUBrr", + "VPMINUDYrr", + "VPMINUDZ128rr(b?)(k?)(z?)", + "VPMINUDZ256rr(b?)(k?)(z?)", + "VPMINUDZrr(b?)(k?)(z?)", + "VPMINUDrr", + "VPMINUWYrr", + "VPMINUWZ128rr(b?)(k?)(z?)", + "VPMINUWZ256rr(b?)(k?)(z?)", + "VPMINUWZrr(b?)(k?)(z?)", + "VPMINUWrr", + "VPROLDZ128r(b?)i(k?)(z?)", + "VPROLDZ256r(b?)i(k?)(z?)", + "VPROLDZri(b?)(k?)(z?)", + "VPROLQZ128r(b?)i(k?)(z?)", + "VPROLQZ256r(b?)i(k?)(z?)", + "VPROLQZri(b?)(k?)(z?)", + "VPROLVDZ128rr(b?)(k?)(z?)", + "VPROLVDZ256rr(b?)(k?)(z?)", + "VPROLVDZrr(b?)(k?)(z?)", + "VPROLVQZ128rr(b?)(k?)(z?)", + "VPROLVQZ256rr(b?)(k?)(z?)", + "VPROLVQZrr(b?)(k?)(z?)", + "VPRORDZ128r(b?)i(k?)(z?)", + "VPRORDZ256r(b?)i(k?)(z?)", + "VPRORDZri(b?)(k?)(z?)", + "VPRORQZ128r(b?)i(k?)(z?)", + "VPRORQZ256r(b?)i(k?)(z?)", + "VPRORQZri(b?)(k?)(z?)", + "VPRORVDZ128rr(b?)(k?)(z?)", + "VPRORVDZ256rr(b?)(k?)(z?)", + "VPRORVDZrr(b?)(k?)(z?)", + "VPRORVQZ128rr(b?)(k?)(z?)", + "VPRORVQZ256rr(b?)(k?)(z?)", + "VPRORVQZrr(b?)(k?)(z?)", + "VPSIGNBYrr", + "VPSIGNBrr", + "VPSIGNDYrr", + "VPSIGNDrr", + "VPSIGNWYrr", + "VPSIGNWrr", + "VPSLLDYri", + "VPSLLDZ128r(b?)i(k?)(z?)", + "VPSLLDZ256r(b?)i(k?)(z?)", + "VPSLLDZri(b?)(k?)(z?)", + "VPSLLDri", + "VPSLLQYri", + "VPSLLQZ128r(b?)i(k?)(z?)", + "VPSLLQZ256r(b?)i(k?)(z?)", + "VPSLLQZri(b?)(k?)(z?)", + "VPSLLQri", + "VPSLLVDYrr", + "VPSLLVDZ128rr(b?)(k?)(z?)", + "VPSLLVDZ256rr(b?)(k?)(z?)", + "VPSLLVDZrr(b?)(k?)(z?)", + "VPSLLVDrr", + "VPSLLVQYrr", + "VPSLLVQZ128rr(b?)(k?)(z?)", + "VPSLLVQZ256rr(b?)(k?)(z?)", + "VPSLLVQZrr(b?)(k?)(z?)", + "VPSLLVQrr", + "VPSLLVWZ128rr(b?)(k?)(z?)", + "VPSLLVWZ256rr(b?)(k?)(z?)", + "VPSLLVWZrr(b?)(k?)(z?)", + "VPSLLWYri", + "VPSLLWZ128ri(b?)(k?)(z?)", + "VPSLLWZ256ri(b?)(k?)(z?)", + "VPSLLWZri(b?)(k?)(z?)", + "VPSLLWri", + "VPSRADYri", + "VPSRADZ128r(b?)i(k?)(z?)", + "VPSRADZ256r(b?)i(k?)(z?)", + "VPSRADZri(b?)(k?)(z?)", + "VPSRADri", + "VPSRAQZ128r(b?)i(k?)(z?)", + "VPSRAQZ256r(b?)i(k?)(z?)", + "VPSRAQZri(b?)(k?)(z?)", + "VPSRAVDYrr", + "VPSRAVDZ128rr(b?)(k?)(z?)", + "VPSRAVDZ256rr(b?)(k?)(z?)", + "VPSRAVDZrr(b?)(k?)(z?)", + "VPSRAVDrr", + "VPSRAVQZ128rr(b?)(k?)(z?)", + "VPSRAVQZ256rr(b?)(k?)(z?)", + "VPSRAVQZrr(b?)(k?)(z?)", + "VPSRAVWZ128rr(b?)(k?)(z?)", + "VPSRAVWZ256rr(b?)(k?)(z?)", + "VPSRAVWZrr(b?)(k?)(z?)", + "VPSRAWYri", + "VPSRAWZ128ri(b?)(k?)(z?)", + "VPSRAWZ256ri(b?)(k?)(z?)", + "VPSRAWZri(b?)(k?)(z?)", + "VPSRAWri", + "VPSRLDYri", + "VPSRLDZ128r(b?)i(k?)(z?)", + "VPSRLDZ256r(b?)i(k?)(z?)", + "VPSRLDZri(b?)(k?)(z?)", + "VPSRLDri", + "VPSRLQYri", + "VPSRLQZ128r(b?)i(k?)(z?)", + "VPSRLQZ256r(b?)i(k?)(z?)", + "VPSRLQZri(b?)(k?)(z?)", + "VPSRLQri", + "VPSRLVDYrr", + "VPSRLVDZ128rr(b?)(k?)(z?)", + "VPSRLVDZ256rr(b?)(k?)(z?)", + "VPSRLVDZrr(b?)(k?)(z?)", + "VPSRLVDrr", + "VPSRLVQYrr", + "VPSRLVQZ128rr(b?)(k?)(z?)", + "VPSRLVQZ256rr(b?)(k?)(z?)", + "VPSRLVQZrr(b?)(k?)(z?)", + "VPSRLVQrr", + "VPSRLVWZ128rr(b?)(k?)(z?)", + "VPSRLVWZ256rr(b?)(k?)(z?)", + "VPSRLVWZrr(b?)(k?)(z?)", + "VPSRLWYri", + "VPSRLWZ128ri(b?)(k?)(z?)", + "VPSRLWZ256ri(b?)(k?)(z?)", + "VPSRLWZri(b?)(k?)(z?)", + "VPSRLWri", + "VPSUBSBYrr", + "VPSUBSBZ128rr(b?)(k?)(z?)", + "VPSUBSBZ256rr(b?)(k?)(z?)", + "VPSUBSBZrr(b?)(k?)(z?)", + "VPSUBSBrr", + "VPSUBSWYrr", + "VPSUBSWZ128rr(b?)(k?)(z?)", + "VPSUBSWZ256rr(b?)(k?)(z?)", + "VPSUBSWZrr(b?)(k?)(z?)", + "VPSUBSWrr", + "VPSUBUSBYrr", + "VPSUBUSBZ128rr(b?)(k?)(z?)", + "VPSUBUSBZ256rr(b?)(k?)(z?)", + "VPSUBUSBZrr(b?)(k?)(z?)", + "VPSUBUSBrr", + "VPSUBUSWYrr", + "VPSUBUSWZ128rr(b?)(k?)(z?)", + "VPSUBUSWZ256rr(b?)(k?)(z?)", + "VPSUBUSWZrr(b?)(k?)(z?)", + "VPSUBUSWrr")>; def SKXWriteResGroup6 : SchedWriteRes<[SKXPort05]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup6], (instregex "FINCSTP")>; -def: InstRW<[SKXWriteResGroup6], (instregex "FNOP")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_MOVQ64rr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PABSBrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PABSDrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PABSWrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PADDBirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PADDDirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PADDQirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PADDWirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PANDNirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PANDirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PORirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSIGNBrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSIGNDrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSIGNWrr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSUBBirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSUBDirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSUBQirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PSUBWirr")>; -def: InstRW<[SKXWriteResGroup6], (instregex "MMX_PXORirr")>; +def: InstRW<[SKXWriteResGroup6], (instregex "FINCSTP", + "FNOP", + "MMX_MOVQ64rr", + "MMX_PABSBrr", + "MMX_PABSDrr", + "MMX_PABSWrr", + "MMX_PADDBirr", + "MMX_PADDDirr", + "MMX_PADDQirr", + "MMX_PADDWirr", + "MMX_PANDNirr", + "MMX_PANDirr", + "MMX_PORirr", + "MMX_PSIGNBrr", + "MMX_PSIGNDrr", + "MMX_PSIGNWrr", + "MMX_PSUBBirr", + "MMX_PSUBDirr", + "MMX_PSUBQirr", + "MMX_PSUBWirr", + "MMX_PXORirr")>; def SKXWriteResGroup7 : SchedWriteRes<[SKXPort06]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup7], (instregex "ADC(16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "ADC(16|32|64)i")>; -def: InstRW<[SKXWriteResGroup7], (instregex "ADC(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "ADCX(32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "ADOX(32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BT(16|32|64)ri8")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BT(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTC(16|32|64)ri8")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTC(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTR(16|32|64)ri8")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTR(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTS(16|32|64)ri8")>; -def: InstRW<[SKXWriteResGroup7], (instregex "BTS(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "CDQ")>; -def: InstRW<[SKXWriteResGroup7], (instregex "CLAC")>; -def: InstRW<[SKXWriteResGroup7], (instregex "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "CQO")>; -def: InstRW<[SKXWriteResGroup7], (instregex "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_1")>; -def: InstRW<[SKXWriteResGroup7], (instregex "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_4")>; -def: InstRW<[SKXWriteResGroup7], (instregex "JMP_1")>; -def: InstRW<[SKXWriteResGroup7], (instregex "JMP_4")>; -def: InstRW<[SKXWriteResGroup7], (instregex "RORX(32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SAR(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SAR(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SARX(32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SBB(16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SBB(16|32|64)i")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SBB(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SET(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)r")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHL(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHL(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHLX(32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHR(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHR(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup7], (instregex "SHRX(32|64)rr")>; -def: InstRW<[SKXWriteResGroup7], (instregex "STAC")>; +def: InstRW<[SKXWriteResGroup7], (instregex "ADC(16|32|64)ri", + "ADC(16|32|64)i", + "ADC(8|16|32|64)rr", + "ADCX(32|64)rr", + "ADOX(32|64)rr", + "BT(16|32|64)ri8", + "BT(16|32|64)rr", + "BTC(16|32|64)ri8", + "BTC(16|32|64)rr", + "BTR(16|32|64)ri8", + "BTR(16|32|64)rr", + "BTS(16|32|64)ri8", + "BTS(16|32|64)rr", + "CDQ", + "CLAC", + "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rr", + "CQO", + "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_1", + "J(A|AE|B|BE|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)_4", + "JMP_1", + "JMP_4", + "RORX(32|64)ri", + "SAR(8|16|32|64)r1", + "SAR(8|16|32|64)ri", + "SARX(32|64)rr", + "SBB(16|32|64)ri", + "SBB(16|32|64)i", + "SBB(8|16|32|64)rr", + "SET(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)r", + "SHL(8|16|32|64)r1", + "SHL(8|16|32|64)ri", + "SHLX(32|64)rr", + "SHR(8|16|32|64)r1", + "SHR(8|16|32|64)ri", + "SHRX(32|64)rr", + "STAC")>; def SKXWriteResGroup8 : SchedWriteRes<[SKXPort15]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup8], (instregex "ANDN(32|64)rr")>; -def: InstRW<[SKXWriteResGroup8], (instregex "BLSI(32|64)rr")>; -def: InstRW<[SKXWriteResGroup8], (instregex "BLSMSK(32|64)rr")>; -def: InstRW<[SKXWriteResGroup8], (instregex "BLSR(32|64)rr")>; -def: InstRW<[SKXWriteResGroup8], (instregex "BZHI(32|64)rr")>; -def: InstRW<[SKXWriteResGroup8], (instregex "LEA(16|32|64)(_32)?r")>; +def: InstRW<[SKXWriteResGroup8], (instregex "ANDN(32|64)rr", + "BLSI(32|64)rr", + "BLSMSK(32|64)rr", + "BLSR(32|64)rr", + "BZHI(32|64)rr", + "LEA(16|32|64)(_32)?r")>; def SKXWriteResGroup9 : SchedWriteRes<[SKXPort015]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup9], (instregex "ANDNPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "ANDNPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "ANDPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "ANDPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "BLENDPDrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "BLENDPSrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVAPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVAPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVDQArr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVDQUrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVPQI2QIrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "MOVSSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "ORPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "ORPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PADDBrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PADDDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PADDQrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PADDWrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PANDNrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PANDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PORrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PSUBBrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PSUBDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PSUBQrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PSUBWrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "PXORrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPSYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDNPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPSYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VANDPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDMPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDPDYrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDPDrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDPSYrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VBLENDPSrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPSYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVAPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA32Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA32Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA32Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA64Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA64Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQA64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQAYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQArr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU16Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU16Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU16Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU32Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU32Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU32Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU64Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU64Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU8Z128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU8Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQU8Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQUYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVDQUrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVPQI(2Q|Lo2PQ)IZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVPQI2QIrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVSSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVUPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VMOVZPQILo2PQIrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPSYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VORPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDBYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDBrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDQYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDQrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDWYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPADDWrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDNrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPANDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDDYrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDDrri")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPBLENDMWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPORrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBBYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBBrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBQYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBQrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBWYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPSUBWrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGQZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGQZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPTERNLOGQZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VPXORrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPDYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPSYrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup9], (instregex "VXORPSrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "XORPDrr")>; -def: InstRW<[SKXWriteResGroup9], (instregex "XORPSrr")>; +def: InstRW<[SKXWriteResGroup9], (instregex "ANDNPDrr", + "ANDNPSrr", + "ANDPDrr", + "ANDPSrr", + "BLENDPDrri", + "BLENDPSrri", + "MOVAPDrr", + "MOVAPSrr", + "MOVDQArr", + "MOVDQUrr", + "MOVPQI2QIrr", + "MOVSSrr", + "ORPDrr", + "ORPSrr", + "PADDBrr", + "PADDDrr", + "PADDQrr", + "PADDWrr", + "PANDNrr", + "PANDrr", + "PORrr", + "PSUBBrr", + "PSUBDrr", + "PSUBQrr", + "PSUBWrr", + "PXORrr", + "VANDNPDYrr", + "VANDNPDZ128rr(b?)(k?)(z?)", + "VANDNPDZ256rr(b?)(k?)(z?)", + "VANDNPDZrr(b?)(k?)(z?)", + "VANDNPDrr", + "VANDNPSYrr", + "VANDNPSZ128rr(b?)(k?)(z?)", + "VANDNPSZ256rr(b?)(k?)(z?)", + "VANDNPSZrr(b?)(k?)(z?)", + "VANDNPSrr", + "VANDPDYrr", + "VANDPDZ128rr(b?)(k?)(z?)", + "VANDPDZ256rr(b?)(k?)(z?)", + "VANDPDZrr(b?)(k?)(z?)", + "VANDPDrr", + "VANDPSYrr", + "VANDPSZ128rr(b?)(k?)(z?)", + "VANDPSZ256rr(b?)(k?)(z?)", + "VANDPSZrr(b?)(k?)(z?)", + "VANDPSrr", + "VBLENDMPDZ128rr(b?)(k?)(z?)", + "VBLENDMPDZ256rr(b?)(k?)(z?)", + "VBLENDMPDZrr(b?)(k?)(z?)", + "VBLENDMPSZ128rr(b?)(k?)(z?)", + "VBLENDMPSZ256rr(b?)(k?)(z?)", + "VBLENDMPSZrr(b?)(k?)(z?)", + "VBLENDPDYrri", + "VBLENDPDrri", + "VBLENDPSYrri", + "VBLENDPSrri", + "VMOVAPDYrr", + "VMOVAPDZ128rr(b?)(k?)(z?)", + "VMOVAPDZ256rr(b?)(k?)(z?)", + "VMOVAPDZrr(b?)(k?)(z?)", + "VMOVAPDrr", + "VMOVAPSYrr", + "VMOVAPSZ128rr(b?)(k?)(z?)", + "VMOVAPSZ256rr(b?)(k?)(z?)", + "VMOVAPSZrr(b?)(k?)(z?)", + "VMOVAPSrr", + "VMOVDQA32Z128rr(b?)(k?)(z?)", + "VMOVDQA32Z256rr(b?)(k?)(z?)", + "VMOVDQA32Zrr(b?)(k?)(z?)", + "VMOVDQA64Z128rr(b?)(k?)(z?)", + "VMOVDQA64Z256rr(b?)(k?)(z?)", + "VMOVDQA64Zrr(b?)(k?)(z?)", + "VMOVDQAYrr", + "VMOVDQArr", + "VMOVDQU16Z128rr(b?)(k?)(z?)", + "VMOVDQU16Z256rr(b?)(k?)(z?)", + "VMOVDQU16Zrr(b?)(k?)(z?)", + "VMOVDQU32Z128rr(b?)(k?)(z?)", + "VMOVDQU32Z256rr(b?)(k?)(z?)", + "VMOVDQU32Zrr(b?)(k?)(z?)", + "VMOVDQU64Z128rr(b?)(k?)(z?)", + "VMOVDQU64Z256rr(b?)(k?)(z?)", + "VMOVDQU64Zrr(b?)(k?)(z?)", + "VMOVDQU8Z128rr(b?)(k?)(z?)", + "VMOVDQU8Z256rr(b?)(k?)(z?)", + "VMOVDQU8Zrr(b?)(k?)(z?)", + "VMOVDQUYrr", + "VMOVDQUrr", + "VMOVPQI(2Q|Lo2PQ)IZrr(b?)(k?)(z?)", + "VMOVPQI2QIrr", + "VMOVSSrr", + "VMOVUPDZ128rr(b?)(k?)(z?)", + "VMOVUPDZ256rr(b?)(k?)(z?)", + "VMOVUPDZrr(b?)(k?)(z?)", + "VMOVUPSZ128rr(b?)(k?)(z?)", + "VMOVUPSZ256rr(b?)(k?)(z?)", + "VMOVUPSZrr(b?)(k?)(z?)", + "VMOVZPQILo2PQIrr", + "VORPDYrr", + "VORPDZ128rr(b?)(k?)(z?)", + "VORPDZ256rr(b?)(k?)(z?)", + "VORPDZrr(b?)(k?)(z?)", + "VORPDrr", + "VORPSYrr", + "VORPSZ128rr(b?)(k?)(z?)", + "VORPSZ256rr(b?)(k?)(z?)", + "VORPSZrr(b?)(k?)(z?)", + "VORPSrr", + "VPADDBYrr", + "VPADDBZ128rr(b?)(k?)(z?)", + "VPADDBZ256rr(b?)(k?)(z?)", + "VPADDBZrr(b?)(k?)(z?)", + "VPADDBrr", + "VPADDDYrr", + "VPADDDZ128rr(b?)(k?)(z?)", + "VPADDDZ256rr(b?)(k?)(z?)", + "VPADDDZrr(b?)(k?)(z?)", + "VPADDDrr", + "VPADDQYrr", + "VPADDQZ128rr(b?)(k?)(z?)", + "VPADDQZ256rr(b?)(k?)(z?)", + "VPADDQZrr(b?)(k?)(z?)", + "VPADDQrr", + "VPADDWYrr", + "VPADDWZ128rr(b?)(k?)(z?)", + "VPADDWZ256rr(b?)(k?)(z?)", + "VPADDWZrr(b?)(k?)(z?)", + "VPADDWrr", + "VPANDDZ128rr(b?)(k?)(z?)", + "VPANDDZ256rr(b?)(k?)(z?)", + "VPANDDZrr(b?)(k?)(z?)", + "VPANDNDZ128rr(b?)(k?)(z?)", + "VPANDNDZ256rr(b?)(k?)(z?)", + "VPANDNDZrr(b?)(k?)(z?)", + "VPANDNQZ128rr(b?)(k?)(z?)", + "VPANDNQZ256rr(b?)(k?)(z?)", + "VPANDNQZrr(b?)(k?)(z?)", + "VPANDNYrr", + "VPANDNrr", + "VPANDQZ128rr(b?)(k?)(z?)", + "VPANDQZ256rr(b?)(k?)(z?)", + "VPANDQZrr(b?)(k?)(z?)", + "VPANDYrr", + "VPANDrr", + "VPBLENDDYrri", + "VPBLENDDrri", + "VPBLENDMBZ128rr(b?)(k?)(z?)", + "VPBLENDMBZ256rr(b?)(k?)(z?)", + "VPBLENDMBZrr(b?)(k?)(z?)", + "VPBLENDMDZ128rr(b?)(k?)(z?)", + "VPBLENDMDZ256rr(b?)(k?)(z?)", + "VPBLENDMDZrr(b?)(k?)(z?)", + "VPBLENDMQZ128rr(b?)(k?)(z?)", + "VPBLENDMQZ256rr(b?)(k?)(z?)", + "VPBLENDMQZrr(b?)(k?)(z?)", + "VPBLENDMWZ128rr(b?)(k?)(z?)", + "VPBLENDMWZ256rr(b?)(k?)(z?)", + "VPBLENDMWZrr(b?)(k?)(z?)", + "VPORDZ128rr(b?)(k?)(z?)", + "VPORDZ256rr(b?)(k?)(z?)", + "VPORDZrr(b?)(k?)(z?)", + "VPORQZ128rr(b?)(k?)(z?)", + "VPORQZ256rr(b?)(k?)(z?)", + "VPORQZrr(b?)(k?)(z?)", + "VPORYrr", + "VPORrr", + "VPSUBBYrr", + "VPSUBBZ128rr(b?)(k?)(z?)", + "VPSUBBZ256rr(b?)(k?)(z?)", + "VPSUBBZrr(b?)(k?)(z?)", + "VPSUBBrr", + "VPSUBDYrr", + "VPSUBDZ128rr(b?)(k?)(z?)", + "VPSUBDZ256rr(b?)(k?)(z?)", + "VPSUBDZrr(b?)(k?)(z?)", + "VPSUBDrr", + "VPSUBQYrr", + "VPSUBQZ128rr(b?)(k?)(z?)", + "VPSUBQZ256rr(b?)(k?)(z?)", + "VPSUBQZrr(b?)(k?)(z?)", + "VPSUBQrr", + "VPSUBWYrr", + "VPSUBWZ128rr(b?)(k?)(z?)", + "VPSUBWZrr(b?)(k?)(z?)", + "VPSUBWrr", + "VPTERNLOGDZ128rri(b?)(k?)(z?)", + "VPTERNLOGDZ256rri(b?)(k?)(z?)", + "VPTERNLOGDZrri(b?)(k?)(z?)", + "VPTERNLOGQZ128rri(b?)(k?)(z?)", + "VPTERNLOGQZ256rri(b?)(k?)(z?)", + "VPTERNLOGQZrri(b?)(k?)(z?)", + "VPXORDZ128rr(b?)(k?)(z?)", + "VPXORDZ256rr(b?)(k?)(z?)", + "VPXORDZrr(b?)(k?)(z?)", + "VPXORQZ128rr(b?)(k?)(z?)", + "VPXORQZ256rr(b?)(k?)(z?)", + "VPXORQZrr(b?)(k?)(z?)", + "VPXORYrr", + "VPXORrr", + "VXORPDYrr", + "VXORPDZ128rr(b?)(k?)(z?)", + "VXORPDZ256rr(b?)(k?)(z?)", + "VXORPDZrr(b?)(k?)(z?)", + "VXORPDrr", + "VXORPSYrr", + "VXORPSZ128rr(b?)(k?)(z?)", + "VXORPSZ256rr(b?)(k?)(z?)", + "VXORPSZrr(b?)(k?)(z?)", + "VXORPSrr", + "XORPDrr", + "XORPSrr")>; def SKXWriteResGroup10 : SchedWriteRes<[SKXPort0156]> { let Latency = 1; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup10], (instregex "ADD(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "ADD(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "ADD(8|16|32|64)i")>; -def: InstRW<[SKXWriteResGroup10], (instregex "AND(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "AND(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "AND(8|16|32|64)i")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CBW")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CLC")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CMC")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CMP(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CMP(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "CMP(8|16|32|64)i")>; def: InstRW<[SKXWriteResGroup10], (instrs CWDE)>; -def: InstRW<[SKXWriteResGroup10], (instregex "DEC(8|16|32|64)r")>; -def: InstRW<[SKXWriteResGroup10], (instregex "INC(8|16|32|64)r")>; -def: InstRW<[SKXWriteResGroup10], (instregex "LAHF")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOV(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOV(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOVSX(16|32|64)rr16")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOVSX(16|32|64)rr32")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOVSX(16|32|64)rr8")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOVZX(16|32|64)rr16")>; -def: InstRW<[SKXWriteResGroup10], (instregex "MOVZX(16|32|64)rr8")>; -def: InstRW<[SKXWriteResGroup10], (instregex "NEG(8|16|32|64)r")>; -def: InstRW<[SKXWriteResGroup10], (instregex "NOOP")>; -def: InstRW<[SKXWriteResGroup10], (instregex "NOT(8|16|32|64)r")>; -def: InstRW<[SKXWriteResGroup10], (instregex "OR(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "OR(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "OR(8|16|32|64)i")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SAHF")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SGDT64m")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SIDT64m")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SLDT64m")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SMSW16m")>; -def: InstRW<[SKXWriteResGroup10], (instregex "STC")>; -def: InstRW<[SKXWriteResGroup10], (instregex "STRm")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SUB(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SUB(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SUB(8|16|32|64)i")>; -def: InstRW<[SKXWriteResGroup10], (instregex "SYSCALL")>; -def: InstRW<[SKXWriteResGroup10], (instregex "TEST(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "TEST(8|16|32|64)i")>; -def: InstRW<[SKXWriteResGroup10], (instregex "TEST(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "XCHG(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "XOR(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup10], (instregex "XOR(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup10], (instregex "XOR(8|16|32|64)i")>; +def: InstRW<[SKXWriteResGroup10], (instregex "ADD(8|16|32|64)ri", + "ADD(8|16|32|64)rr", + "ADD(8|16|32|64)i", + "AND(8|16|32|64)ri", + "AND(8|16|32|64)rr", + "AND(8|16|32|64)i", + "CBW", + "CLC", + "CMC", + "CMP(8|16|32|64)ri", + "CMP(8|16|32|64)rr", + "CMP(8|16|32|64)i", + "DEC(8|16|32|64)r", + "INC(8|16|32|64)r", + "LAHF", + "MOV(8|16|32|64)rr", + "MOV(8|16|32|64)ri", + "MOVSX(16|32|64)rr16", + "MOVSX(16|32|64)rr32", + "MOVSX(16|32|64)rr8", + "MOVZX(16|32|64)rr16", + "MOVZX(16|32|64)rr8", + "NEG(8|16|32|64)r", + "NOOP", + "NOT(8|16|32|64)r", + "OR(8|16|32|64)ri", + "OR(8|16|32|64)rr", + "OR(8|16|32|64)i", + "SAHF", + "SGDT64m", + "SIDT64m", + "SLDT64m", + "SMSW16m", + "STC", + "STRm", + "SUB(8|16|32|64)ri", + "SUB(8|16|32|64)rr", + "SUB(8|16|32|64)i", + "SYSCALL", + "TEST(8|16|32|64)rr", + "TEST(8|16|32|64)i", + "TEST(8|16|32|64)ri", + "XCHG(16|32|64)rr", + "XOR(8|16|32|64)ri", + "XOR(8|16|32|64)rr", + "XOR(8|16|32|64)i")>; def SKXWriteResGroup11 : SchedWriteRes<[SKXPort4,SKXPort237]> { let Latency = 1; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup11], (instregex "FBSTPm")>; -def: InstRW<[SKXWriteResGroup11], (instregex "KMOVBmk")>; -def: InstRW<[SKXWriteResGroup11], (instregex "KMOVDmk")>; -def: InstRW<[SKXWriteResGroup11], (instregex "KMOVQmk")>; -def: InstRW<[SKXWriteResGroup11], (instregex "KMOVWmk")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MMX_MOVD64from64rm")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MMX_MOVD64mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MMX_MOVNTQmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MMX_MOVQ64mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOV(16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOV8mi")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOV8mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVAPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVAPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVDQAmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVDQUmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVHPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVHPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVLPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVLPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVNTDQmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVNTI_64mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVNTImr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVNTPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVNTPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVPDI2DImr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVPQI2QImr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVPQIto64mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVSDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVSSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVUPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "MOVUPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "ST_FP32m")>; -def: InstRW<[SKXWriteResGroup11], (instregex "ST_FP64m")>; -def: InstRW<[SKXWriteResGroup11], (instregex "ST_FP80m")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF128mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF32x4Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF32x4Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF32x8Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF64x2Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF64x2Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTF64x4Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI128mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI32x4Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI32x4Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI32x8Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI64x2Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI64x2Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VEXTRACTI64x4Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPDYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPSYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPSZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVAPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA32Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA32Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA32Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA64Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA64Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQA64Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQAYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQAmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU16Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU16Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU16Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU32Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU32Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU32Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU64Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU64Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU64Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU8Z128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQU8Z256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQUYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVDQUmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVHPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVHPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVHPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVHPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVLPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVLPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVLPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVLPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTDQYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTDQZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTDQZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTDQZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTDQmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPDYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPSYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPSZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVNTPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVPDI2DIZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVPDI2DImr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVPQI(2QI|to64)Zmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVPQI2QImr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVPQIto64mr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVSDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVSDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVSSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVSSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPDYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPDmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPSYmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPSZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMOVUPSmr")>; -def: InstRW<[SKXWriteResGroup11], (instregex "VMPTRSTm")>; +def: InstRW<[SKXWriteResGroup11], (instregex "FBSTPm", + "KMOVBmk", + "KMOVDmk", + "KMOVQmk", + "KMOVWmk", + "MMX_MOVD64from64rm", + "MMX_MOVD64mr", + "MMX_MOVNTQmr", + "MMX_MOVQ64mr", + "MOV(16|32|64)mr", + "MOV8mi", + "MOV8mr", + "MOVAPDmr", + "MOVAPSmr", + "MOVDQAmr", + "MOVDQUmr", + "MOVHPDmr", + "MOVHPSmr", + "MOVLPDmr", + "MOVLPSmr", + "MOVNTDQmr", + "MOVNTI_64mr", + "MOVNTImr", + "MOVNTPDmr", + "MOVNTPSmr", + "MOVPDI2DImr", + "MOVPQI2QImr", + "MOVPQIto64mr", + "MOVSDmr", + "MOVSSmr", + "MOVUPDmr", + "MOVUPSmr", + "ST_FP32m", + "ST_FP64m", + "ST_FP80m", + "VEXTRACTF128mr", + "VEXTRACTF32x4Z256mr(b?)(k?)(z?)", + "VEXTRACTF32x4Zmr(b?)(k?)(z?)", + "VEXTRACTF32x8Zmr(b?)(k?)(z?)", + "VEXTRACTF64x2Z256mr(b?)(k?)(z?)", + "VEXTRACTF64x2Zmr(b?)(k?)(z?)", + "VEXTRACTF64x4Zmr(b?)(k?)(z?)", + "VEXTRACTI128mr", + "VEXTRACTI32x4Z256mr(b?)(k?)(z?)", + "VEXTRACTI32x4Zmr(b?)(k?)(z?)", + "VEXTRACTI32x8Zmr(b?)(k?)(z?)", + "VEXTRACTI64x2Z256mr(b?)(k?)(z?)", + "VEXTRACTI64x2Zmr(b?)(k?)(z?)", + "VEXTRACTI64x4Zmr(b?)(k?)(z?)", + "VMOVAPDYmr", + "VMOVAPDZ128mr(b?)(k?)(z?)", + "VMOVAPDZ256mr(b?)(k?)(z?)", + "VMOVAPDZmr(b?)(k?)(z?)", + "VMOVAPDmr", + "VMOVAPSYmr", + "VMOVAPSZ128mr(b?)(k?)(z?)", + "VMOVAPSZ256mr(b?)(k?)(z?)", + "VMOVAPSZmr(b?)(k?)(z?)", + "VMOVAPSmr", + "VMOVDQA32Z128mr(b?)(k?)(z?)", + "VMOVDQA32Z256mr(b?)(k?)(z?)", + "VMOVDQA32Zmr(b?)(k?)(z?)", + "VMOVDQA64Z128mr(b?)(k?)(z?)", + "VMOVDQA64Z256mr(b?)(k?)(z?)", + "VMOVDQA64Zmr(b?)(k?)(z?)", + "VMOVDQAYmr", + "VMOVDQAmr", + "VMOVDQU16Z128mr(b?)(k?)(z?)", + "VMOVDQU16Z256mr(b?)(k?)(z?)", + "VMOVDQU16Zmr(b?)(k?)(z?)", + "VMOVDQU32Z128mr(b?)(k?)(z?)", + "VMOVDQU32Z256mr(b?)(k?)(z?)", + "VMOVDQU32Zmr(b?)(k?)(z?)", + "VMOVDQU64Z128mr(b?)(k?)(z?)", + "VMOVDQU64Z256mr(b?)(k?)(z?)", + "VMOVDQU64Zmr(b?)(k?)(z?)", + "VMOVDQU8Z128mr(b?)(k?)(z?)", + "VMOVDQU8Z256mr(b?)(k?)(z?)", + "VMOVDQUYmr", + "VMOVDQUmr", + "VMOVHPDZ128mr(b?)(k?)(z?)", + "VMOVHPDmr", + "VMOVHPSZ128mr(b?)(k?)(z?)", + "VMOVHPSmr", + "VMOVLPDZ128mr(b?)(k?)(z?)", + "VMOVLPDmr", + "VMOVLPSZ128mr(b?)(k?)(z?)", + "VMOVLPSmr", + "VMOVNTDQYmr", + "VMOVNTDQZ128mr(b?)(k?)(z?)", + "VMOVNTDQZ256mr(b?)(k?)(z?)", + "VMOVNTDQZmr(b?)(k?)(z?)", + "VMOVNTDQmr", + "VMOVNTPDYmr", + "VMOVNTPDZ128mr(b?)(k?)(z?)", + "VMOVNTPDZ256mr(b?)(k?)(z?)", + "VMOVNTPDZmr(b?)(k?)(z?)", + "VMOVNTPDmr", + "VMOVNTPSYmr", + "VMOVNTPSZ128mr(b?)(k?)(z?)", + "VMOVNTPSZ256mr(b?)(k?)(z?)", + "VMOVNTPSZmr(b?)(k?)(z?)", + "VMOVNTPSmr", + "VMOVPDI2DIZmr(b?)(k?)(z?)", + "VMOVPDI2DImr", + "VMOVPQI(2QI|to64)Zmr(b?)(k?)(z?)", + "VMOVPQI2QImr", + "VMOVPQIto64mr", + "VMOVSDZmr(b?)(k?)(z?)", + "VMOVSDmr", + "VMOVSSZmr(b?)(k?)(z?)", + "VMOVSSmr", + "VMOVUPDYmr", + "VMOVUPDZ128mr(b?)(k?)(z?)", + "VMOVUPDZ256mr(b?)(k?)(z?)", + "VMOVUPDZmr(b?)(k?)(z?)", + "VMOVUPDmr", + "VMOVUPSYmr", + "VMOVUPSZ128mr(b?)(k?)(z?)", + "VMOVUPSZ256mr(b?)(k?)(z?)", + "VMOVUPSZmr(b?)(k?)(z?)", + "VMOVUPSmr", + "VMPTRSTm")>; def SKXWriteResGroup12 : SchedWriteRes<[SKXPort0]> { let Latency = 2; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup12], (instregex "COMISDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "COMISSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MMX_MOVD64from64rr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MMX_MOVD64grr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MMX_PMOVMSKBrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MOVMSKPDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MOVMSKPSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MOVPDI2DIrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "MOVPQIto64rr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "PMOVMSKBrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "UCOMISDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "UCOMISSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VCOMISDZrr(b?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VCOMISDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VCOMISSZrr(b?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VCOMISSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVMSKPDYrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVMSKPDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVMSKPSYrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVMSKPSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVPDI2DIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVPDI2DIrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVPQIto64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VMOVPQIto64rr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VPMOVMSKBYrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VPMOVMSKBrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VTESTPDYrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VTESTPDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VTESTPSYrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VTESTPSrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VUCOMISDZrr(b?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VUCOMISDrr")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VUCOMISSZrr(b?)")>; -def: InstRW<[SKXWriteResGroup12], (instregex "VUCOMISSrr")>; +def: InstRW<[SKXWriteResGroup12], (instregex "COMISDrr", + "COMISSrr", + "MMX_MOVD64from64rr", + "MMX_MOVD64grr", + "MMX_PMOVMSKBrr", + "MOVMSKPDrr", + "MOVMSKPSrr", + "MOVPDI2DIrr", + "MOVPQIto64rr", + "PMOVMSKBrr", + "UCOMISDrr", + "UCOMISSrr", + "VCOMISDZrr(b?)", + "VCOMISDrr", + "VCOMISSZrr(b?)", + "VCOMISSrr", + "VMOVMSKPDYrr", + "VMOVMSKPDrr", + "VMOVMSKPSYrr", + "VMOVMSKPSrr", + "VMOVPDI2DIZrr(b?)(k?)(z?)", + "VMOVPDI2DIrr", + "VMOVPQIto64Zrr(b?)(k?)(z?)", + "VMOVPQIto64rr", + "VPMOVMSKBYrr", + "VPMOVMSKBrr", + "VTESTPDYrr", + "VTESTPDrr", + "VTESTPSYrr", + "VTESTPSrr", + "VUCOMISDZrr(b?)", + "VUCOMISDrr", + "VUCOMISSZrr(b?)", + "VUCOMISSrr")>; def SKXWriteResGroup13 : SchedWriteRes<[SKXPort5]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup13], (instregex "MMX_MOVQ2DQrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "MMX_PINSRWrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "PINSRBrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "PINSRDrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "PINSRQrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "PINSRWrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRBrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRDrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRQrr")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup13], (instregex "VPINSRWrr")>; +def: InstRW<[SKXWriteResGroup13], (instregex "MMX_MOVQ2DQrr", + "MMX_PINSRWrr", + "PINSRBrr", + "PINSRDrr", + "PINSRQrr", + "PINSRWrr", + "VPINSRBZrr(b?)(k?)(z?)", + "VPINSRBrr", + "VPINSRDZrr(b?)(k?)(z?)", + "VPINSRDrr", + "VPINSRQZrr(b?)(k?)(z?)", + "VPINSRQrr", + "VPINSRWZrr(b?)(k?)(z?)", + "VPINSRWrr")>; def SKXWriteResGroup14 : SchedWriteRes<[SKXPort05]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup14], (instregex "FDECSTP")>; -def: InstRW<[SKXWriteResGroup14], (instregex "MMX_MOVDQ2Qrr")>; +def: InstRW<[SKXWriteResGroup14], (instregex "FDECSTP", + "MMX_MOVDQ2Qrr")>; def SKXWriteResGroup15 : SchedWriteRes<[SKXPort06]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup15], (instregex "CMOV(A|BE)(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup15], (instregex "ROL(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup15], (instregex "ROL(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup15], (instregex "ROR(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup15], (instregex "ROR(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup15], (instregex "SET(A|BE)r")>; +def: InstRW<[SKXWriteResGroup15], (instregex "CMOV(A|BE)(16|32|64)rr", + "ROL(8|16|32|64)r1", + "ROL(8|16|32|64)ri", + "ROR(8|16|32|64)r1", + "ROR(8|16|32|64)ri", + "SET(A|BE)r")>; def SKXWriteResGroup16 : SchedWriteRes<[SKXPort015]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup16], (instregex "BLENDVPDrr0")>; -def: InstRW<[SKXWriteResGroup16], (instregex "BLENDVPSrr0")>; -def: InstRW<[SKXWriteResGroup16], (instregex "PBLENDVBrr0")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VBLENDVPDYrr")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VBLENDVPDrr")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VBLENDVPSYrr")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VBLENDVPSrr")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VPBLENDVBYrr")>; -def: InstRW<[SKXWriteResGroup16], (instregex "VPBLENDVBrr")>; +def: InstRW<[SKXWriteResGroup16], (instregex "BLENDVPDrr0", + "BLENDVPSrr0", + "PBLENDVBrr0", + "VBLENDVPDYrr", + "VBLENDVPDrr", + "VBLENDVPSYrr", + "VBLENDVPSrr", + "VPBLENDVBYrr", + "VPBLENDVBrr")>; def SKXWriteResGroup17 : SchedWriteRes<[SKXPort0156]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup17], (instregex "LFENCE")>; -def: InstRW<[SKXWriteResGroup17], (instregex "WAIT")>; -def: InstRW<[SKXWriteResGroup17], (instregex "XGETBV")>; +def: InstRW<[SKXWriteResGroup17], (instregex "LFENCE", + "WAIT", + "XGETBV")>; def SKXWriteResGroup18 : SchedWriteRes<[SKXPort0,SKXPort237]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup18], (instregex "VMASKMOVPDYmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VMASKMOVPDmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VMASKMOVPSYmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VMASKMOVPSmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VPMASKMOVDYmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VPMASKMOVDmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VPMASKMOVQYmr")>; -def: InstRW<[SKXWriteResGroup18], (instregex "VPMASKMOVQmr")>; +def: InstRW<[SKXWriteResGroup18], (instregex "VMASKMOVPDYmr", + "VMASKMOVPDmr", + "VMASKMOVPSYmr", + "VMASKMOVPSmr", + "VPMASKMOVDYmr", + "VPMASKMOVDmr", + "VPMASKMOVQYmr", + "VPMASKMOVQmr")>; def SKXWriteResGroup19 : SchedWriteRes<[SKXPort5,SKXPort01]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup19], (instregex "PSLLDrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSLLQrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSLLWrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSRADrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSRAWrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSRLDrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSRLQrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "PSRLWrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLDrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLQrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSLLWrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRADZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRADrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRAQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRAWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRAWrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRLDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRLDrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRLQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRLQrr")>; -def: InstRW<[SKXWriteResGroup19], (instregex "VPSRLWrr")>; +def: InstRW<[SKXWriteResGroup19], (instregex "PSLLDrr", + "PSLLQrr", + "PSLLWrr", + "PSRADrr", + "PSRAWrr", + "PSRLDrr", + "PSRLQrr", + "PSRLWrr", + "VPSLLDZ128rr(b?)(k?)(z?)", + "VPSLLDrr", + "VPSLLQZ128rr(b?)(k?)(z?)", + "VPSLLQrr", + "VPSLLWZ128rr(b?)(k?)(z?)", + "VPSLLWrr", + "VPSRADZ128rr(b?)(k?)(z?)", + "VPSRADrr", + "VPSRAQZ128rr(b?)(k?)(z?)", + "VPSRAWZ128rr(b?)(k?)(z?)", + "VPSRAWrr", + "VPSRLDZ128rr(b?)(k?)(z?)", + "VPSRLDrr", + "VPSRLQZ128rr(b?)(k?)(z?)", + "VPSRLQrr", + "VPSRLWrr")>; def SKXWriteResGroup20 : SchedWriteRes<[SKXPort6,SKXPort0156]> { let Latency = 2; @@ -1579,43 +1579,43 @@ def SKXWriteResGroup22 : SchedWriteRes<[SKXPort06,SKXPort15]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup22], (instregex "BEXTR(32|64)rr")>; -def: InstRW<[SKXWriteResGroup22], (instregex "BSWAP(16|32|64)r")>; +def: InstRW<[SKXWriteResGroup22], (instregex "BEXTR(32|64)rr", + "BSWAP(16|32|64)r")>; def SKXWriteResGroup23 : SchedWriteRes<[SKXPort06,SKXPort0156]> { let Latency = 2; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup23], (instregex "ADC8i8")>; -def: InstRW<[SKXWriteResGroup23], (instregex "ADC8ri")>; def: InstRW<[SKXWriteResGroup23], (instrs CWD)>; def: InstRW<[SKXWriteResGroup23], (instrs JCXZ, JECXZ, JRCXZ)>; -def: InstRW<[SKXWriteResGroup23], (instregex "SBB8i8")>; -def: InstRW<[SKXWriteResGroup23], (instregex "SBB8ri")>; +def: InstRW<[SKXWriteResGroup23], (instregex "ADC8i8", + "ADC8ri", + "SBB8i8", + "SBB8ri")>; def SKXWriteResGroup24 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237]> { let Latency = 2; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup24], (instregex "EXTRACTPSmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "PEXTRBmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "PEXTRDmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "PEXTRQmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "PEXTRWmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "STMXCSR")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VEXTRACTPSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VEXTRACTPSmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRBmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRDmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRQZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRQmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VPEXTRWmr")>; -def: InstRW<[SKXWriteResGroup24], (instregex "VSTMXCSR")>; +def: InstRW<[SKXWriteResGroup24], (instregex "EXTRACTPSmr", + "PEXTRBmr", + "PEXTRDmr", + "PEXTRQmr", + "PEXTRWmr", + "STMXCSR", + "VEXTRACTPSZmr(b?)(k?)(z?)", + "VEXTRACTPSmr", + "VPEXTRBZmr(b?)(k?)(z?)", + "VPEXTRBmr", + "VPEXTRDZmr(b?)(k?)(z?)", + "VPEXTRDmr", + "VPEXTRQZmr(b?)(k?)(z?)", + "VPEXTRQmr", + "VPEXTRWZmr(b?)(k?)(z?)", + "VPEXTRWmr", + "VSTMXCSR")>; def SKXWriteResGroup25 : SchedWriteRes<[SKXPort4,SKXPort6,SKXPort237]> { let Latency = 2; @@ -1644,12 +1644,12 @@ def SKXWriteResGroup28 : SchedWriteRes<[SKXPort4,SKXPort237,SKXPort0156]> { let ResourceCycles = [1,1,1]; } def: InstRW<[SKXWriteResGroup28], (instrs PUSH16r, PUSH32r, PUSH64r)>; -def: InstRW<[SKXWriteResGroup28], (instregex "PUSH(16|32|64)rmr")>; -def: InstRW<[SKXWriteResGroup28], (instregex "PUSH64i8")>; -def: InstRW<[SKXWriteResGroup28], (instregex "STOSB")>; -def: InstRW<[SKXWriteResGroup28], (instregex "STOSL")>; -def: InstRW<[SKXWriteResGroup28], (instregex "STOSQ")>; -def: InstRW<[SKXWriteResGroup28], (instregex "STOSW")>; +def: InstRW<[SKXWriteResGroup28], (instregex "PUSH(16|32|64)rmr", + "PUSH64i8", + "STOSB", + "STOSL", + "STOSQ", + "STOSW")>; def SKXWriteResGroup29 : SchedWriteRes<[SKXPort4,SKXPort237,SKXPort15]> { let Latency = 2; @@ -1663,40 +1663,39 @@ def SKXWriteResGroup30 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup30], (instregex "KADDBrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KADDDrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KADDQrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KADDWrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KMOVBrk")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KMOVDrk")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KMOVQrk")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KMOVWrk")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KORTESTBrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KORTESTDrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KORTESTQrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KORTESTWrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KTESTBrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KTESTDrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KTESTQrr")>; -def: InstRW<[SKXWriteResGroup30], (instregex "KTESTWrr")>; +def: InstRW<[SKXWriteResGroup30], (instregex "KADDBrr", + "KADDDrr", + "KADDQrr", + "KADDWrr", + "KMOVBrk", + "KMOVDrk", + "KMOVQrk", + "KMOVWrk", + "KORTESTBrr", + "KORTESTDrr", + "KORTESTQrr", + "KORTESTWrr", + "KTESTBrr", + "KTESTDrr", + "KTESTQrr", + "KTESTWrr")>; def SKXWriteResGroup31 : SchedWriteRes<[SKXPort1]> { let Latency = 3; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup31], (instregex "BSF(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup31], (instregex "BSR(16|32|64)rr")>; def: InstRW<[SKXWriteResGroup31], (instrs IMUL16rr, IMUL32rr, IMUL32rri, IMUL32rri8, IMUL64rr, IMUL64rri32, IMUL64rri8)>; -def: InstRW<[SKXWriteResGroup31], (instrs IMUL8r)>; -def: InstRW<[SKXWriteResGroup31], (instregex "LZCNT(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup31], (instrs MUL8r)>; -def: InstRW<[SKXWriteResGroup31], (instregex "PDEP(32|64)rr")>; -def: InstRW<[SKXWriteResGroup31], (instregex "PEXT(32|64)rr")>; -def: InstRW<[SKXWriteResGroup31], (instregex "POPCNT(16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup31], (instregex "SHLD(16|32|64)rri8")>; -def: InstRW<[SKXWriteResGroup31], (instregex "SHRD(16|32|64)rri8")>; -def: InstRW<[SKXWriteResGroup31], (instregex "TZCNT(16|32|64)rr")>; +def: InstRW<[SKXWriteResGroup31], (instrs IMUL8r, MUL8r)>; +def: InstRW<[SKXWriteResGroup31], (instregex "BSF(16|32|64)rr", + "BSR(16|32|64)rr", + "LZCNT(16|32|64)rr", + "PDEP(32|64)rr", + "PEXT(32|64)rr", + "POPCNT(16|32|64)rr", + "SHLD(16|32|64)rri8", + "SHRD(16|32|64)rri8", + "TZCNT(16|32|64)rr")>; def SKXWriteResGroup31_16i : SchedWriteRes<[SKXPort1, SKXPort0156]> { let Latency = 3; @@ -1711,334 +1710,334 @@ def SKXWriteResGroup32 : SchedWriteRes<[SKXPort5]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup32], (instregex "ADD_FPrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "ADD_FST0r")>; -def: InstRW<[SKXWriteResGroup32], (instregex "ADD_FrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTLBri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTLDri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTLQri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTLWri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTRBri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTRDri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTRQri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KSHIFTRWri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KUNPCKBWrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KUNPCKDQrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "KUNPCKWDrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "MMX_PSADBWirr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "PCMPGTQrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "PSADBWrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUBR_FPrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUBR_FST0r")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUBR_FrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUB_FPrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUB_FST0r")>; -def: InstRW<[SKXWriteResGroup32], (instregex "SUB_FrST0")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNQZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNQZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VALIGNQZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTF32X2Z256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTF32X2Zr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTI32X2Z256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTI32X2Zr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSDZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSSYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSSZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSSZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VBROADCASTSSZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPSDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VCMPSSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VDBPSADBWZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VDBPSADBWZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VDBPSADBWZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF32x4Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF32x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF32x8Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF64x2Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF64x2Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTF64x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI32x4Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI32x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI32x8Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI64x2Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI64x2Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VEXTRACTI64x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSSDrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VFPCLASSSSrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF32x4Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF32x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF32x8Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF64x2Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF64x2Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTF64x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI32x4Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI32x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI32x8Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI64x2Z256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI64x2Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VINSERTI64x4Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTBYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTBZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTBZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTBZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTBrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDrZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDrZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTDrZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQrZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQrZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTQrZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTWYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTWZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTWZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTWZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPBROADCASTWrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPBZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPBZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPBZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPEQWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTQrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPGTWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPQZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPQZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPQZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUBZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUBZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUBZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUQZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUQZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUQZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUWZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUWZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPUWZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPWZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPWZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPCMPWZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERM2F128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERM2I128rr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2D128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2D256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2Drr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PD128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PD256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PDrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PS128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PS256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2PSrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2Q128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2Q256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMI2Qrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPDYri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPDZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPDZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPSYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMQYri")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMQZ256r(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMQZri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2D128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2D256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2Drr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PD128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PD256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PDrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PS128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PS256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2PSrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2Q128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2Q256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPERMT2Qrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXSQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXSQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXSQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXUQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXUQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMAXUQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINSQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINSQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINSQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINUQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINUQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMINUQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVQDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVQDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVQDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBWYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXDQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVSXWQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBWYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXDQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWDYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWQYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPMOVZXWQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPSADBWYrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPSADBWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPSADBWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPSADBWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPSADBWrr")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTMWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VPTESTNMWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFF32X4Z256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFF32X4Zrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFF64X2Z256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFF64X2Zrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFI32X4Z256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFI32X4Zrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFI64X2Z256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup32], (instregex "VSHUFI64X2Zrri(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup32], (instregex "ADD_FPrST0", + "ADD_FST0r", + "ADD_FrST0", + "KSHIFTLBri", + "KSHIFTLDri", + "KSHIFTLQri", + "KSHIFTLWri", + "KSHIFTRBri", + "KSHIFTRDri", + "KSHIFTRQri", + "KSHIFTRWri", + "KUNPCKBWrr", + "KUNPCKDQrr", + "KUNPCKWDrr", + "MMX_PSADBWirr", + "PCMPGTQrr", + "PSADBWrr", + "SUBR_FPrST0", + "SUBR_FST0r", + "SUBR_FrST0", + "SUB_FPrST0", + "SUB_FST0r", + "SUB_FrST0", + "VALIGNDZ128rri(b?)(k?)(z?)", + "VALIGNDZ256rri(b?)(k?)(z?)", + "VALIGNDZrri(b?)(k?)(z?)", + "VALIGNQZ128rri(b?)(k?)(z?)", + "VALIGNQZ256rri(b?)(k?)(z?)", + "VALIGNQZrri(b?)(k?)(z?)", + "VBROADCASTF32X2Z256r(b?)(k?)(z?)", + "VBROADCASTF32X2Zr(b?)(k?)(z?)", + "VBROADCASTI32X2Z256r(b?)(k?)(z?)", + "VBROADCASTI32X2Zr(b?)(k?)(z?)", + "VBROADCASTSDYrr", + "VBROADCASTSDZ256r(b?)(k?)(z?)", + "VBROADCASTSDZr(b?)(k?)(z?)", + "VBROADCASTSSYrr", + "VBROADCASTSSZ128r(b?)(k?)(z?)", + "VBROADCASTSSZ256r(b?)(k?)(z?)", + "VBROADCASTSSZr(b?)(k?)(z?)", + "VCMPPDZ128rri(b?)(k?)(z?)", + "VCMPPDZ256rri(b?)(k?)(z?)", + "VCMPPDZrri(b?)(k?)(z?)", + "VCMPPSZ128rri(b?)(k?)(z?)", + "VCMPPSZ256rri(b?)(k?)(z?)", + "VCMPPSZrri(b?)(k?)(z?)", + "VCMPSDZrr(b?)(_Int)?(k?)(z?)", + "VCMPSSZrr(b?)(_Int)?(k?)(z?)", + "VDBPSADBWZ128rri(b?)(k?)(z?)", + "VDBPSADBWZ256rri(b?)(k?)(z?)", + "VDBPSADBWZrri(b?)(k?)(z?)", + "VEXTRACTF128rr", + "VEXTRACTF32x4Z256rr(b?)(k?)(z?)", + "VEXTRACTF32x4Zrr(b?)(k?)(z?)", + "VEXTRACTF32x8Zrr(b?)(k?)(z?)", + "VEXTRACTF64x2Z256rr(b?)(k?)(z?)", + "VEXTRACTF64x2Zrr(b?)(k?)(z?)", + "VEXTRACTF64x4Zrr(b?)(k?)(z?)", + "VEXTRACTI128rr", + "VEXTRACTI32x4Z256rr(b?)(k?)(z?)", + "VEXTRACTI32x4Zrr(b?)(k?)(z?)", + "VEXTRACTI32x8Zrr(b?)(k?)(z?)", + "VEXTRACTI64x2Z256rr(b?)(k?)(z?)", + "VEXTRACTI64x2Zrr(b?)(k?)(z?)", + "VEXTRACTI64x4Zrr(b?)(k?)(z?)", + "VFPCLASSPDZ128rr(b?)(k?)(z?)", + "VFPCLASSPDZ256rr(b?)(k?)(z?)", + "VFPCLASSPDZrr(b?)(k?)(z?)", + "VFPCLASSPSZ128rr(b?)(k?)(z?)", + "VFPCLASSPSZ256rr(b?)(k?)(z?)", + "VFPCLASSPSZrr(b?)(k?)(z?)", + "VFPCLASSSDrr(b?)(k?)(z?)", + "VFPCLASSSSrr(b?)(k?)(z?)", + "VINSERTF128rr", + "VINSERTF32x4Z256rr(b?)(k?)(z?)", + "VINSERTF32x4Zrr(b?)(k?)(z?)", + "VINSERTF32x8Zrr(b?)(k?)(z?)", + "VINSERTF64x2Z256rr(b?)(k?)(z?)", + "VINSERTF64x2Zrr(b?)(k?)(z?)", + "VINSERTF64x4Zrr(b?)(k?)(z?)", + "VINSERTI128rr", + "VINSERTI32x4Z256rr(b?)(k?)(z?)", + "VINSERTI32x4Zrr(b?)(k?)(z?)", + "VINSERTI32x8Zrr(b?)(k?)(z?)", + "VINSERTI64x2Z256rr(b?)(k?)(z?)", + "VINSERTI64x2Zrr(b?)(k?)(z?)", + "VINSERTI64x4Zrr(b?)(k?)(z?)", + "VPBROADCASTBYrr", + "VPBROADCASTBZ128r(b?)(k?)(z?)", + "VPBROADCASTBZ256r(b?)(k?)(z?)", + "VPBROADCASTBZr(b?)(k?)(z?)", + "VPBROADCASTBrr", + "VPBROADCASTDYrr", + "VPBROADCASTDZ128r(b?)(k?)(z?)", + "VPBROADCASTDZ256r(b?)(k?)(z?)", + "VPBROADCASTDZr(b?)(k?)(z?)", + "VPBROADCASTDrZ128r(b?)(k?)(z?)", + "VPBROADCASTDrZ256r(b?)(k?)(z?)", + "VPBROADCASTDrZr(b?)(k?)(z?)", + "VPBROADCASTQYrr", + "VPBROADCASTQZ128r(b?)(k?)(z?)", + "VPBROADCASTQZ256r(b?)(k?)(z?)", + "VPBROADCASTQZr(b?)(k?)(z?)", + "VPBROADCASTQrZ128r(b?)(k?)(z?)", + "VPBROADCASTQrZ256r(b?)(k?)(z?)", + "VPBROADCASTQrZr(b?)(k?)(z?)", + "VPBROADCASTWYrr", + "VPBROADCASTWZ128r(b?)(k?)(z?)", + "VPBROADCASTWZ256r(b?)(k?)(z?)", + "VPBROADCASTWZr(b?)(k?)(z?)", + "VPBROADCASTWrr", + "VPCMPBZ128rri(b?)(k?)(z?)", + "VPCMPBZ256rri(b?)(k?)(z?)", + "VPCMPBZrri(b?)(k?)(z?)", + "VPCMPDZ128rri(b?)(k?)(z?)", + "VPCMPDZ256rri(b?)(k?)(z?)", + "VPCMPDZrri(b?)(k?)(z?)", + "VPCMPEQBZ128rr(b?)(k?)(z?)", + "VPCMPEQBZ256rr(b?)(k?)(z?)", + "VPCMPEQBZrr(b?)(k?)(z?)", + "VPCMPEQDZ128rr(b?)(k?)(z?)", + "VPCMPEQDZ256rr(b?)(k?)(z?)", + "VPCMPEQDZrr(b?)(k?)(z?)", + "VPCMPEQQZ128rr(b?)(k?)(z?)", + "VPCMPEQQZ256rr(b?)(k?)(z?)", + "VPCMPEQQZrr(b?)(k?)(z?)", + "VPCMPEQWZ128rr(b?)(k?)(z?)", + "VPCMPEQWZ256rr(b?)(k?)(z?)", + "VPCMPEQWZrr(b?)(k?)(z?)", + "VPCMPGTBZ128rr(b?)(k?)(z?)", + "VPCMPGTBZ256rr(b?)(k?)(z?)", + "VPCMPGTBZrr(b?)(k?)(z?)", + "VPCMPGTDZ128rr(b?)(k?)(z?)", + "VPCMPGTDZ256rr(b?)(k?)(z?)", + "VPCMPGTDZrr(b?)(k?)(z?)", + "VPCMPGTQYrr", + "VPCMPGTQZ128rr(b?)(k?)(z?)", + "VPCMPGTQZ256rr(b?)(k?)(z?)", + "VPCMPGTQZrr(b?)(k?)(z?)", + "VPCMPGTQrr", + "VPCMPGTWZ128rr(b?)(k?)(z?)", + "VPCMPGTWZ256rr(b?)(k?)(z?)", + "VPCMPGTWZrr(b?)(k?)(z?)", + "VPCMPQZ128rri(b?)(k?)(z?)", + "VPCMPQZ256rri(b?)(k?)(z?)", + "VPCMPQZrri(b?)(k?)(z?)", + "VPCMPUBZ128rri(b?)(k?)(z?)", + "VPCMPUBZ256rri(b?)(k?)(z?)", + "VPCMPUBZrri(b?)(k?)(z?)", + "VPCMPUDZ128rri(b?)(k?)(z?)", + "VPCMPUDZ256rri(b?)(k?)(z?)", + "VPCMPUDZrri(b?)(k?)(z?)", + "VPCMPUQZ128rri(b?)(k?)(z?)", + "VPCMPUQZ256rri(b?)(k?)(z?)", + "VPCMPUQZrri(b?)(k?)(z?)", + "VPCMPUWZ128rri(b?)(k?)(z?)", + "VPCMPUWZ256rri(b?)(k?)(z?)", + "VPCMPUWZrri(b?)(k?)(z?)", + "VPCMPWZ128rri(b?)(k?)(z?)", + "VPCMPWZ256rri(b?)(k?)(z?)", + "VPCMPWZrri(b?)(k?)(z?)", + "VPERM2F128rr", + "VPERM2I128rr", + "VPERMDYrr", + "VPERMDZ256rr(b?)(k?)(z?)", + "VPERMDZrr(b?)(k?)(z?)", + "VPERMI2D128rr(b?)(k?)(z?)", + "VPERMI2D256rr(b?)(k?)(z?)", + "VPERMI2Drr(b?)(k?)(z?)", + "VPERMI2PD128rr(b?)(k?)(z?)", + "VPERMI2PD256rr(b?)(k?)(z?)", + "VPERMI2PDrr(b?)(k?)(z?)", + "VPERMI2PS128rr(b?)(k?)(z?)", + "VPERMI2PS256rr(b?)(k?)(z?)", + "VPERMI2PSrr(b?)(k?)(z?)", + "VPERMI2Q128rr(b?)(k?)(z?)", + "VPERMI2Q256rr(b?)(k?)(z?)", + "VPERMI2Qrr(b?)(k?)(z?)", + "VPERMPDYri", + "VPERMPDZ256r(b?)i(k?)(z?)", + "VPERMPDZ256rr(b?)(k?)(z?)", + "VPERMPDZri(b?)(k?)(z?)", + "VPERMPDZrr(b?)(k?)(z?)", + "VPERMPSYrr", + "VPERMPSZ256rr(b?)(k?)(z?)", + "VPERMPSZrr(b?)(k?)(z?)", + "VPERMQYri", + "VPERMQZ256r(b?)i(k?)(z?)", + "VPERMQZ256rr(b?)(k?)(z?)", + "VPERMQZri(b?)(k?)(z?)", + "VPERMQZrr(b?)(k?)(z?)", + "VPERMT2D128rr(b?)(k?)(z?)", + "VPERMT2D256rr(b?)(k?)(z?)", + "VPERMT2Drr(b?)(k?)(z?)", + "VPERMT2PD128rr(b?)(k?)(z?)", + "VPERMT2PD256rr(b?)(k?)(z?)", + "VPERMT2PDrr(b?)(k?)(z?)", + "VPERMT2PS128rr(b?)(k?)(z?)", + "VPERMT2PS256rr(b?)(k?)(z?)", + "VPERMT2PSrr(b?)(k?)(z?)", + "VPERMT2Q128rr(b?)(k?)(z?)", + "VPERMT2Q256rr(b?)(k?)(z?)", + "VPERMT2Qrr(b?)(k?)(z?)", + "VPMAXSQZ128rr(b?)(k?)(z?)", + "VPMAXSQZ256rr(b?)(k?)(z?)", + "VPMAXSQZrr(b?)(k?)(z?)", + "VPMAXUQZ128rr(b?)(k?)(z?)", + "VPMAXUQZ256rr(b?)(k?)(z?)", + "VPMAXUQZrr(b?)(k?)(z?)", + "VPMINSQZ128rr(b?)(k?)(z?)", + "VPMINSQZ256rr(b?)(k?)(z?)", + "VPMINSQZrr(b?)(k?)(z?)", + "VPMINUQZ128rr(b?)(k?)(z?)", + "VPMINUQZ256rr(b?)(k?)(z?)", + "VPMINUQZrr(b?)(k?)(z?)", + "VPMOVQDZ128rr(b?)(k?)(z?)", + "VPMOVQDZ256rr(b?)(k?)(z?)", + "VPMOVQDZrr(b?)(k?)(z?)", + "VPMOVSXBDYrr", + "VPMOVSXBDZ128rr(b?)(k?)(z?)", + "VPMOVSXBDZ256rr(b?)(k?)(z?)", + "VPMOVSXBDZrr(b?)(k?)(z?)", + "VPMOVSXBQYrr", + "VPMOVSXBQZ128rr(b?)(k?)(z?)", + "VPMOVSXBQZ256rr(b?)(k?)(z?)", + "VPMOVSXBQZrr(b?)(k?)(z?)", + "VPMOVSXBWYrr", + "VPMOVSXBWZ128rr(b?)(k?)(z?)", + "VPMOVSXBWZ256rr(b?)(k?)(z?)", + "VPMOVSXBWZrr(b?)(k?)(z?)", + "VPMOVSXDQYrr", + "VPMOVSXDQZ128rr(b?)(k?)(z?)", + "VPMOVSXDQZ256rr(b?)(k?)(z?)", + "VPMOVSXDQZrr(b?)(k?)(z?)", + "VPMOVSXWDYrr", + "VPMOVSXWDZ128rr(b?)(k?)(z?)", + "VPMOVSXWDZ256rr(b?)(k?)(z?)", + "VPMOVSXWDZrr(b?)(k?)(z?)", + "VPMOVSXWQYrr", + "VPMOVSXWQZ128rr(b?)(k?)(z?)", + "VPMOVSXWQZ256rr(b?)(k?)(z?)", + "VPMOVSXWQZrr(b?)(k?)(z?)", + "VPMOVZXBDYrr", + "VPMOVZXBDZ128rr(b?)(k?)(z?)", + "VPMOVZXBDZ256rr(b?)(k?)(z?)", + "VPMOVZXBDZrr(b?)(k?)(z?)", + "VPMOVZXBQYrr", + "VPMOVZXBQZ128rr(b?)(k?)(z?)", + "VPMOVZXBQZ256rr(b?)(k?)(z?)", + "VPMOVZXBQZrr(b?)(k?)(z?)", + "VPMOVZXBWYrr", + "VPMOVZXBWZ128rr(b?)(k?)(z?)", + "VPMOVZXBWZ256rr(b?)(k?)(z?)", + "VPMOVZXBWZrr(b?)(k?)(z?)", + "VPMOVZXDQYrr", + "VPMOVZXDQZ128rr(b?)(k?)(z?)", + "VPMOVZXDQZ256rr(b?)(k?)(z?)", + "VPMOVZXDQZrr(b?)(k?)(z?)", + "VPMOVZXWDYrr", + "VPMOVZXWDZ128rr(b?)(k?)(z?)", + "VPMOVZXWDZ256rr(b?)(k?)(z?)", + "VPMOVZXWDZrr(b?)(k?)(z?)", + "VPMOVZXWQYrr", + "VPMOVZXWQZ128rr(b?)(k?)(z?)", + "VPMOVZXWQZ256rr(b?)(k?)(z?)", + "VPMOVZXWQZrr(b?)(k?)(z?)", + "VPSADBWYrr", + "VPSADBWZ128rr(b?)(k?)(z?)", + "VPSADBWZ256rr(b?)(k?)(z?)", + "VPSADBWZrr(b?)(k?)(z?)", + "VPSADBWrr", + "VPTESTMBZ128rr(b?)(k?)(z?)", + "VPTESTMBZ256rr(b?)(k?)(z?)", + "VPTESTMBZrr(b?)(k?)(z?)", + "VPTESTMDZ128rr(b?)(k?)(z?)", + "VPTESTMDZ256rr(b?)(k?)(z?)", + "VPTESTMDZrr(b?)(k?)(z?)", + "VPTESTMQZ128rr(b?)(k?)(z?)", + "VPTESTMQZ256rr(b?)(k?)(z?)", + "VPTESTMQZrr(b?)(k?)(z?)", + "VPTESTMWZ128rr(b?)(k?)(z?)", + "VPTESTMWZ256rr(b?)(k?)(z?)", + "VPTESTMWZrr(b?)(k?)(z?)", + "VPTESTNMBZ128rr(b?)(k?)(z?)", + "VPTESTNMBZ256rr(b?)(k?)(z?)", + "VPTESTNMBZrr(b?)(k?)(z?)", + "VPTESTNMDZ128rr(b?)(k?)(z?)", + "VPTESTNMDZ256rr(b?)(k?)(z?)", + "VPTESTNMDZrr(b?)(k?)(z?)", + "VPTESTNMQZ128rr(b?)(k?)(z?)", + "VPTESTNMQZ256rr(b?)(k?)(z?)", + "VPTESTNMQZrr(b?)(k?)(z?)", + "VPTESTNMWZ128rr(b?)(k?)(z?)", + "VPTESTNMWZ256rr(b?)(k?)(z?)", + "VPTESTNMWZrr(b?)(k?)(z?)", + "VSHUFF32X4Z256rri(b?)(k?)(z?)", + "VSHUFF32X4Zrri(b?)(k?)(z?)", + "VSHUFF64X2Z256rri(b?)(k?)(z?)", + "VSHUFF64X2Zrri(b?)(k?)(z?)", + "VSHUFI32X4Z256rri(b?)(k?)(z?)", + "VSHUFI32X4Zrri(b?)(k?)(z?)", + "VSHUFI64X2Z256rri(b?)(k?)(z?)", + "VSHUFI64X2Zrri(b?)(k?)(z?)")>; def SKXWriteResGroup33 : SchedWriteRes<[SKXPort0,SKXPort5]> { let Latency = 3; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup33], (instregex "EXTRACTPSrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "MMX_PEXTRWrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "PEXTRBrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "PEXTRDrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "PEXTRQrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "PEXTRWrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "PTESTrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VEXTRACTPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VEXTRACTPSrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRBrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRDrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRQrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRWZrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPEXTRWrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPTESTYrr")>; -def: InstRW<[SKXWriteResGroup33], (instregex "VPTESTrr")>; +def: InstRW<[SKXWriteResGroup33], (instregex "EXTRACTPSrr", + "MMX_PEXTRWrr", + "PEXTRBrr", + "PEXTRDrr", + "PEXTRQrr", + "PEXTRWrr", + "PTESTrr", + "VEXTRACTPSZrr(b?)(k?)(z?)", + "VEXTRACTPSrr", + "VPEXTRBZrr(b?)(k?)(z?)", + "VPEXTRBrr", + "VPEXTRDZrr(b?)(k?)(z?)", + "VPEXTRDrr", + "VPEXTRQZrr(b?)(k?)(z?)", + "VPEXTRQrr", + "VPEXTRWZrr", + "VPEXTRWrr", + "VPTESTYrr", + "VPTESTrr")>; def SKXWriteResGroup34 : SchedWriteRes<[SKXPort0,SKXPort0156]> { let Latency = 3; @@ -2052,76 +2051,76 @@ def SKXWriteResGroup35 : SchedWriteRes<[SKXPort06]> { let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKXWriteResGroup35], (instregex "ROL(8|16|32|64)rCL")>; -def: InstRW<[SKXWriteResGroup35], (instregex "ROR(8|16|32|64)rCL")>; -def: InstRW<[SKXWriteResGroup35], (instregex "SAR(8|16|32|64)rCL")>; -def: InstRW<[SKXWriteResGroup35], (instregex "SHL(8|16|32|64)rCL")>; -def: InstRW<[SKXWriteResGroup35], (instregex "SHR(8|16|32|64)rCL")>; +def: InstRW<[SKXWriteResGroup35], (instregex "ROL(8|16|32|64)rCL", + "ROR(8|16|32|64)rCL", + "SAR(8|16|32|64)rCL", + "SHL(8|16|32|64)rCL", + "SHR(8|16|32|64)rCL")>; def SKXWriteResGroup36 : SchedWriteRes<[SKXPort0156]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKXWriteResGroup36], (instregex "XADD(8|16|32|64)rr")>; -def: InstRW<[SKXWriteResGroup36], (instregex "XCHG8rr")>; +def: InstRW<[SKXWriteResGroup36], (instregex "XADD(8|16|32|64)rr", + "XCHG8rr")>; def SKXWriteResGroup37 : SchedWriteRes<[SKXPort0,SKXPort5]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup37], (instregex "MMX_PHADDSWrr")>; -def: InstRW<[SKXWriteResGroup37], (instregex "MMX_PHSUBSWrr")>; +def: InstRW<[SKXWriteResGroup37], (instregex "MMX_PHADDSWrr", + "MMX_PHSUBSWrr")>; def SKXWriteResGroup38 : SchedWriteRes<[SKXPort5,SKXPort01]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup38], (instregex "PHADDSWrr")>; -def: InstRW<[SKXWriteResGroup38], (instregex "PHSUBSWrr")>; -def: InstRW<[SKXWriteResGroup38], (instregex "VPHADDSWrr")>; -def: InstRW<[SKXWriteResGroup38], (instregex "VPHADDSWYrr")>; -def: InstRW<[SKXWriteResGroup38], (instregex "VPHSUBSWrr")>; -def: InstRW<[SKXWriteResGroup38], (instregex "VPHSUBSWYrr")>; +def: InstRW<[SKXWriteResGroup38], (instregex "PHADDSWrr", + "PHSUBSWrr", + "VPHADDSWrr", + "VPHADDSWYrr", + "VPHSUBSWrr", + "VPHSUBSWYrr")>; def SKXWriteResGroup39 : SchedWriteRes<[SKXPort5,SKXPort05]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup39], (instregex "MMX_PHADDDrr")>; -def: InstRW<[SKXWriteResGroup39], (instregex "MMX_PHADDWrr")>; -def: InstRW<[SKXWriteResGroup39], (instregex "MMX_PHSUBDrr")>; -def: InstRW<[SKXWriteResGroup39], (instregex "MMX_PHSUBWrr")>; +def: InstRW<[SKXWriteResGroup39], (instregex "MMX_PHADDDrr", + "MMX_PHADDWrr", + "MMX_PHSUBDrr", + "MMX_PHSUBWrr")>; def SKXWriteResGroup40 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup40], (instregex "PHADDDrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "PHADDWrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "PHSUBDrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "PHSUBWrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHADDDYrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHADDDrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHADDWYrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHADDWrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHSUBDYrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHSUBDrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHSUBWYrr")>; -def: InstRW<[SKXWriteResGroup40], (instregex "VPHSUBWrr")>; +def: InstRW<[SKXWriteResGroup40], (instregex "PHADDDrr", + "PHADDWrr", + "PHSUBDrr", + "PHSUBWrr", + "VPHADDDYrr", + "VPHADDDrr", + "VPHADDWYrr", + "VPHADDWrr", + "VPHSUBDYrr", + "VPHSUBDrr", + "VPHSUBWYrr", + "VPHSUBWrr")>; def SKXWriteResGroup41 : SchedWriteRes<[SKXPort5,SKXPort0156]> { let Latency = 3; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup41], (instregex "MMX_PACKSSDWirr")>; -def: InstRW<[SKXWriteResGroup41], (instregex "MMX_PACKSSWBirr")>; -def: InstRW<[SKXWriteResGroup41], (instregex "MMX_PACKUSWBirr")>; +def: InstRW<[SKXWriteResGroup41], (instregex "MMX_PACKSSDWirr", + "MMX_PACKSSWBirr", + "MMX_PACKUSWBirr")>; def SKXWriteResGroup42 : SchedWriteRes<[SKXPort6,SKXPort0156]> { let Latency = 3; @@ -2142,10 +2141,10 @@ def SKXWriteResGroup44 : SchedWriteRes<[SKXPort06,SKXPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup44], (instregex "RCL(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup44], (instregex "RCL(8|16|32|64)ri")>; -def: InstRW<[SKXWriteResGroup44], (instregex "RCR(8|16|32|64)r1")>; -def: InstRW<[SKXWriteResGroup44], (instregex "RCR(8|16|32|64)ri")>; +def: InstRW<[SKXWriteResGroup44], (instregex "RCL(8|16|32|64)r1", + "RCL(8|16|32|64)ri", + "RCR(8|16|32|64)r1", + "RCR(8|16|32|64)ri")>; def SKXWriteResGroup45 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort237]> { let Latency = 3; @@ -2180,164 +2179,307 @@ def SKXWriteResGroup49 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup49], (instregex "AESDECLASTrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "AESDECrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "AESENCLASTrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "AESENCrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMADDUBSWrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMADDWDirr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMULHRSWrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMULHUWirr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMULHWirr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMULLWirr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MMX_PMULUDQirr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MUL_FPrST0")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MUL_FST0r")>; -def: InstRW<[SKXWriteResGroup49], (instregex "MUL_FrST0")>; -def: InstRW<[SKXWriteResGroup49], (instregex "RCPPSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "RCPSSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "RSQRTPSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "RSQRTSSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VAESDECLASTrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VAESDECrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VAESENCLASTrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VAESENCrr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14PDZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14PDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14PSZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14PSZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14SDrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCP14SSrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCPPSYr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCPPSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRCPSSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14PDZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14PDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14PSZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14PSZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14SDrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRT14SSrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRTPSYr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRTPSr")>; -def: InstRW<[SKXWriteResGroup49], (instregex "VRSQRTSSr")>; +def: InstRW<[SKXWriteResGroup49], (instregex "AESDECLASTrr", + "AESDECrr", + "AESENCLASTrr", + "AESENCrr", + "MMX_PMADDUBSWrr", + "MMX_PMADDWDirr", + "MMX_PMULHRSWrr", + "MMX_PMULHUWirr", + "MMX_PMULHWirr", + "MMX_PMULLWirr", + "MMX_PMULUDQirr", + "MUL_FPrST0", + "MUL_FST0r", + "MUL_FrST0", + "RCPPSr", + "RCPSSr", + "RSQRTPSr", + "RSQRTSSr", + "VAESDECLASTrr", + "VAESDECrr", + "VAESENCLASTrr", + "VAESENCrr", + "VRCP14PDZ128r(b?)(k?)(z?)", + "VRCP14PDZ256r(b?)(k?)(z?)", + "VRCP14PSZ128r(b?)(k?)(z?)", + "VRCP14PSZ256r(b?)(k?)(z?)", + "VRCP14SDrr(b?)(k?)(z?)", + "VRCP14SSrr(b?)(k?)(z?)", + "VRCPPSYr", + "VRCPPSr", + "VRCPSSr", + "VRSQRT14PDZ128r(b?)(k?)(z?)", + "VRSQRT14PDZ256r(b?)(k?)(z?)", + "VRSQRT14PSZ128r(b?)(k?)(z?)", + "VRSQRT14PSZ256r(b?)(k?)(z?)", + "VRSQRT14SDrr(b?)(k?)(z?)", + "VRSQRT14SSrr(b?)(k?)(z?)", + "VRSQRTPSYr", + "VRSQRTPSr", + "VRSQRTSSr")>; def SKXWriteResGroup50 : SchedWriteRes<[SKXPort015]> { let Latency = 4; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup50], (instregex "ADDPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "ADDPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "ADDSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "ADDSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "ADDSUBPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "ADDSUBPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CMPPDrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CMPPSrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CMPSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CMPSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CVTDQ2PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CVTPS2DQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "CVTTPS2DQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MAX(C?)PDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MAX(C?)PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MAX(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MAX(C?)SSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MIN(C?)PDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MIN(C?)PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MIN(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MIN(C?)SSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MULPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MULPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MULSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "MULSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PHMINPOSUWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMADDUBSWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMADDWDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULDQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULHRSWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULHUWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULHWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULLWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "PMULUDQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "SUBPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "SUBPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "SUBSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "SUBSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSUBPDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSUBPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSUBPSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VADDSUBPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPPDYrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPPDrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPPSYrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPPSrri")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCMPSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTDQ2PSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTDQ2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTDQ2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTDQ2PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTDQ2PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2QQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2QQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2QQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2UQQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2UQQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPD2UQQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2DQYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2DQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2DQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2DQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2DQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2UDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2UDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTPS2UDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTQQ2PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTQQ2PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTQQ2PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2QQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2QQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2QQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2UQQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2UQQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPD2UQQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2DQYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2DQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2DQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2DQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2DQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2UDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2UDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTTPS2UDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUDQ2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUDQ2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUDQ2PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUQQ2PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUQQ2PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VCVTUQQ2PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMSDrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VFIXUPIMMSSrri(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup50], (instregex "ADDPDrr", + "ADDPSrr", + "ADDSDrr", + "ADDSSrr", + "ADDSUBPDrr", + "ADDSUBPSrr", + "CMPPDrri", + "CMPPSrri", + "CMPSDrr", + "CMPSSrr", + "CVTDQ2PSrr", + "CVTPS2DQrr", + "CVTTPS2DQrr", + "MAX(C?)PDrr", + "MAX(C?)PSrr", + "MAX(C?)SDrr", + "MAX(C?)SSrr", + "MIN(C?)PDrr", + "MIN(C?)PSrr", + "MIN(C?)SDrr", + "MIN(C?)SSrr", + "MULPDrr", + "MULPSrr", + "MULSDrr", + "MULSSrr", + "PHMINPOSUWrr", + "PMADDUBSWrr", + "PMADDWDrr", + "PMULDQrr", + "PMULHRSWrr", + "PMULHUWrr", + "PMULHWrr", + "PMULLWrr", + "PMULUDQrr", + "SUBPDrr", + "SUBPSrr", + "SUBSDrr", + "SUBSSrr", + "VADDPDYrr", + "VADDPDZ128rr(b?)(k?)(z?)", + "VADDPDZ256rr(b?)(k?)(z?)", + "VADDPDZrr(b?)(k?)(z?)", + "VADDPDrr", + "VADDPSYrr", + "VADDPSZ128rr(b?)(k?)(z?)", + "VADDPSZ256rr(b?)(k?)(z?)", + "VADDPSZrr(b?)(k?)(z?)", + "VADDPSrr", + "VADDSDZrr(b?)(_Int)?(k?)(z?)", + "VADDSDrr", + "VADDSSZrr(b?)(_Int)?(k?)(z?)", + "VADDSSrr", + "VADDSUBPDYrr", + "VADDSUBPDrr", + "VADDSUBPSYrr", + "VADDSUBPSrr", + "VCMPPDYrri", + "VCMPPDrri", + "VCMPPSYrri", + "VCMPPSrri", + "VCMPSDrr", + "VCMPSSrr", + "VCVTDQ2PSYrr", + "VCVTDQ2PSZ128rr(b?)(k?)(z?)", + "VCVTDQ2PSZ256rr(b?)(k?)(z?)", + "VCVTDQ2PSZrr(b?)(k?)(z?)", + "VCVTDQ2PSrr", + "VCVTPD2QQZ128rr(b?)(k?)(z?)", + "VCVTPD2QQZ256rr(b?)(k?)(z?)", + "VCVTPD2QQZrr(b?)(k?)(z?)", + "VCVTPD2UQQZ128rr(b?)(k?)(z?)", + "VCVTPD2UQQZ256rr(b?)(k?)(z?)", + "VCVTPD2UQQZrr(b?)(k?)(z?)", + "VCVTPS2DQYrr", + "VCVTPS2DQZ128rr(b?)(k?)(z?)", + "VCVTPS2DQZ256rr(b?)(k?)(z?)", + "VCVTPS2DQZrr(b?)(k?)(z?)", + "VCVTPS2DQrr", + "VCVTPS2UDQZ128rr(b?)(k?)(z?)", + "VCVTPS2UDQZ256rr(b?)(k?)(z?)", + "VCVTPS2UDQZrr(b?)(k?)(z?)", + "VCVTQQ2PDZ128rr(b?)(k?)(z?)", + "VCVTQQ2PDZ256rr(b?)(k?)(z?)", + "VCVTQQ2PDZrr(b?)(k?)(z?)", + "VCVTTPD2QQZ128rr(b?)(k?)(z?)", + "VCVTTPD2QQZ256rr(b?)(k?)(z?)", + "VCVTTPD2QQZrr(b?)(k?)(z?)", + "VCVTTPD2UQQZ128rr(b?)(k?)(z?)", + "VCVTTPD2UQQZ256rr(b?)(k?)(z?)", + "VCVTTPD2UQQZrr(b?)(k?)(z?)", + "VCVTTPS2DQYrr", + "VCVTTPS2DQZ128rr(b?)(k?)(z?)", + "VCVTTPS2DQZ256rr(b?)(k?)(z?)", + "VCVTTPS2DQZrr(b?)(k?)(z?)", + "VCVTTPS2DQrr", + "VCVTTPS2UDQZ128rr(b?)(k?)(z?)", + "VCVTTPS2UDQZ256rr(b?)(k?)(z?)", + "VCVTTPS2UDQZrr(b?)(k?)(z?)", + "VCVTUDQ2PSZ128rr(b?)(k?)(z?)", + "VCVTUDQ2PSZ256rr(b?)(k?)(z?)", + "VCVTUDQ2PSZrr(b?)(k?)(z?)", + "VCVTUQQ2PDZ128rr(b?)(k?)(z?)", + "VCVTUQQ2PDZ256rr(b?)(k?)(z?)", + "VCVTUQQ2PDZrr(b?)(k?)(z?)", + "VFIXUPIMMPDZ128rri(b?)(k?)(z?)", + "VFIXUPIMMPDZ256rri(b?)(k?)(z?)", + "VFIXUPIMMPDZrri(b?)(k?)(z?)", + "VFIXUPIMMPSZ128rri(b?)(k?)(z?)", + "VFIXUPIMMPSZ256rri(b?)(k?)(z?)", + "VFIXUPIMMPSZrri(b?)(k?)(z?)", + "VFIXUPIMMSDrri(b?)(k?)(z?)", + "VFIXUPIMMSSrri(b?)(k?)(z?)", + "VGETEXPPDZ128r(b?)(k?)(z?)", + "VGETEXPPDZ256r(b?)(k?)(z?)", + "VGETEXPPDr(b?)(k?)(z?)", + "VGETEXPPSZ128r(b?)(k?)(z?)", + "VGETEXPPSZ256r(b?)(k?)(z?)", + "VGETEXPPSr(b?)(k?)(z?)", + "VGETEXPSDr(b?)(k?)(z?)", + "VGETEXPSSr(b?)(k?)(z?)", + "VGETMANTPDZ128rri(b?)(k?)(z?)", + "VGETMANTPDZ256rri(b?)(k?)(z?)", + "VGETMANTPDZrri(b?)(k?)(z?)", + "VGETMANTPSZ128rri(b?)(k?)(z?)", + "VGETMANTPSZ256rri(b?)(k?)(z?)", + "VGETMANTPSZrri(b?)(k?)(z?)", + "VGETMANTSDZ128rri(b?)(k?)(z?)", + "VGETMANTSSZ128rri(b?)(k?)(z?)", + "VMAX(C?)PDYrr", + "VMAX(C?)PDZ128rr(b?)(k?)(z?)", + "VMAX(C?)PDZ256rr(b?)(k?)(z?)", + "VMAX(C?)PDZrr(b?)(k?)(z?)", + "VMAX(C?)PDrr", + "VMAX(C?)PSYrr", + "VMAX(C?)PSZ128rr(b?)(k?)(z?)", + "VMAX(C?)PSZ256rr(b?)(k?)(z?)", + "VMAX(C?)PSZrr(b?)(k?)(z?)", + "VMAX(C?)PSrr", + "VMAX(C?)SDZrr(b?)(_Int)?(k?)(z?)", + "VMAX(C?)SDrr", + "VMAX(C?)SSZrr(b?)(_Int)?(k?)(z?)", + "VMAX(C?)SSrr", + "VMIN(C?)PDYrr", + "VMIN(C?)PDZ128rr(b?)(k?)(z?)", + "VMIN(C?)PDZ256rr(b?)(k?)(z?)", + "VMIN(C?)PDZrr(b?)(k?)(z?)", + "VMIN(C?)PDrr", + "VMIN(C?)PSYrr", + "VMIN(C?)PSZ128rr(b?)(k?)(z?)", + "VMIN(C?)PSZ256rr(b?)(k?)(z?)", + "VMIN(C?)PSZrr(b?)(k?)(z?)", + "VMIN(C?)PSrr", + "VMIN(C?)SDZrr(b?)(_Int)?(k?)(z?)", + "VMIN(C?)SDrr", + "VMIN(C?)SSZrr(b?)(_Int)?(k?)(z?)", + "VMIN(C?)SSrr", + "VMULPDYrr", + "VMULPDZ128rr(b?)(k?)(z?)", + "VMULPDZ256rr(b?)(k?)(z?)", + "VMULPDZrr(b?)(k?)(z?)", + "VMULPDrr", + "VMULPSYrr", + "VMULPSZ128rr(b?)(k?)(z?)", + "VMULPSZ256rr(b?)(k?)(z?)", + "VMULPSZrr(b?)(k?)(z?)", + "VMULPSrr", + "VMULSDZrr(b?)(_Int)?(k?)(z?)", + "VMULSDrr", + "VMULSSZrr(b?)(_Int)?(k?)(z?)", + "VMULSSrr", + "VPHMINPOSUWrr", + "VPLZCNTDZ128rr(b?)(k?)(z?)", + "VPLZCNTDZ256rr(b?)(k?)(z?)", + "VPLZCNTDZrr(b?)(k?)(z?)", + "VPLZCNTQZ128rr(b?)(k?)(z?)", + "VPLZCNTQZ256rr(b?)(k?)(z?)", + "VPLZCNTQZrr(b?)(k?)(z?)", + "VPMADDUBSWYrr", + "VPMADDUBSWZ128rr(b?)(k?)(z?)", + "VPMADDUBSWZ256rr(b?)(k?)(z?)", + "VPMADDUBSWZrr(b?)(k?)(z?)", + "VPMADDUBSWrr", + "VPMADDWDYrr", + "VPMADDWDZ128rr(b?)(k?)(z?)", + "VPMADDWDZ256rr(b?)(k?)(z?)", + "VPMADDWDZrr(b?)(k?)(z?)", + "VPMADDWDrr", + "VPMULDQYrr", + "VPMULDQZ128rr(b?)(k?)(z?)", + "VPMULDQZ256rr(b?)(k?)(z?)", + "VPMULDQZrr(b?)(k?)(z?)", + "VPMULDQrr", + "VPMULHRSWYrr", + "VPMULHRSWZ128rr(b?)(k?)(z?)", + "VPMULHRSWZ256rr(b?)(k?)(z?)", + "VPMULHRSWZrr(b?)(k?)(z?)", + "VPMULHRSWrr", + "VPMULHUWYrr", + "VPMULHUWZ128rr(b?)(k?)(z?)", + "VPMULHUWZ256rr(b?)(k?)(z?)", + "VPMULHUWZrr(b?)(k?)(z?)", + "VPMULHUWrr", + "VPMULHWYrr", + "VPMULHWZ128rr(b?)(k?)(z?)", + "VPMULHWZ256rr(b?)(k?)(z?)", + "VPMULHWZrr(b?)(k?)(z?)", + "VPMULHWrr", + "VPMULLWYrr", + "VPMULLWZ128rr(b?)(k?)(z?)", + "VPMULLWZ256rr(b?)(k?)(z?)", + "VPMULLWZrr(b?)(k?)(z?)", + "VPMULLWrr", + "VPMULUDQYrr", + "VPMULUDQZ128rr(b?)(k?)(z?)", + "VPMULUDQZ256rr(b?)(k?)(z?)", + "VPMULUDQZrr(b?)(k?)(z?)", + "VPMULUDQrr", + "VRANGEPDZ128rri(b?)(k?)(z?)", + "VRANGEPDZ256rri(b?)(k?)(z?)", + "VRANGEPDZrri(b?)(k?)(z?)", + "VRANGEPSZ128rri(b?)(k?)(z?)", + "VRANGEPSZ256rri(b?)(k?)(z?)", + "VRANGEPSZrri(b?)(k?)(z?)", + "VRANGESDZ128rri(b?)(k?)(z?)", + "VRANGESSZ128rri(b?)(k?)(z?)", + "VREDUCEPDZ128rri(b?)(k?)(z?)", + "VREDUCEPDZ256rri(b?)(k?)(z?)", + "VREDUCEPDZrri(b?)(k?)(z?)", + "VREDUCEPSZ128rri(b?)(k?)(z?)", + "VREDUCEPSZ256rri(b?)(k?)(z?)", + "VREDUCEPSZrri(b?)(k?)(z?)", + "VREDUCESDZ128rri(b?)(k?)(z?)", + "VREDUCESSZ128rri(b?)(k?)(z?)", + "VSCALEFPDZ128rr(b?)(k?)(z?)", + "VSCALEFPDZ256rr(b?)(k?)(z?)", + "VSCALEFPDZrr(b?)(k?)(z?)", + "VSCALEFPSZ128rr(b?)(k?)(z?)", + "VSCALEFPSZ256rr(b?)(k?)(z?)", + "VSCALEFPSZrr(b?)(k?)(z?)", + "VSCALEFSDZ128rr(b?)(k?)(z?)", + "VSCALEFSSZ128rr(b?)(k?)(z?)", + "VSUBPDYrr", + "VSUBPDZ128rr(b?)(k?)(z?)", + "VSUBPDZ256rr(b?)(k?)(z?)", + "VSUBPDZrr(b?)(k?)(z?)", + "VSUBPDrr", + "VSUBPSYrr", + "VSUBPSZ128rr(b?)(k?)(z?)", + "VSUBPSZ256rr(b?)(k?)(z?)", + "VSUBPSZrr(b?)(k?)(z?)", + "VSUBPSrr", + "VSUBSDZrr(b?)(_Int)?(k?)(z?)", + "VSUBSDrr", + "VSUBSSZrr(b?)(_Int)?(k?)(z?)", + "VSUBSSrr")>; def: InstRW<[SKXWriteResGroup50], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Yr", @@ -2347,222 +2489,80 @@ def: InstRW<[SKXWriteResGroup50], "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)r", "VF(N)?M(ADD|SUB)(132|213|231)S(D|S)Zr(b?)(_Int)?(k?)(z?)", "VF(N)?M(ADD|SUB)(132|213|231)S(D|S)r")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPDZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPDr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPSZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPSZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPPSr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPSDr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETEXPSSr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTSDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VGETMANTSSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)SDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)SSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMAX(C?)SSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)PSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)SDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)SDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)SSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMIN(C?)SSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULSDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULSSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VMULSSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPHMINPOSUWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPLZCNTQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDUBSWYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDUBSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDUBSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDUBSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDUBSWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDWDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDWDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDWDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDWDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMADDWDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULDQYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULDQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHRSWYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHRSWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHRSWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHRSWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHRSWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHUWYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHUWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHUWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHUWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHUWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHWYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULHWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULLWYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULLWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULLWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULLWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULLWrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULUDQYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULUDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULUDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULUDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VPMULUDQrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGEPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGESDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VRANGESSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCEPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCESDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VREDUCESSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFSDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSCALEFSSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPDYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPSYrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBPSrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBSDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBSDrr")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBSSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup50], (instregex "VSUBSSrr")>; def SKXWriteResGroup51 : SchedWriteRes<[SKXPort5]> { let Latency = 4; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup51], (instregex "MPSADBWrri")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VEXPANDPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VMPSADBWYrri")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VMPSADBWrri")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPEXPANDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVQWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSQWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSWBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSWBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVSWBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSDWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSQWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSWBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSWBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVUSWBZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVWBZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVWBZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup51], (instregex "VPMOVWBZrr(b?)(k?)(z?)")>; - +def: InstRW<[SKXWriteResGroup51], (instregex "MPSADBWrri", + "VEXPANDPDZ128rr(b?)(k?)(z?)", + "VEXPANDPDZ256rr(b?)(k?)(z?)", + "VEXPANDPDZrr(b?)(k?)(z?)", + "VEXPANDPSZ128rr(b?)(k?)(z?)", + "VEXPANDPSZ256rr(b?)(k?)(z?)", + "VEXPANDPSZrr(b?)(k?)(z?)", + "VMPSADBWYrri", + "VMPSADBWrri", + "VPEXPANDDZ128rr(b?)(k?)(z?)", + "VPEXPANDDZ256rr(b?)(k?)(z?)", + "VPEXPANDDZrr(b?)(k?)(z?)", + "VPEXPANDQZ128rr(b?)(k?)(z?)", + "VPEXPANDQZ256rr(b?)(k?)(z?)", + "VPEXPANDQZrr(b?)(k?)(z?)", + "VPMOVDBZ128rr(b?)(k?)(z?)", + "VPMOVDBZ256rr(b?)(k?)(z?)", + "VPMOVDBZrr(b?)(k?)(z?)", + "VPMOVDWZ128rr(b?)(k?)(z?)", + "VPMOVDWZ256rr(b?)(k?)(z?)", + "VPMOVDWZrr(b?)(k?)(z?)", + "VPMOVQBZ128rr(b?)(k?)(z?)", + "VPMOVQBZ256rr(b?)(k?)(z?)", + "VPMOVQBZrr(b?)(k?)(z?)", + "VPMOVQWZ128rr(b?)(k?)(z?)", + "VPMOVQWZ256rr(b?)(k?)(z?)", + "VPMOVQWZrr(b?)(k?)(z?)", + "VPMOVSDBZ128rr(b?)(k?)(z?)", + "VPMOVSDBZ256rr(b?)(k?)(z?)", + "VPMOVSDBZrr(b?)(k?)(z?)", + "VPMOVSDWZ128rr(b?)(k?)(z?)", + "VPMOVSDWZ256rr(b?)(k?)(z?)", + "VPMOVSDWZrr(b?)(k?)(z?)", + "VPMOVSQBZ128rr(b?)(k?)(z?)", + "VPMOVSQBZ256rr(b?)(k?)(z?)", + "VPMOVSQBZrr(b?)(k?)(z?)", + "VPMOVSQDZ128rr(b?)(k?)(z?)", + "VPMOVSQDZ256rr(b?)(k?)(z?)", + "VPMOVSQDZrr(b?)(k?)(z?)", + "VPMOVSQWZ128rr(b?)(k?)(z?)", + "VPMOVSQWZ256rr(b?)(k?)(z?)", + "VPMOVSQWZrr(b?)(k?)(z?)", + "VPMOVSWBZ128rr(b?)(k?)(z?)", + "VPMOVSWBZ256rr(b?)(k?)(z?)", + "VPMOVSWBZrr(b?)(k?)(z?)", + "VPMOVUSDBZ128rr(b?)(k?)(z?)", + "VPMOVUSDBZ256rr(b?)(k?)(z?)", + "VPMOVUSDBZrr(b?)(k?)(z?)", + "VPMOVUSDWZ128rr(b?)(k?)(z?)", + "VPMOVUSDWZ256rr(b?)(k?)(z?)", + "VPMOVUSDWZrr(b?)(k?)(z?)", + "VPMOVUSQBZ128rr(b?)(k?)(z?)", + "VPMOVUSQBZ256rr(b?)(k?)(z?)", + "VPMOVUSQBZrr(b?)(k?)(z?)", + "VPMOVUSQDZ128rr(b?)(k?)(z?)", + "VPMOVUSQDZ256rr(b?)(k?)(z?)", + "VPMOVUSQDZrr(b?)(k?)(z?)", + "VPMOVUSQWZ128rr(b?)(k?)(z?)", + "VPMOVUSQWZ256rr(b?)(k?)(z?)", + "VPMOVUSQWZrr(b?)(k?)(z?)", + "VPMOVUSWBZ128rr(b?)(k?)(z?)", + "VPMOVUSWBZ256rr(b?)(k?)(z?)", + "VPMOVUSWBZrr(b?)(k?)(z?)", + "VPMOVWBZ128rr(b?)(k?)(z?)", + "VPMOVWBZ256rr(b?)(k?)(z?)", + "VPMOVWBZrr(b?)(k?)(z?)")>; + +// FIXME: IMUL32r/MUL32r should be uops lik SkylakeClient. def SKXWriteResGroup52 : SchedWriteRes<[SKXPort1,SKXPort5]> { let Latency = 4; let NumMicroOps = 2; @@ -2576,57 +2576,56 @@ def SKXWriteResGroup52_16 : SchedWriteRes<[SKXPort1,SKXPort06,SKXPort0156]> { let Latency = 4; let NumMicroOps = 4; } -def: InstRW<[SKXWriteResGroup52_16], (instrs IMUL16r)>; -def: InstRW<[SKXWriteResGroup52_16], (instrs MUL16r)>; +def: InstRW<[SKXWriteResGroup52_16], (instrs IMUL16r, MUL16r)>; def SKXWriteResGroup53 : SchedWriteRes<[SKXPort5,SKXPort01]> { let Latency = 4; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLDYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLQYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLWYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRADYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRADZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRADZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRAQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRAQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRAWYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRAWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRAWZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLDYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLQYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLWYrr")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup53], (instregex "VPSRLWZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup53], (instregex "VPSLLDYrr", + "VPSLLDZ256rr(b?)(k?)(z?)", + "VPSLLDZrr(b?)(k?)(z?)", + "VPSLLQYrr", + "VPSLLQZ256rr(b?)(k?)(z?)", + "VPSLLQZrr(b?)(k?)(z?)", + "VPSLLWYrr", + "VPSLLWZ256rr(b?)(k?)(z?)", + "VPSLLWZrr(b?)(k?)(z?)", + "VPSRADYrr", + "VPSRADZ256rr(b?)(k?)(z?)", + "VPSRADZrr(b?)(k?)(z?)", + "VPSRAQZ256rr(b?)(k?)(z?)", + "VPSRAQZrr(b?)(k?)(z?)", + "VPSRAWYrr", + "VPSRAWZ256rr(b?)(k?)(z?)", + "VPSRAWZrr(b?)(k?)(z?)", + "VPSRLDYrr", + "VPSRLDZ256rr(b?)(k?)(z?)", + "VPSRLDZrr(b?)(k?)(z?)", + "VPSRLQYrr", + "VPSRLQZ256rr(b?)(k?)(z?)", + "VPSRLQZrr(b?)(k?)(z?)", + "VPSRLWYrr", + "VPSRLWZ256rr(b?)(k?)(z?)", + "VPSRLWZrr(b?)(k?)(z?)")>; def SKXWriteResGroup54 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237]> { let Latency = 4; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup54], (instregex "ISTT_FP16m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "ISTT_FP32m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "ISTT_FP64m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "IST_F16m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "IST_F32m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "IST_FP16m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "IST_FP32m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "IST_FP64m")>; -def: InstRW<[SKXWriteResGroup54], (instregex "VPMOVQDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup54], (instregex "VPMOVQDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup54], (instregex "VPMOVQDZmr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup54], (instregex "ISTT_FP16m", + "ISTT_FP32m", + "ISTT_FP64m", + "IST_F16m", + "IST_F32m", + "IST_FP16m", + "IST_FP32m", + "IST_FP64m", + "VPMOVQDZ128mr(b?)(k?)(z?)", + "VPMOVQDZ256mr(b?)(k?)(z?)", + "VPMOVQDZmr(b?)(k?)(z?)")>; def SKXWriteResGroup55 : SchedWriteRes<[SKXPort0156]> { let Latency = 4; @@ -2654,31 +2653,31 @@ def SKXWriteResGroup58 : SchedWriteRes<[SKXPort23]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup58], (instregex "MMX_MOVD64rm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MMX_MOVD64to64rm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MMX_MOVQ64rm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOV(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOV64toPQIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVDDUPrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVDI2PDIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVQI2PQIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVSDrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVSSrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVSX(16|32|64)rm16")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVSX(16|32|64)rm32")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVSX(16|32|64)rm8")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVZX(16|32|64)rm16")>; -def: InstRW<[SKXWriteResGroup58], (instregex "MOVZX(16|32|64)rm8")>; -def: InstRW<[SKXWriteResGroup58], (instregex "PREFETCHNTA")>; -def: InstRW<[SKXWriteResGroup58], (instregex "PREFETCHT0")>; -def: InstRW<[SKXWriteResGroup58], (instregex "PREFETCHT1")>; -def: InstRW<[SKXWriteResGroup58], (instregex "PREFETCHT2")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOV64toPQIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOVDDUPrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOVDI2PDIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOVQI2PQIrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOVSDrm")>; -def: InstRW<[SKXWriteResGroup58], (instregex "VMOVSSrm")>; +def: InstRW<[SKXWriteResGroup58], (instregex "MMX_MOVD64rm", + "MMX_MOVD64to64rm", + "MMX_MOVQ64rm", + "MOV(8|16|32|64)rm", + "MOV64toPQIrm", + "MOVDDUPrm", + "MOVDI2PDIrm", + "MOVQI2PQIrm", + "MOVSDrm", + "MOVSSrm", + "MOVSX(16|32|64)rm16", + "MOVSX(16|32|64)rm32", + "MOVSX(16|32|64)rm8", + "MOVZX(16|32|64)rm16", + "MOVZX(16|32|64)rm8", + "PREFETCHNTA", + "PREFETCHT0", + "PREFETCHT1", + "PREFETCHT2", + "VMOV64toPQIrm", + "VMOVDDUPrm", + "VMOVDI2PDIrm", + "VMOVQI2PQIrm", + "VMOVSDrm", + "VMOVSSrm")>; def SKXWriteResGroup59 : SchedWriteRes<[SKXPort015]> { let Latency = 5; @@ -2692,62 +2691,61 @@ def SKXWriteResGroup60 : SchedWriteRes<[SKXPort0,SKXPort5]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup60], (instregex "CVTDQ2PDrr")>; -def: InstRW<[SKXWriteResGroup60], (instregex "MMX_CVTPI2PDirr")>; -def: InstRW<[SKXWriteResGroup60], (instregex "VCVTDQ2PDrr")>; +def: InstRW<[SKXWriteResGroup60], (instregex "(V?)CVTDQ2PDrr", + "MMX_CVTPI2PDirr")>; def SKXWriteResGroup61 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 5; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup61], (instregex "CVTPD2DQrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTPD2PSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTPS2PDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTSD2SSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTSI642SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTSI2SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTSI2SSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTSS2SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "CVTTPD2DQrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "MMX_CVTPD2PIirr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "MMX_CVTPS2PIirr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "MMX_CVTTPD2PIirr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "MMX_CVTTPS2PIirr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTDQ2PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPD2DQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPD2DQrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPD2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPD2PSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPD2UDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPH2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPH2PSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2PDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2PHZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2PHrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2QQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTPS2UQQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTQQ2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSD2SSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI642SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI2SDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI2SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI2SSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI2SSrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSI642SDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSS2SDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTSS2SDrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTTPD2DQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTTPD2DQrr")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTTPD2UDQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTTPS2QQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTTPS2UQQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTUDQ2PDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTUQQ2PSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTUSI2SDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTUSI2SSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup61], (instregex "VCVTUSI642SDZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup61], (instregex "CVTPD2DQrr", + "CVTPD2PSrr", + "CVTPS2PDrr", + "CVTSD2SSrr", + "CVTSI642SDrr", + "CVTSI2SDrr", + "CVTSI2SSrr", + "CVTSS2SDrr", + "CVTTPD2DQrr", + "MMX_CVTPD2PIirr", + "MMX_CVTPS2PIirr", + "MMX_CVTTPD2PIirr", + "MMX_CVTTPS2PIirr", + "VCVTDQ2PDZ128rr(b?)(k?)(z?)", + "VCVTPD2DQZ128rr(b?)(k?)(z?)", + "VCVTPD2DQrr", + "VCVTPD2PSZ128rr(b?)(k?)(z?)", + "VCVTPD2PSrr", + "VCVTPD2UDQZ128rr(b?)(k?)(z?)", + "VCVTPH2PSZ128rr(b?)(k?)(z?)", + "VCVTPH2PSrr", + "VCVTPS2PDZ128rr(b?)(k?)(z?)", + "VCVTPS2PDrr", + "VCVTPS2PHZ128rr(b?)(k?)(z?)", + "VCVTPS2PHrr", + "VCVTPS2QQZ128rr(b?)(k?)(z?)", + "VCVTPS2UQQZ128rr(b?)(k?)(z?)", + "VCVTQQ2PSZ128rr(b?)(k?)(z?)", + "VCVTSD2SSrr", + "VCVTSI642SDrr", + "VCVTSI2SDZrr(b?)(k?)(z?)", + "VCVTSI2SDrr", + "VCVTSI2SSZrr(b?)(k?)(z?)", + "VCVTSI2SSrr", + "VCVTSI642SDZrr(b?)(k?)(z?)", + "VCVTSS2SDZrr(b?)(_Int)?(k?)(z?)", + "VCVTSS2SDrr", + "VCVTTPD2DQZ128rr(b?)(k?)(z?)", + "VCVTTPD2DQrr", + "VCVTTPD2UDQZ128rr(b?)(k?)(z?)", + "VCVTTPS2QQZ128rr(b?)(k?)(z?)", + "VCVTTPS2UQQZ128rr(b?)(k?)(z?)", + "VCVTUDQ2PDZ128rr(b?)(k?)(z?)", + "VCVTUQQ2PSZ128rr(b?)(k?)(z?)", + "VCVTUSI2SDZrr(b?)(k?)(z?)", + "VCVTUSI2SSZrr(b?)(k?)(z?)", + "VCVTUSI642SDZrr(b?)(k?)(z?)")>; def SKXWriteResGroup62 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 5; @@ -2775,66 +2773,66 @@ def SKXWriteResGroup65 : SchedWriteRes<[SKXPort4,SKXPort237,SKXPort015]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup65], (instregex "VCVTPS2PHZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup65], (instregex "VCVTPS2PHZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup65], (instregex "VCVTPS2PHZmr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup65], (instregex "VCVTPS2PHZ128mr(b?)(k?)(z?)", + "VCVTPS2PHZ256mr(b?)(k?)(z?)", + "VCVTPS2PHZmr(b?)(k?)(z?)")>; def SKXWriteResGroup66 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237]> { let Latency = 5; let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVQWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSDWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSQWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSWBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSWBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVSWBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSDWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQWZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQWZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSQWZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSWBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSWBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVUSWBZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVWBZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVWBZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVWBZmr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup66], (instregex "VPMOVDBZ128mr(b?)(k?)(z?)", + "VPMOVDBZ256mr(b?)(k?)(z?)", + "VPMOVDBZmr(b?)(k?)(z?)", + "VPMOVDWZ128mr(b?)(k?)(z?)", + "VPMOVDWZ256mr(b?)(k?)(z?)", + "VPMOVDWZmr(b?)(k?)(z?)", + "VPMOVQBZ128mr(b?)(k?)(z?)", + "VPMOVQBZ256mr(b?)(k?)(z?)", + "VPMOVQBZmr(b?)(k?)(z?)", + "VPMOVQWZ128mr(b?)(k?)(z?)", + "VPMOVQWZ256mr(b?)(k?)(z?)", + "VPMOVQWZmr(b?)(k?)(z?)", + "VPMOVSDBZ128mr(b?)(k?)(z?)", + "VPMOVSDBZ256mr(b?)(k?)(z?)", + "VPMOVSDBZmr(b?)(k?)(z?)", + "VPMOVSDWZ128mr(b?)(k?)(z?)", + "VPMOVSDWZ256mr(b?)(k?)(z?)", + "VPMOVSDWZmr(b?)(k?)(z?)", + "VPMOVSQBZ128mr(b?)(k?)(z?)", + "VPMOVSQBZ256mr(b?)(k?)(z?)", + "VPMOVSQBZmr(b?)(k?)(z?)", + "VPMOVSQDZ128mr(b?)(k?)(z?)", + "VPMOVSQDZ256mr(b?)(k?)(z?)", + "VPMOVSQDZmr(b?)(k?)(z?)", + "VPMOVSQWZ128mr(b?)(k?)(z?)", + "VPMOVSQWZ256mr(b?)(k?)(z?)", + "VPMOVSQWZmr(b?)(k?)(z?)", + "VPMOVSWBZ128mr(b?)(k?)(z?)", + "VPMOVSWBZ256mr(b?)(k?)(z?)", + "VPMOVSWBZmr(b?)(k?)(z?)", + "VPMOVUSDBZ128mr(b?)(k?)(z?)", + "VPMOVUSDBZ256mr(b?)(k?)(z?)", + "VPMOVUSDBZmr(b?)(k?)(z?)", + "VPMOVUSDWZ128mr(b?)(k?)(z?)", + "VPMOVUSDWZ256mr(b?)(k?)(z?)", + "VPMOVUSDWZmr(b?)(k?)(z?)", + "VPMOVUSQBZ128mr(b?)(k?)(z?)", + "VPMOVUSQBZ256mr(b?)(k?)(z?)", + "VPMOVUSQBZmr(b?)(k?)(z?)", + "VPMOVUSQDZ128mr(b?)(k?)(z?)", + "VPMOVUSQDZ256mr(b?)(k?)(z?)", + "VPMOVUSQDZmr(b?)(k?)(z?)", + "VPMOVUSQWZ128mr(b?)(k?)(z?)", + "VPMOVUSQWZ256mr(b?)(k?)(z?)", + "VPMOVUSQWZmr(b?)(k?)(z?)", + "VPMOVUSWBZ128mr(b?)(k?)(z?)", + "VPMOVUSWBZ256mr(b?)(k?)(z?)", + "VPMOVUSWBZmr(b?)(k?)(z?)", + "VPMOVWBZ128mr(b?)(k?)(z?)", + "VPMOVWBZ256mr(b?)(k?)(z?)", + "VPMOVWBZmr(b?)(k?)(z?)")>; def SKXWriteResGroup67 : SchedWriteRes<[SKXPort06,SKXPort0156]> { let Latency = 5; @@ -2855,311 +2853,310 @@ def SKXWriteResGroup69 : SchedWriteRes<[SKXPort4,SKXPort237,SKXPort0156]> { let NumMicroOps = 6; let ResourceCycles = [1,1,4]; } -def: InstRW<[SKXWriteResGroup69], (instregex "PUSHF16")>; -def: InstRW<[SKXWriteResGroup69], (instregex "PUSHF64")>; +def: InstRW<[SKXWriteResGroup69], (instregex "PUSHF16", + "PUSHF64")>; def SKXWriteResGroup70 : SchedWriteRes<[SKXPort5]> { let Latency = 6; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup70], (instregex "PCLMULQDQrr")>; -def: InstRW<[SKXWriteResGroup70], (instregex "VPCLMULQDQrr")>; +def: InstRW<[SKXWriteResGroup70], (instregex "(V?)PCLMULQDQrr")>; def SKXWriteResGroup71 : SchedWriteRes<[SKXPort23]> { let Latency = 6; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup71], (instregex "LDDQUrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVAPDrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVAPSrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVDQArm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVDQUrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVNTDQArm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVSHDUPrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVSLDUPrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVUPDrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "MOVUPSrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VBROADCASTSSrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VLDDQUrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVAPDrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVAPSrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVDQArm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVDQUrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVNTDQArm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVSHDUPrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVSLDUPrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVUPDrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VMOVUPSrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VPBROADCASTDrm")>; -def: InstRW<[SKXWriteResGroup71], (instregex "VPBROADCASTQrm")>; +def: InstRW<[SKXWriteResGroup71], (instregex "LDDQUrm", + "MOVAPDrm", + "MOVAPSrm", + "MOVDQArm", + "MOVDQUrm", + "MOVNTDQArm", + "MOVSHDUPrm", + "MOVSLDUPrm", + "MOVUPDrm", + "MOVUPSrm", + "VBROADCASTSSrm", + "VLDDQUrm", + "VMOVAPDrm", + "VMOVAPSrm", + "VMOVDQArm", + "VMOVDQUrm", + "VMOVNTDQArm", + "VMOVSHDUPrm", + "VMOVSLDUPrm", + "VMOVUPDrm", + "VMOVUPSrm", + "VPBROADCASTDrm", + "VPBROADCASTQrm")>; def SKXWriteResGroup72 : SchedWriteRes<[SKXPort0]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup72], (instregex "MMX_CVTPI2PSirr")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VCOMPRESSPSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPCOMPRESSQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPERMWZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPERMWZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup72], (instregex "VPERMWZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup72], (instregex "MMX_CVTPI2PSirr", + "VCOMPRESSPDZ128rr(b?)(k?)(z?)", + "VCOMPRESSPDZ256rr(b?)(k?)(z?)", + "VCOMPRESSPDZrr(b?)(k?)(z?)", + "VCOMPRESSPSZ128rr(b?)(k?)(z?)", + "VCOMPRESSPSZ256rr(b?)(k?)(z?)", + "VCOMPRESSPSZrr(b?)(k?)(z?)", + "VPCOMPRESSDZ128rr(b?)(k?)(z?)", + "VPCOMPRESSDZ256rr(b?)(k?)(z?)", + "VPCOMPRESSDZrr(b?)(k?)(z?)", + "VPCOMPRESSQZ128rr(b?)(k?)(z?)", + "VPCOMPRESSQZ256rr(b?)(k?)(z?)", + "VPCOMPRESSQZrr(b?)(k?)(z?)", + "VPERMWZ128rr(b?)(k?)(z?)", + "VPERMWZ256rr(b?)(k?)(z?)", + "VPERMWZrr(b?)(k?)(z?)")>; def SKXWriteResGroup73 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PADDSBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PADDSWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PADDUSBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PADDUSWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PAVGBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PAVGWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPEQBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPEQDirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPEQWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPGTBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPGTDirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PCMPGTWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PMAXSWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PMAXUBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PMINSWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PMINUBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSLLDrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSLLQrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSLLWrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSRADrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSRAWrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSRLDrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSRLQrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSRLWrm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSUBSBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSUBSWirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSUBUSBirm")>; -def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PSUBUSWirm")>; +def: InstRW<[SKXWriteResGroup73], (instregex "MMX_PADDSBirm", + "MMX_PADDSWirm", + "MMX_PADDUSBirm", + "MMX_PADDUSWirm", + "MMX_PAVGBirm", + "MMX_PAVGWirm", + "MMX_PCMPEQBirm", + "MMX_PCMPEQDirm", + "MMX_PCMPEQWirm", + "MMX_PCMPGTBirm", + "MMX_PCMPGTDirm", + "MMX_PCMPGTWirm", + "MMX_PMAXSWirm", + "MMX_PMAXUBirm", + "MMX_PMINSWirm", + "MMX_PMINUBirm", + "MMX_PSLLDrm", + "MMX_PSLLQrm", + "MMX_PSLLWrm", + "MMX_PSRADrm", + "MMX_PSRAWrm", + "MMX_PSRLDrm", + "MMX_PSRLQrm", + "MMX_PSRLWrm", + "MMX_PSUBSBirm", + "MMX_PSUBSWirm", + "MMX_PSUBUSBirm", + "MMX_PSUBUSWirm")>; def SKXWriteResGroup74 : SchedWriteRes<[SKXPort0,SKXPort015]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup74], (instregex "CVTSD2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "CVTSD2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "CVTSS2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "CVTSS2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "CVTTSD2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "CVTTSD2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2SI64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2SIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2USI64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSD2USIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSS2SI64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSS2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSS2SIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSS2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTSS2USIZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2SI64Zrr(b?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2SI64rr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2SIZrr(b?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2SIrr")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2USI64Zrr(b?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSD2USIZrr(b?)")>; -def: InstRW<[SKXWriteResGroup74], (instregex "VCVTTSS2USIZrr(b?)")>; +def: InstRW<[SKXWriteResGroup74], (instregex "CVTSD2SI64rr", + "CVTSD2SIrr", + "CVTSS2SI64rr", + "CVTSS2SIrr", + "CVTTSD2SI64rr", + "CVTTSD2SIrr", + "VCVTSD2SI64Zrr(b?)(k?)(z?)", + "VCVTSD2SI64rr", + "VCVTSD2SIZrr(b?)(k?)(z?)", + "VCVTSD2SIrr", + "VCVTSD2USI64Zrr(b?)(k?)(z?)", + "VCVTSD2USIZrr(b?)(k?)(z?)", + "VCVTSS2SI64Zrr(b?)(k?)(z?)", + "VCVTSS2SI64rr", + "VCVTSS2SIZrr(b?)(k?)(z?)", + "VCVTSS2SIrr", + "VCVTSS2USIZrr(b?)(k?)(z?)", + "VCVTTSD2SI64Zrr(b?)", + "VCVTTSD2SI64rr", + "VCVTTSD2SIZrr(b?)", + "VCVTTSD2SIrr", + "VCVTTSD2USI64Zrr(b?)", + "VCVTTSD2USIZrr(b?)", + "VCVTTSS2USIZrr(b?)")>; def SKXWriteResGroup75 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PALIGNRrmi")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PINSRWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PSHUFBrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PSHUFWmi")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKHBWirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKHDQirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKHWDirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKLBWirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKLDQirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PUNPCKLWDirm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MOVHPDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MOVHPSrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MOVLPDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "MOVLPSrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PINSRBrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PINSRDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PINSRQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PINSRWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXBDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXBQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXBWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXDQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXWDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVSXWQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXBDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXBQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXBWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXDQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXWDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "PMOVZXWQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVHPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVHPDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVHPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVHPSrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVLPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVLPDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVLPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VMOVLPSrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRBrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPINSRWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXBDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXBQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXBWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXDQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXWDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVSXWQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXBDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXBQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXBWrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXDQrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXWDrm")>; -def: InstRW<[SKXWriteResGroup75], (instregex "VPMOVZXWQrm")>; +def: InstRW<[SKXWriteResGroup75], (instregex "MMX_PALIGNRrmi", + "MMX_PINSRWrm", + "MMX_PSHUFBrm", + "MMX_PSHUFWmi", + "MMX_PUNPCKHBWirm", + "MMX_PUNPCKHDQirm", + "MMX_PUNPCKHWDirm", + "MMX_PUNPCKLBWirm", + "MMX_PUNPCKLDQirm", + "MMX_PUNPCKLWDirm", + "MOVHPDrm", + "MOVHPSrm", + "MOVLPDrm", + "MOVLPSrm", + "PINSRBrm", + "PINSRDrm", + "PINSRQrm", + "PINSRWrm", + "PMOVSXBDrm", + "PMOVSXBQrm", + "PMOVSXBWrm", + "PMOVSXDQrm", + "PMOVSXWDrm", + "PMOVSXWQrm", + "PMOVZXBDrm", + "PMOVZXBQrm", + "PMOVZXBWrm", + "PMOVZXDQrm", + "PMOVZXWDrm", + "PMOVZXWQrm", + "VMOVHPDZ128rm(b?)(k?)(z?)", + "VMOVHPDrm", + "VMOVHPSZ128rm(b?)(k?)(z?)", + "VMOVHPSrm", + "VMOVLPDZ128rm(b?)(k?)(z?)", + "VMOVLPDrm", + "VMOVLPSZ128rm(b?)(k?)(z?)", + "VMOVLPSrm", + "VPINSRBZrm(b?)(k?)(z?)", + "VPINSRBrm", + "VPINSRDZrm(b?)(k?)(z?)", + "VPINSRDrm", + "VPINSRQZrm(b?)(k?)(z?)", + "VPINSRQrm", + "VPINSRWZrm(b?)(k?)(z?)", + "VPINSRWrm", + "VPMOVSXBDrm", + "VPMOVSXBQrm", + "VPMOVSXBWrm", + "VPMOVSXDQrm", + "VPMOVSXWDrm", + "VPMOVSXWQrm", + "VPMOVZXBDrm", + "VPMOVZXBQrm", + "VPMOVZXBWrm", + "VPMOVZXDQrm", + "VPMOVZXWDrm", + "VPMOVZXWQrm")>; def SKXWriteResGroup76 : SchedWriteRes<[SKXPort6,SKXPort23]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup76], (instregex "FARJMP64")>; -def: InstRW<[SKXWriteResGroup76], (instregex "JMP(16|32|64)m")>; +def: InstRW<[SKXWriteResGroup76], (instregex "FARJMP64", + "JMP(16|32|64)m")>; def SKXWriteResGroup77 : SchedWriteRes<[SKXPort23,SKXPort05]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PABSBrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PABSDrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PABSWrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PADDBirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PADDDirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PADDQirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PADDWirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PANDNirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PANDirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PORirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSIGNBrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSIGNDrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSIGNWrm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSUBBirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSUBDirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSUBQirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PSUBWirm")>; -def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PXORirm")>; +def: InstRW<[SKXWriteResGroup77], (instregex "MMX_PABSBrm", + "MMX_PABSDrm", + "MMX_PABSWrm", + "MMX_PADDBirm", + "MMX_PADDDirm", + "MMX_PADDQirm", + "MMX_PADDWirm", + "MMX_PANDNirm", + "MMX_PANDirm", + "MMX_PORirm", + "MMX_PSIGNBrm", + "MMX_PSIGNDrm", + "MMX_PSIGNWrm", + "MMX_PSUBBirm", + "MMX_PSUBDirm", + "MMX_PSUBQirm", + "MMX_PSUBWirm", + "MMX_PXORirm")>; def SKXWriteResGroup78 : SchedWriteRes<[SKXPort23,SKXPort06]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup78], (instregex "ADC(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "ADCX(32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "ADOX(32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "BT(16|32|64)mi8")>; -def: InstRW<[SKXWriteResGroup78], (instregex "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "RORX(32|64)mi")>; -def: InstRW<[SKXWriteResGroup78], (instregex "SARX(32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "SBB(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "SHLX(32|64)rm")>; -def: InstRW<[SKXWriteResGroup78], (instregex "SHRX(32|64)rm")>; +def: InstRW<[SKXWriteResGroup78], (instregex "ADC(8|16|32|64)rm", + "ADCX(32|64)rm", + "ADOX(32|64)rm", + "BT(16|32|64)mi8", + "CMOV(AE|B|E|G|GE|L|LE|NE|NO|NP|NS|O|P|S)(16|32|64)rm", + "RORX(32|64)mi", + "SARX(32|64)rm", + "SBB(8|16|32|64)rm", + "SHLX(32|64)rm", + "SHRX(32|64)rm")>; def SKXWriteResGroup79 : SchedWriteRes<[SKXPort23,SKXPort15]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup79], (instregex "ANDN(32|64)rm")>; -def: InstRW<[SKXWriteResGroup79], (instregex "BLSI(32|64)rm")>; -def: InstRW<[SKXWriteResGroup79], (instregex "BLSMSK(32|64)rm")>; -def: InstRW<[SKXWriteResGroup79], (instregex "BLSR(32|64)rm")>; -def: InstRW<[SKXWriteResGroup79], (instregex "BZHI(32|64)rm")>; -def: InstRW<[SKXWriteResGroup79], (instregex "MOVBE(16|32|64)rm")>; +def: InstRW<[SKXWriteResGroup79], (instregex "ANDN(32|64)rm", + "BLSI(32|64)rm", + "BLSMSK(32|64)rm", + "BLSR(32|64)rm", + "BZHI(32|64)rm", + "MOVBE(16|32|64)rm")>; def SKXWriteResGroup80 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup80], (instregex "VMOV(64to|QI2)PQIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup80], (instregex "VMOVDI2PDIZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup80], (instregex "VMOV(64to|QI2)PQIZrm(b?)(k?)(z?)", + "VMOVDI2PDIZrm(b?)(k?)(z?)")>; def SKXWriteResGroup81 : SchedWriteRes<[SKXPort23,SKXPort0156]> { let Latency = 6; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup81], (instregex "ADD(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup81], (instregex "AND(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup81], (instregex "CMP(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup81], (instregex "CMP(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup81], (instregex "CMP(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup81], (instregex "OR(8|16|32|64)rm")>; def: InstRW<[SKXWriteResGroup81], (instrs POP16r, POP32r, POP64r)>; -def: InstRW<[SKXWriteResGroup81], (instregex "POP(16|32|64)rmr")>; -def: InstRW<[SKXWriteResGroup81], (instregex "SUB(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup81], (instregex "TEST(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup81], (instregex "TEST(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup81], (instregex "XOR(8|16|32|64)rm")>; +def: InstRW<[SKXWriteResGroup81], (instregex "ADD(8|16|32|64)rm", + "AND(8|16|32|64)rm", + "CMP(8|16|32|64)mi", + "CMP(8|16|32|64)mr", + "CMP(8|16|32|64)rm", + "OR(8|16|32|64)rm", + "POP(16|32|64)rmr", + "SUB(8|16|32|64)rm", + "TEST(8|16|32|64)mr", + "TEST(8|16|32|64)mi", + "XOR(8|16|32|64)rm")>; def SKXWriteResGroup82 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 6; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup82], (instregex "CVTSI642SSrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "HADDPDrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "HADDPSrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "HSUBPDrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "HSUBPSrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VCVTSI642SSrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VCVTSI642SSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VCVTUSI642SSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHADDPDYrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHADDPDrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHADDPSYrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHADDPSrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHSUBPDYrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHSUBPDrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHSUBPSYrr")>; -def: InstRW<[SKXWriteResGroup82], (instregex "VHSUBPSrr")>; +def: InstRW<[SKXWriteResGroup82], (instregex "CVTSI642SSrr", + "HADDPDrr", + "HADDPSrr", + "HSUBPDrr", + "HSUBPSrr", + "VCVTSI642SSrr", + "VCVTSI642SSZrr(b?)(k?)(z?)", + "VCVTUSI642SSZrr(b?)(k?)(z?)", + "VHADDPDYrr", + "VHADDPDrr", + "VHADDPSYrr", + "VHADDPSrr", + "VHSUBPDYrr", + "VHSUBPDrr", + "VHSUBPSYrr", + "VHSUBPSrr")>; def SKXWriteResGroup83 : SchedWriteRes<[SKXPort1,SKXPort06,SKXPort0156]> { let Latency = 6; let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKXWriteResGroup83], (instregex "SHLD(16|32|64)rrCL")>; -def: InstRW<[SKXWriteResGroup83], (instregex "SHRD(16|32|64)rrCL")>; +def: InstRW<[SKXWriteResGroup83], (instregex "SHLD(16|32|64)rrCL", + "SHRD(16|32|64)rrCL")>; def SKXWriteResGroup84 : SchedWriteRes<[SKXPort1,SKXPort6,SKXPort06,SKXPort0156]> { let Latency = 6; @@ -3180,37 +3177,37 @@ def SKXWriteResGroup86 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort06] let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKXWriteResGroup86], (instregex "BTC(16|32|64)mi8")>; -def: InstRW<[SKXWriteResGroup86], (instregex "BTR(16|32|64)mi8")>; -def: InstRW<[SKXWriteResGroup86], (instregex "BTS(16|32|64)mi8")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SAR(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SAR(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SHL(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SHL(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SHR(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup86], (instregex "SHR(8|16|32|64)mi")>; +def: InstRW<[SKXWriteResGroup86], (instregex "BTC(16|32|64)mi8", + "BTR(16|32|64)mi8", + "BTS(16|32|64)mi8", + "SAR(8|16|32|64)m1", + "SAR(8|16|32|64)mi", + "SHL(8|16|32|64)m1", + "SHL(8|16|32|64)mi", + "SHR(8|16|32|64)m1", + "SHR(8|16|32|64)mi")>; def SKXWriteResGroup87 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort0156]> { let Latency = 6; let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKXWriteResGroup87], (instregex "ADD(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup87], (instregex "ADD(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup87], (instregex "AND(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup87], (instregex "AND(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup87], (instregex "DEC(8|16|32|64)m")>; -def: InstRW<[SKXWriteResGroup87], (instregex "INC(8|16|32|64)m")>; -def: InstRW<[SKXWriteResGroup87], (instregex "NEG(8|16|32|64)m")>; -def: InstRW<[SKXWriteResGroup87], (instregex "NOT(8|16|32|64)m")>; -def: InstRW<[SKXWriteResGroup87], (instregex "OR(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup87], (instregex "OR(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup87], (instregex "POP(16|32|64)rmm")>; -def: InstRW<[SKXWriteResGroup87], (instregex "PUSH(16|32|64)rmm")>; -def: InstRW<[SKXWriteResGroup87], (instregex "SUB(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup87], (instregex "SUB(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup87], (instregex "XOR(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup87], (instregex "XOR(8|16|32|64)mr")>; +def: InstRW<[SKXWriteResGroup87], (instregex "ADD(8|16|32|64)mi", + "ADD(8|16|32|64)mr", + "AND(8|16|32|64)mi", + "AND(8|16|32|64)mr", + "DEC(8|16|32|64)m", + "INC(8|16|32|64)m", + "NEG(8|16|32|64)m", + "NOT(8|16|32|64)m", + "OR(8|16|32|64)mi", + "OR(8|16|32|64)mr", + "POP(16|32|64)rmm", + "PUSH(16|32|64)rmm", + "SUB(8|16|32|64)mi", + "SUB(8|16|32|64)mr", + "XOR(8|16|32|64)mi", + "XOR(8|16|32|64)mr")>; def SKXWriteResGroup88 : SchedWriteRes<[SKXPort6,SKXPort0156]> { let Latency = 6; @@ -3224,27 +3221,27 @@ def SKXWriteResGroup89 : SchedWriteRes<[SKXPort23]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup89], (instregex "LD_F32m")>; -def: InstRW<[SKXWriteResGroup89], (instregex "LD_F64m")>; -def: InstRW<[SKXWriteResGroup89], (instregex "LD_F80m")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VBROADCASTF128")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VBROADCASTI128")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VBROADCASTSDYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VBROADCASTSSYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VLDDQUYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVAPDYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVAPSYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVDDUPYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVDQAYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVDQUYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVNTDQAYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVNTDQAZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVSHDUPYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVSLDUPYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVUPDYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VMOVUPSYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VPBROADCASTDYrm")>; -def: InstRW<[SKXWriteResGroup89], (instregex "VPBROADCASTQYrm")>; +def: InstRW<[SKXWriteResGroup89], (instregex "LD_F32m", + "LD_F64m", + "LD_F80m", + "VBROADCASTF128", + "VBROADCASTI128", + "VBROADCASTSDYrm", + "VBROADCASTSSYrm", + "VLDDQUYrm", + "VMOVAPDYrm", + "VMOVAPSYrm", + "VMOVDDUPYrm", + "VMOVDQAYrm", + "VMOVDQUYrm", + "VMOVNTDQAYrm", + "VMOVNTDQAZrm(b?)(k?)(z?)", + "VMOVSHDUPYrm", + "VMOVSLDUPYrm", + "VMOVUPDYrm", + "VMOVUPSYrm", + "VPBROADCASTDYrm", + "VPBROADCASTQYrm")>; def SKXWriteResGroup90 : SchedWriteRes<[SKXPort0,SKXPort5]> { let Latency = 7; @@ -3258,444 +3255,444 @@ def SKXWriteResGroup91 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup91], (instregex "COMISDrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "COMISSrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "UCOMISDrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "UCOMISSrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VCOMISDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VCOMISDrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VCOMISSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VCOMISSrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VUCOMISDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VUCOMISDrm")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VUCOMISSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup91], (instregex "VUCOMISSrm")>; +def: InstRW<[SKXWriteResGroup91], (instregex "COMISDrm", + "COMISSrm", + "UCOMISDrm", + "UCOMISSrm", + "VCOMISDZrm(b?)(k?)(z?)", + "VCOMISDrm", + "VCOMISSZrm(b?)(k?)(z?)", + "VCOMISSrm", + "VUCOMISDZrm(b?)(k?)(z?)", + "VUCOMISDrm", + "VUCOMISSZrm(b?)(k?)(z?)", + "VUCOMISSrm")>; def SKXWriteResGroup92 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup92], (instregex "INSERTPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PACKSSDWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PACKSSWBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PACKUSDWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PACKUSWBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PALIGNRrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PBLENDWrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PSHUFBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PSHUFDmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PSHUFHWmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PSHUFLWmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKHBWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKHDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKHQDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKHWDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKLBWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKLDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKLQDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "PUNPCKLWDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "SHUFPDrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "SHUFPSrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "UNPCKHPDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "UNPCKHPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "UNPCKLPDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "UNPCKLPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VINSERTPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VINSERTPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VMOVSDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VMOVSSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKSSDWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKSSDWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKSSWBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKSSWBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKUSDWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKUSDWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKUSWBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPACKUSWBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPALIGNRZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPALIGNRrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPBLENDWrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPBROADCASTBZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPBROADCASTBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPBROADCASTWZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPBROADCASTWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPDmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPSZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPSmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPERMILPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFBrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFDmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFHWZ128mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFHWmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFLWZ128mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSHUFLWmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSLLDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPSRLDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHBWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHQDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHQDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHWDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKHWDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLBWrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLQDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLQDQrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLWDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VPUNPCKLWDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VSHUFPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VSHUFPDrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VSHUFPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VSHUFPSrmi")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKHPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKHPDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKHPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKHPSrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKLPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKLPDrm")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKLPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup92], (instregex "VUNPCKLPSrm")>; +def: InstRW<[SKXWriteResGroup92], (instregex "INSERTPSrm", + "PACKSSDWrm", + "PACKSSWBrm", + "PACKUSDWrm", + "PACKUSWBrm", + "PALIGNRrmi", + "PBLENDWrmi", + "PSHUFBrm", + "PSHUFDmi", + "PSHUFHWmi", + "PSHUFLWmi", + "PUNPCKHBWrm", + "PUNPCKHDQrm", + "PUNPCKHQDQrm", + "PUNPCKHWDrm", + "PUNPCKLBWrm", + "PUNPCKLDQrm", + "PUNPCKLQDQrm", + "PUNPCKLWDrm", + "SHUFPDrmi", + "SHUFPSrmi", + "UNPCKHPDrm", + "UNPCKHPSrm", + "UNPCKLPDrm", + "UNPCKLPSrm", + "VINSERTPSZrm(b?)(k?)(z?)", + "VINSERTPSrm", + "VMOVSDZrm(b?)(k?)(z?)", + "VMOVSSZrm(b?)(k?)(z?)", + "VPACKSSDWZ128rm(b?)(k?)(z?)", + "VPACKSSDWrm", + "VPACKSSWBZ128rm(b?)(k?)(z?)", + "VPACKSSWBrm", + "VPACKUSDWZ128rm(b?)(k?)(z?)", + "VPACKUSDWrm", + "VPACKUSWBZ128rm(b?)(k?)(z?)", + "VPACKUSWBrm", + "VPALIGNRZ128rmi(b?)(k?)(z?)", + "VPALIGNRrmi", + "VPBLENDWrmi", + "VPBROADCASTBZ128m(b?)(k?)(z?)", + "VPBROADCASTBrm", + "VPBROADCASTWZ128m(b?)(k?)(z?)", + "VPBROADCASTWrm", + "VPERMILPDZ128m(b?)i(k?)(z?)", + "VPERMILPDZ128rm(b?)(k?)(z?)", + "VPERMILPDmi", + "VPERMILPDrm", + "VPERMILPSZ128m(b?)i(k?)(z?)", + "VPERMILPSZ128rm(b?)(k?)(z?)", + "VPERMILPSmi", + "VPERMILPSrm", + "VPSHUFBZ128rm(b?)(k?)(z?)", + "VPSHUFBrm", + "VPSHUFDZ128m(b?)i(k?)(z?)", + "VPSHUFDmi", + "VPSHUFHWZ128mi(b?)(k?)(z?)", + "VPSHUFHWmi", + "VPSHUFLWZ128mi(b?)(k?)(z?)", + "VPSHUFLWmi", + "VPSLLDQZ128rm(b?)(k?)(z?)", + "VPSRLDQZ128rm(b?)(k?)(z?)", + "VPUNPCKHBWZ128rm(b?)(k?)(z?)", + "VPUNPCKHBWrm", + "VPUNPCKHDQZ128rm(b?)(k?)(z?)", + "VPUNPCKHDQrm", + "VPUNPCKHQDQZ128rm(b?)(k?)(z?)", + "VPUNPCKHQDQrm", + "VPUNPCKHWDZ128rm(b?)(k?)(z?)", + "VPUNPCKHWDrm", + "VPUNPCKLBWZ128rm(b?)(k?)(z?)", + "VPUNPCKLBWrm", + "VPUNPCKLDQZ128rm(b?)(k?)(z?)", + "VPUNPCKLDQrm", + "VPUNPCKLQDQZ128rm(b?)(k?)(z?)", + "VPUNPCKLQDQrm", + "VPUNPCKLWDZ128rm(b?)(k?)(z?)", + "VPUNPCKLWDrm", + "VSHUFPDZ128rm(b?)i(k?)(z?)", + "VSHUFPDrmi", + "VSHUFPSZ128rm(b?)i(k?)(z?)", + "VSHUFPSrmi", + "VUNPCKHPDZ128rm(b?)(k?)(z?)", + "VUNPCKHPDrm", + "VUNPCKHPSZ128rm(b?)(k?)(z?)", + "VUNPCKHPSrm", + "VUNPCKLPDZ128rm(b?)(k?)(z?)", + "VUNPCKLPDrm", + "VUNPCKLPSZ128rm(b?)(k?)(z?)", + "VUNPCKLPSrm")>; def SKXWriteResGroup93 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTDQ2PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTDQ2PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2DQYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2DQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2DQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2PSYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2UDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPD2UDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPH2PSYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPH2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPH2PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PDYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PHYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PHZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2PHZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2QQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2QQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2UQQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTPS2UQQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTQQ2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTQQ2PSZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPD2DQYrr")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPD2DQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPD2DQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPD2UDQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPD2UDQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPS2QQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPS2QQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPS2UQQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTTPS2UQQZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTUDQ2PDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTUDQ2PDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTUQQ2PSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup93], (instregex "VCVTUQQ2PSZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup93], (instregex "VCVTDQ2PDZ256rr(b?)(k?)(z?)", + "VCVTDQ2PDZrr(b?)(k?)(z?)", + "VCVTPD2DQYrr", + "VCVTPD2DQZ256rr(b?)(k?)(z?)", + "VCVTPD2DQZrr(b?)(k?)(z?)", + "VCVTPD2PSYrr", + "VCVTPD2PSZ256rr(b?)(k?)(z?)", + "VCVTPD2PSZrr(b?)(k?)(z?)", + "VCVTPD2UDQZ256rr(b?)(k?)(z?)", + "VCVTPD2UDQZrr(b?)(k?)(z?)", + "VCVTPH2PSYrr", + "VCVTPH2PSZ256rr(b?)(k?)(z?)", + "VCVTPH2PSZrr(b?)(k?)(z?)", + "VCVTPS2PDYrr", + "VCVTPS2PDZ256rr(b?)(k?)(z?)", + "VCVTPS2PDZrr(b?)(k?)(z?)", + "VCVTPS2PHYrr", + "VCVTPS2PHZ256rr(b?)(k?)(z?)", + "VCVTPS2PHZrr(b?)(k?)(z?)", + "VCVTPS2QQZ256rr(b?)(k?)(z?)", + "VCVTPS2QQZrr(b?)(k?)(z?)", + "VCVTPS2UQQZ256rr(b?)(k?)(z?)", + "VCVTPS2UQQZrr(b?)(k?)(z?)", + "VCVTQQ2PSZ256rr(b?)(k?)(z?)", + "VCVTQQ2PSZrr(b?)(k?)(z?)", + "VCVTTPD2DQYrr", + "VCVTTPD2DQZ256rr(b?)(k?)(z?)", + "VCVTTPD2DQZrr(b?)(k?)(z?)", + "VCVTTPD2UDQZ256rr(b?)(k?)(z?)", + "VCVTTPD2UDQZrr(b?)(k?)(z?)", + "VCVTTPS2QQZ256rr(b?)(k?)(z?)", + "VCVTTPS2QQZrr(b?)(k?)(z?)", + "VCVTTPS2UQQZ256rr(b?)(k?)(z?)", + "VCVTTPS2UQQZrr(b?)(k?)(z?)", + "VCVTUDQ2PDZ256rr(b?)(k?)(z?)", + "VCVTUDQ2PDZrr(b?)(k?)(z?)", + "VCVTUQQ2PSZ256rr(b?)(k?)(z?)", + "VCVTUQQ2PSZrr(b?)(k?)(z?)")>; def SKXWriteResGroup94 : SchedWriteRes<[SKXPort01,SKXPort23]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup94], (instregex "PABSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PABSDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PABSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PADDSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PADDSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PADDUSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PADDUSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PAVGBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PAVGWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPEQBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPEQDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPEQQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPEQWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPGTBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPGTDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PCMPGTWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAXSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAX(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAXSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAXUBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAXUDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMAXUWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMINSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMIN(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMINSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMINUBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMINUDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PMINUWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSIGNBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSIGNDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSIGNWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSLLDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSLLQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSLLWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSRADrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSRAWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSRLDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSRLQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSRLWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSUBSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSUBSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSUBUSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "PSUBUSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPABSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDUSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDUSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDUSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPADDUSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPAVGBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPAVGBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPAVGWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPAVGWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPEQBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPEQDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPEQQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPEQWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPGTBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPGTDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPCMPGTWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAX(C?)SDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAX(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMAXUWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMIN(C?)SDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMIN(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPMINUWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPROLDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPROLQZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPROLVDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPROLVQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPRORDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPRORQZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPRORVDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPRORVQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSIGNBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSIGNDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSIGNWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLQZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLVDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLVDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLVQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLVQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLVWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLWZ128mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSLLWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRADZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRADZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRADrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAQZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAVDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAVDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAVQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAVWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAWZ128mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRAWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLDZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLQZ128m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLVDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLVDrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLVQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLVQrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLVWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLWZ128mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSRLWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBSWrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBUSBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBUSBrm")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBUSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup94], (instregex "VPSUBUSWrm")>; +def: InstRW<[SKXWriteResGroup94], (instregex "PABSBrm", + "PABSDrm", + "PABSWrm", + "PADDSBrm", + "PADDSWrm", + "PADDUSBrm", + "PADDUSWrm", + "PAVGBrm", + "PAVGWrm", + "PCMPEQBrm", + "PCMPEQDrm", + "PCMPEQQrm", + "PCMPEQWrm", + "PCMPGTBrm", + "PCMPGTDrm", + "PCMPGTWrm", + "PMAXSBrm", + "PMAX(C?)SDrm", + "PMAXSWrm", + "PMAXUBrm", + "PMAXUDrm", + "PMAXUWrm", + "PMINSBrm", + "PMIN(C?)SDrm", + "PMINSWrm", + "PMINUBrm", + "PMINUDrm", + "PMINUWrm", + "PSIGNBrm", + "PSIGNDrm", + "PSIGNWrm", + "PSLLDrm", + "PSLLQrm", + "PSLLWrm", + "PSRADrm", + "PSRAWrm", + "PSRLDrm", + "PSRLQrm", + "PSRLWrm", + "PSUBSBrm", + "PSUBSWrm", + "PSUBUSBrm", + "PSUBUSWrm", + "VPABSBZ128rm(b?)(k?)(z?)", + "VPABSBrm", + "VPABSDZ128rm(b?)(k?)(z?)", + "VPABSDrm", + "VPABSQZ128rm(b?)(k?)(z?)", + "VPABSWZ128rm(b?)(k?)(z?)", + "VPABSWrm", + "VPADDSBZ128rm(b?)(k?)(z?)", + "VPADDSBrm", + "VPADDSWZ128rm(b?)(k?)(z?)", + "VPADDSWrm", + "VPADDUSBZ128rm(b?)(k?)(z?)", + "VPADDUSBrm", + "VPADDUSWZ128rm(b?)(k?)(z?)", + "VPADDUSWrm", + "VPAVGBZ128rm(b?)(k?)(z?)", + "VPAVGBrm", + "VPAVGWZ128rm(b?)(k?)(z?)", + "VPAVGWrm", + "VPCMPEQBrm", + "VPCMPEQDrm", + "VPCMPEQQrm", + "VPCMPEQWrm", + "VPCMPGTBrm", + "VPCMPGTDrm", + "VPCMPGTWrm", + "VPMAXSBZ128rm(b?)(k?)(z?)", + "VPMAXSBrm", + "VPMAX(C?)SDZ128rm(b?)(k?)(z?)", + "VPMAX(C?)SDrm", + "VPMAXSWZ128rm(b?)(k?)(z?)", + "VPMAXSWrm", + "VPMAXUBZ128rm(b?)(k?)(z?)", + "VPMAXUBrm", + "VPMAXUDZ128rm(b?)(k?)(z?)", + "VPMAXUDrm", + "VPMAXUWZ128rm(b?)(k?)(z?)", + "VPMAXUWrm", + "VPMINSBZ128rm(b?)(k?)(z?)", + "VPMINSBrm", + "VPMIN(C?)SDZ128rm(b?)(k?)(z?)", + "VPMIN(C?)SDrm", + "VPMINSWZ128rm(b?)(k?)(z?)", + "VPMINSWrm", + "VPMINUBZ128rm(b?)(k?)(z?)", + "VPMINUBrm", + "VPMINUDZ128rm(b?)(k?)(z?)", + "VPMINUDrm", + "VPMINUWZ128rm(b?)(k?)(z?)", + "VPMINUWrm", + "VPROLDZ128m(b?)i(k?)(z?)", + "VPROLQZ128m(b?)i(k?)(z?)", + "VPROLVDZ128rm(b?)(k?)(z?)", + "VPROLVQZ128rm(b?)(k?)(z?)", + "VPRORDZ128m(b?)i(k?)(z?)", + "VPRORQZ128m(b?)i(k?)(z?)", + "VPRORVDZ128rm(b?)(k?)(z?)", + "VPRORVQZ128rm(b?)(k?)(z?)", + "VPSIGNBrm", + "VPSIGNDrm", + "VPSIGNWrm", + "VPSLLDZ128m(b?)i(k?)(z?)", + "VPSLLDZ128rm(b?)(k?)(z?)", + "VPSLLDrm", + "VPSLLQZ128m(b?)i(k?)(z?)", + "VPSLLQZ128rm(b?)(k?)(z?)", + "VPSLLQrm", + "VPSLLVDZ128rm(b?)(k?)(z?)", + "VPSLLVDrm", + "VPSLLVQZ128rm(b?)(k?)(z?)", + "VPSLLVQrm", + "VPSLLVWZ128rm(b?)(k?)(z?)", + "VPSLLWZ128mi(b?)(k?)(z?)", + "VPSLLWZ128rm(b?)(k?)(z?)", + "VPSLLWrm", + "VPSRADZ128m(b?)i(k?)(z?)", + "VPSRADZ128rm(b?)(k?)(z?)", + "VPSRADrm", + "VPSRAQZ128m(b?)i(k?)(z?)", + "VPSRAQZ128rm(b?)(k?)(z?)", + "VPSRAVDZ128rm(b?)(k?)(z?)", + "VPSRAVDrm", + "VPSRAVQZ128rm(b?)(k?)(z?)", + "VPSRAVWZ128rm(b?)(k?)(z?)", + "VPSRAWZ128mi(b?)(k?)(z?)", + "VPSRAWZ128rm(b?)(k?)(z?)", + "VPSRAWrm", + "VPSRLDZ128m(b?)i(k?)(z?)", + "VPSRLDZ128rm(b?)(k?)(z?)", + "VPSRLDrm", + "VPSRLQZ128m(b?)i(k?)(z?)", + "VPSRLQZ128rm(b?)(k?)(z?)", + "VPSRLQrm", + "VPSRLVDZ128rm(b?)(k?)(z?)", + "VPSRLVDrm", + "VPSRLVQZ128rm(b?)(k?)(z?)", + "VPSRLVQrm", + "VPSRLVWZ128rm(b?)(k?)(z?)", + "VPSRLWZ128mi(b?)(k?)(z?)", + "VPSRLWZ128rm(b?)(k?)(z?)", + "VPSRLWrm", + "VPSUBSBZ128rm(b?)(k?)(z?)", + "VPSUBSBrm", + "VPSUBSWZ128rm(b?)(k?)(z?)", + "VPSUBSWrm", + "VPSUBUSBZ128rm(b?)(k?)(z?)", + "VPSUBUSBrm", + "VPSUBUSWZ128rm(b?)(k?)(z?)", + "VPSUBUSWrm")>; def SKXWriteResGroup95 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 7; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup95], (instregex "ANDNPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "ANDNPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "ANDPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "ANDPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "BLENDPDrmi")>; -def: InstRW<[SKXWriteResGroup95], (instregex "BLENDPSrmi")>; -def: InstRW<[SKXWriteResGroup95], (instregex "ORPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "ORPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PADDBrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PADDDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PADDQrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PADDWrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PANDNrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PANDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PORrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PSUBBrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PSUBDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PSUBQrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PSUBWrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "PXORrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDNPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDNPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDNPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDNPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VANDPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBLENDMPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBLENDMPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBLENDPDrmi")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBLENDPSrmi")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBROADCASTI32X2Z128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VBROADCASTSSZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VINSERTF128rm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VINSERTI128rm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMASKMOVPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMASKMOVPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVAPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVAPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDDUPZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQA32Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQA64Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQU16Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQU32Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQU64Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVDQU8Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVNTDQAZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVSHDUPZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVSLDUPZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVUPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VMOVUPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VORPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VORPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VORPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VORPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDBrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDQrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPADDWrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDNDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDNQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDNrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPANDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBLENDDrmi")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBLENDMBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBLENDMDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBLENDMQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBLENDMWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBROADCASTDZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPBROADCASTQZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPMASKMOVDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPMASKMOVQrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPORDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPORQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPORrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBBrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBQrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPSUBWrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPTERNLOGDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPTERNLOGQZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPXORDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPXORQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VPXORrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VXORPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VXORPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VXORPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup95], (instregex "VXORPSrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "XORPDrm")>; -def: InstRW<[SKXWriteResGroup95], (instregex "XORPSrm")>; +def: InstRW<[SKXWriteResGroup95], (instregex "ANDNPDrm", + "ANDNPSrm", + "ANDPDrm", + "ANDPSrm", + "BLENDPDrmi", + "BLENDPSrmi", + "ORPDrm", + "ORPSrm", + "PADDBrm", + "PADDDrm", + "PADDQrm", + "PADDWrm", + "PANDNrm", + "PANDrm", + "PORrm", + "PSUBBrm", + "PSUBDrm", + "PSUBQrm", + "PSUBWrm", + "PXORrm", + "VANDNPDZ128rm(b?)(k?)(z?)", + "VANDNPDrm", + "VANDNPSZ128rm(b?)(k?)(z?)", + "VANDNPSrm", + "VANDPDZ128rm(b?)(k?)(z?)", + "VANDPDrm", + "VANDPSZ128rm(b?)(k?)(z?)", + "VANDPSrm", + "VBLENDMPDZ128rm(b?)(k?)(z?)", + "VBLENDMPSZ128rm(b?)(k?)(z?)", + "VBLENDPDrmi", + "VBLENDPSrmi", + "VBROADCASTI32X2Z128m(b?)(k?)(z?)", + "VBROADCASTSSZ128m(b?)(k?)(z?)", + "VINSERTF128rm", + "VINSERTI128rm", + "VMASKMOVPDrm", + "VMASKMOVPSrm", + "VMOVAPDZ128rm(b?)(k?)(z?)", + "VMOVAPSZ128rm(b?)(k?)(z?)", + "VMOVDDUPZ128rm(b?)(k?)(z?)", + "VMOVDQA32Z128rm(b?)(k?)(z?)", + "VMOVDQA64Z128rm(b?)(k?)(z?)", + "VMOVDQU16Z128rm(b?)(k?)(z?)", + "VMOVDQU32Z128rm(b?)(k?)(z?)", + "VMOVDQU64Z128rm(b?)(k?)(z?)", + "VMOVDQU8Z128rm(b?)(k?)(z?)", + "VMOVNTDQAZ128rm(b?)(k?)(z?)", + "VMOVSHDUPZ128rm(b?)(k?)(z?)", + "VMOVSLDUPZ128rm(b?)(k?)(z?)", + "VMOVUPDZ128rm(b?)(k?)(z?)", + "VMOVUPSZ128rm(b?)(k?)(z?)", + "VORPDZ128rm(b?)(k?)(z?)", + "VORPDrm", + "VORPSZ128rm(b?)(k?)(z?)", + "VORPSrm", + "VPADDBZ128rm(b?)(k?)(z?)", + "VPADDBrm", + "VPADDDZ128rm(b?)(k?)(z?)", + "VPADDDrm", + "VPADDQZ128rm(b?)(k?)(z?)", + "VPADDQrm", + "VPADDWZ128rm(b?)(k?)(z?)", + "VPADDWrm", + "VPANDDZ128rm(b?)(k?)(z?)", + "VPANDNDZ128rm(b?)(k?)(z?)", + "VPANDNQZ128rm(b?)(k?)(z?)", + "VPANDNrm", + "VPANDQZ128rm(b?)(k?)(z?)", + "VPANDrm", + "VPBLENDDrmi", + "VPBLENDMBZ128rm(b?)(k?)(z?)", + "VPBLENDMDZ128rm(b?)(k?)(z?)", + "VPBLENDMQZ128rm(b?)(k?)(z?)", + "VPBLENDMWZ128rm(b?)(k?)(z?)", + "VPBROADCASTDZ128m(b?)(k?)(z?)", + "VPBROADCASTQZ128m(b?)(k?)(z?)", + "VPMASKMOVDrm", + "VPMASKMOVQrm", + "VPORDZ128rm(b?)(k?)(z?)", + "VPORQZ128rm(b?)(k?)(z?)", + "VPORrm", + "VPSUBBZ128rm(b?)(k?)(z?)", + "VPSUBBrm", + "VPSUBDZ128rm(b?)(k?)(z?)", + "VPSUBDrm", + "VPSUBQZ128rm(b?)(k?)(z?)", + "VPSUBQrm", + "VPSUBWZ128rm(b?)(k?)(z?)", + "VPSUBWrm", + "VPTERNLOGDZ128rm(b?)i(k?)(z?)", + "VPTERNLOGQZ128rm(b?)i(k?)(z?)", + "VPXORDZ128rm(b?)(k?)(z?)", + "VPXORQZ128rm(b?)(k?)(z?)", + "VPXORrm", + "VXORPDZ128rm(b?)(k?)(z?)", + "VXORPDrm", + "VXORPSZ128rm(b?)(k?)(z?)", + "VXORPSrm", + "XORPDrm", + "XORPSrm")>; def SKXWriteResGroup96 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup96], (instregex "MMX_PACKSSDWirm")>; -def: InstRW<[SKXWriteResGroup96], (instregex "MMX_PACKSSWBirm")>; -def: InstRW<[SKXWriteResGroup96], (instregex "MMX_PACKUSWBirm")>; +def: InstRW<[SKXWriteResGroup96], (instregex "MMX_PACKSSDWirm", + "MMX_PACKSSWBirm", + "MMX_PACKUSWBirm")>; def SKXWriteResGroup97 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMI2W128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMI2W256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMI2Wrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMT2W128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMT2W256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup97], (instregex "VPERMT2Wrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup97], (instregex "VPERMI2W128rr(b?)(k?)(z?)", + "VPERMI2W256rr(b?)(k?)(z?)", + "VPERMI2Wrr(b?)(k?)(z?)", + "VPERMT2W128rr(b?)(k?)(z?)", + "VPERMT2W256rr(b?)(k?)(z?)", + "VPERMT2Wrr(b?)(k?)(z?)")>; def SKXWriteResGroup98 : SchedWriteRes<[SKXPort23,SKXPort06]> { let Latency = 7; @@ -3709,25 +3706,25 @@ def SKXWriteResGroup99 : SchedWriteRes<[SKXPort23,SKXPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup99], (instregex "LEAVE64")>; -def: InstRW<[SKXWriteResGroup99], (instregex "SCASB")>; -def: InstRW<[SKXWriteResGroup99], (instregex "SCASL")>; -def: InstRW<[SKXWriteResGroup99], (instregex "SCASQ")>; -def: InstRW<[SKXWriteResGroup99], (instregex "SCASW")>; +def: InstRW<[SKXWriteResGroup99], (instregex "LEAVE64", + "SCASB", + "SCASL", + "SCASQ", + "SCASW")>; def SKXWriteResGroup100 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort015]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup100], (instregex "CVTTSS2SI64rr")>; -def: InstRW<[SKXWriteResGroup100], (instregex "CVTTSS2SIrr")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTSS2USI64Zrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTTSS2SI64Zrr(b?)")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTTSS2SI64rr")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTTSS2SIZrr(b?)")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTTSS2SIrr")>; -def: InstRW<[SKXWriteResGroup100], (instregex "VCVTTSS2USI64Zrr(b?)")>; +def: InstRW<[SKXWriteResGroup100], (instregex "CVTTSS2SI64rr", + "CVTTSS2SIrr", + "VCVTSS2USI64Zrr(b?)(k?)(z?)", + "VCVTTSS2SI64Zrr(b?)", + "VCVTTSS2SI64rr", + "VCVTTSS2SIZrr(b?)", + "VCVTTSS2SIrr", + "VCVTTSS2USI64Zrr(b?)")>; def SKXWriteResGroup101 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort05]> { let Latency = 7; @@ -3741,26 +3738,25 @@ def SKXWriteResGroup102 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort0156]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup102], (instregex "LDMXCSR")>; -def: InstRW<[SKXWriteResGroup102], (instregex "VLDMXCSR")>; +def: InstRW<[SKXWriteResGroup102], (instregex "(V?)LDMXCSR")>; def SKXWriteResGroup103 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort0156]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup103], (instregex "KMOVBkm")>; -def: InstRW<[SKXWriteResGroup103], (instregex "KMOVDkm")>; -def: InstRW<[SKXWriteResGroup103], (instregex "KMOVQkm")>; -def: InstRW<[SKXWriteResGroup103], (instregex "KMOVWkm")>; +def: InstRW<[SKXWriteResGroup103], (instregex "KMOVBkm", + "KMOVDkm", + "KMOVQkm", + "KMOVWkm")>; def SKXWriteResGroup104 : SchedWriteRes<[SKXPort6,SKXPort23,SKXPort0156]> { let Latency = 7; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup104], (instregex "LRETQ")>; -def: InstRW<[SKXWriteResGroup104], (instregex "RETQ")>; +def: InstRW<[SKXWriteResGroup104], (instregex "LRETQ", + "RETQ")>; def SKXWriteResGroup105 : SchedWriteRes<[SKXPort23,SKXPort06,SKXPort15]> { let Latency = 7; @@ -3774,28 +3770,28 @@ def SKXWriteResGroup106 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237]> { let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPSZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPSZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPSZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSDZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSDZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSDZmr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSQZ128mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSQZ256mr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup106], (instregex "VPCOMPRESSQZmr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup106], (instregex "VCOMPRESSPDZ128mr(b?)(k?)(z?)", + "VCOMPRESSPDZ256mr(b?)(k?)(z?)", + "VCOMPRESSPDZmr(b?)(k?)(z?)", + "VCOMPRESSPSZ128mr(b?)(k?)(z?)", + "VCOMPRESSPSZ256mr(b?)(k?)(z?)", + "VCOMPRESSPSZmr(b?)(k?)(z?)", + "VPCOMPRESSDZ128mr(b?)(k?)(z?)", + "VPCOMPRESSDZ256mr(b?)(k?)(z?)", + "VPCOMPRESSDZmr(b?)(k?)(z?)", + "VPCOMPRESSQZ128mr(b?)(k?)(z?)", + "VPCOMPRESSQZ256mr(b?)(k?)(z?)", + "VPCOMPRESSQZmr(b?)(k?)(z?)")>; def SKXWriteResGroup107 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort06]> { let Latency = 7; let NumMicroOps = 5; let ResourceCycles = [1,1,1,2]; } -def: InstRW<[SKXWriteResGroup107], (instregex "ROL(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup107], (instregex "ROL(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup107], (instregex "ROR(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup107], (instregex "ROR(8|16|32|64)mi")>; +def: InstRW<[SKXWriteResGroup107], (instregex "ROL(8|16|32|64)m1", + "ROL(8|16|32|64)mi", + "ROR(8|16|32|64)m1", + "ROR(8|16|32|64)mi")>; def SKXWriteResGroup108 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort0156]> { let Latency = 7; @@ -3809,8 +3805,8 @@ def SKXWriteResGroup109 : SchedWriteRes<[SKXPort4,SKXPort6,SKXPort23,SKXPort237, let NumMicroOps = 5; let ResourceCycles = [1,1,1,1,1]; } -def: InstRW<[SKXWriteResGroup109], (instregex "CALL(16|32|64)m")>; -def: InstRW<[SKXWriteResGroup109], (instregex "FARCALL64")>; +def: InstRW<[SKXWriteResGroup109], (instregex "CALL(16|32|64)m", + "FARCALL64")>; def SKXWriteResGroup110 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort237,SKXPort0156]> { let Latency = 7; @@ -3861,70 +3857,67 @@ def SKXWriteResGroup115 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup115], (instregex "AESIMCrr")>; -def: InstRW<[SKXWriteResGroup115], (instregex "VAESIMCrr")>; +def: InstRW<[SKXWriteResGroup115], (instregex "(V?)AESIMCrr")>; def SKXWriteResGroup116 : SchedWriteRes<[SKXPort015]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup116], (instregex "ROUNDPDr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "ROUNDPSr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "ROUNDSDr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "ROUNDSSr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPDZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPDZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPDZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPSZ128rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPSZ256rri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALEPSZrri(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALESDr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VRNDSCALESSr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDPDr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDPSr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDSDr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDSSr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDYPDr")>; -def: InstRW<[SKXWriteResGroup116], (instregex "VROUNDYPSr")>; +def: InstRW<[SKXWriteResGroup116], (instregex "ROUNDPDr", + "ROUNDPSr", + "ROUNDSDr", + "ROUNDSSr", + "VRNDSCALEPDZ128rri(b?)(k?)(z?)", + "VRNDSCALEPDZ256rri(b?)(k?)(z?)", + "VRNDSCALEPDZrri(b?)(k?)(z?)", + "VRNDSCALEPSZ128rri(b?)(k?)(z?)", + "VRNDSCALEPSZ256rri(b?)(k?)(z?)", + "VRNDSCALEPSZrri(b?)(k?)(z?)", + "VRNDSCALESDr(b?)(k?)(z?)", + "VRNDSCALESSr(b?)(k?)(z?)", + "VROUNDPDr", + "VROUNDPSr", + "VROUNDSDr", + "VROUNDSSr", + "VROUNDYPDr", + "VROUNDYPSr")>; def SKXWriteResGroup116_2 : SchedWriteRes<[SKXPort015]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [2]; } -def: InstRW<[SKXWriteResGroup116_2], (instregex "PMULLDrr")>; -def: InstRW<[SKXWriteResGroup116_2], (instregex "VPMULLDYrr")>; -def: InstRW<[SKXWriteResGroup116_2], (instregex "VPMULLDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116_2], (instregex "VPMULLDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116_2], (instregex "VPMULLDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup116_2], (instregex "VPMULLDrr")>; +def: InstRW<[SKXWriteResGroup116_2], (instregex "PMULLDrr", + "VPMULLDYrr", + "VPMULLDZ128rr(b?)(k?)(z?)", + "VPMULLDZ256rr(b?)(k?)(z?)", + "VPMULLDZrr(b?)(k?)(z?)", + "VPMULLDrr")>; def SKXWriteResGroup117 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup117], (instregex "VTESTPDrm")>; -def: InstRW<[SKXWriteResGroup117], (instregex "VTESTPSrm")>; +def: InstRW<[SKXWriteResGroup117], (instregex "VTESTPDrm", + "VTESTPSrm")>; def SKXWriteResGroup118 : SchedWriteRes<[SKXPort1,SKXPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup118], (instregex "BSF(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instregex "BSR(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instrs IMUL64m)>; +def: InstRW<[SKXWriteResGroup118], (instrs IMUL64m, MUL64m)>; def: InstRW<[SKXWriteResGroup118], (instrs IMUL32rm, IMUL32rmi, IMUL32rmi8, IMUL64rm, IMUL64rmi32, IMUL64rmi8)>; -def: InstRW<[SKXWriteResGroup118], (instrs IMUL8m)>; -def: InstRW<[SKXWriteResGroup118], (instregex "LZCNT(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instrs MUL64m)>; -def: InstRW<[SKXWriteResGroup118], (instrs MUL8m)>; -def: InstRW<[SKXWriteResGroup118], (instregex "PDEP(32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instregex "PEXT(32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instregex "POPCNT(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup118], (instregex "TZCNT(16|32|64)rm")>; +def: InstRW<[SKXWriteResGroup118], (instrs IMUL8m, MUL8m)>; +def: InstRW<[SKXWriteResGroup118], (instregex "BSF(16|32|64)rm", + "BSR(16|32|64)rm", + "LZCNT(16|32|64)rm", + "PDEP(32|64)rm", + "PEXT(32|64)rm", + "POPCNT(16|32|64)rm", + "TZCNT(16|32|64)rm")>; def SKXWriteResGroup118_16_1 : SchedWriteRes<[SKXPort1, SKXPort0156, SKXPort23]> { let Latency = 8; @@ -3937,489 +3930,487 @@ def SKXWriteResGroup118_16_2 : SchedWriteRes<[SKXPort1, SKXPort0156, SKXPort23]> let Latency = 8; let NumMicroOps = 5; } -def: InstRW<[SKXWriteResGroup118_16_2], (instrs IMUL16m)>; -def: InstRW<[SKXWriteResGroup118_16_2], (instrs MUL16m)>; +def: InstRW<[SKXWriteResGroup118_16_2], (instrs IMUL16m, MUL16m)>; def SKXWriteResGroup118_32 : SchedWriteRes<[SKXPort1, SKXPort0156, SKXPort23]> { let Latency = 8; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup118_32], (instrs IMUL32m)>; -def: InstRW<[SKXWriteResGroup118_32], (instrs MUL32m)>; +def: InstRW<[SKXWriteResGroup118_32], (instrs IMUL32m, MUL32m)>; def SKXWriteResGroup119 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup119], (instregex "FCOM32m")>; -def: InstRW<[SKXWriteResGroup119], (instregex "FCOM64m")>; -def: InstRW<[SKXWriteResGroup119], (instregex "FCOMP32m")>; -def: InstRW<[SKXWriteResGroup119], (instregex "FCOMP64m")>; -def: InstRW<[SKXWriteResGroup119], (instregex "MMX_PSADBWirm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VFPCLASSSDrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSDWYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSDWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSDWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSWBYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSWBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKSSWBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSDWYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSDWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSDWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSWBYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSWBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPACKUSWBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPALIGNRYrmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPALIGNRZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPALIGNRZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBLENDWYrmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTBYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTBZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTBZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTWYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTWZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPBROADCASTWZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDYmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSYmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPERMILPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPMOVSXBDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPMOVSXBQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPMOVSXWQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFBYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFDYmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFHWYmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFHWZ256mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFHWZmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFLWYmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFLWZ256mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSHUFLWZmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSLLDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSLLDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSRLDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPSRLDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHBWYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHBWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHDQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHQDQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHQDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHQDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHWDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHWDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKHWDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLBWYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLBWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLDQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLQDQYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLQDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLQDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLWDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLWDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VPUNPCKLWDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPDYrmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPSYrmi")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VSHUFPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPSYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKHPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPDYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPSYrm")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup119], (instregex "VUNPCKLPSZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup119], (instregex "FCOM32m", + "FCOM64m", + "FCOMP32m", + "FCOMP64m", + "MMX_PSADBWirm", + "VFPCLASSSDrm(b?)(k?)(z?)", + "VPACKSSDWYrm", + "VPACKSSDWZ256rm(b?)(k?)(z?)", + "VPACKSSDWZrm(b?)(k?)(z?)", + "VPACKSSWBYrm", + "VPACKSSWBZ256rm(b?)(k?)(z?)", + "VPACKSSWBZrm(b?)(k?)(z?)", + "VPACKUSDWYrm", + "VPACKUSDWZ256rm(b?)(k?)(z?)", + "VPACKUSDWZrm(b?)(k?)(z?)", + "VPACKUSWBYrm", + "VPACKUSWBZ256rm(b?)(k?)(z?)", + "VPACKUSWBZrm(b?)(k?)(z?)", + "VPALIGNRYrmi", + "VPALIGNRZ256rmi(b?)(k?)(z?)", + "VPALIGNRZrmi(b?)(k?)(z?)", + "VPBLENDWYrmi", + "VPBROADCASTBYrm", + "VPBROADCASTBZ256m(b?)(k?)(z?)", + "VPBROADCASTBZm(b?)(k?)(z?)", + "VPBROADCASTWYrm", + "VPBROADCASTWZ256m(b?)(k?)(z?)", + "VPBROADCASTWZm(b?)(k?)(z?)", + "VPERMILPDYmi", + "VPERMILPDYrm", + "VPERMILPDZ256m(b?)i(k?)(z?)", + "VPERMILPDZ256rm(b?)(k?)(z?)", + "VPERMILPDZm(b?)i(k?)(z?)", + "VPERMILPDZrm(b?)(k?)(z?)", + "VPERMILPSYmi", + "VPERMILPSYrm", + "VPERMILPSZ256m(b?)i(k?)(z?)", + "VPERMILPSZ256rm(b?)(k?)(z?)", + "VPERMILPSZm(b?)i(k?)(z?)", + "VPERMILPSZrm(b?)(k?)(z?)", + "VPMOVSXBDYrm", + "VPMOVSXBQYrm", + "VPMOVSXWQYrm", + "VPSHUFBYrm", + "VPSHUFBZ256rm(b?)(k?)(z?)", + "VPSHUFBZrm(b?)(k?)(z?)", + "VPSHUFDYmi", + "VPSHUFDZ256m(b?)i(k?)(z?)", + "VPSHUFDZm(b?)i(k?)(z?)", + "VPSHUFHWYmi", + "VPSHUFHWZ256mi(b?)(k?)(z?)", + "VPSHUFHWZmi(b?)(k?)(z?)", + "VPSHUFLWYmi", + "VPSHUFLWZ256mi(b?)(k?)(z?)", + "VPSHUFLWZmi(b?)(k?)(z?)", + "VPSLLDQZ256rm(b?)(k?)(z?)", + "VPSLLDQZrm(b?)(k?)(z?)", + "VPSRLDQZ256rm(b?)(k?)(z?)", + "VPSRLDQZrm(b?)(k?)(z?)", + "VPUNPCKHBWYrm", + "VPUNPCKHBWZ256rm(b?)(k?)(z?)", + "VPUNPCKHBWZrm(b?)(k?)(z?)", + "VPUNPCKHDQYrm", + "VPUNPCKHDQZ256rm(b?)(k?)(z?)", + "VPUNPCKHDQZrm(b?)(k?)(z?)", + "VPUNPCKHQDQYrm", + "VPUNPCKHQDQZ256rm(b?)(k?)(z?)", + "VPUNPCKHQDQZrm(b?)(k?)(z?)", + "VPUNPCKHWDYrm", + "VPUNPCKHWDZ256rm(b?)(k?)(z?)", + "VPUNPCKHWDZrm(b?)(k?)(z?)", + "VPUNPCKLBWYrm", + "VPUNPCKLBWZ256rm(b?)(k?)(z?)", + "VPUNPCKLBWZrm(b?)(k?)(z?)", + "VPUNPCKLDQYrm", + "VPUNPCKLDQZ256rm(b?)(k?)(z?)", + "VPUNPCKLDQZrm(b?)(k?)(z?)", + "VPUNPCKLQDQYrm", + "VPUNPCKLQDQZ256rm(b?)(k?)(z?)", + "VPUNPCKLQDQZrm(b?)(k?)(z?)", + "VPUNPCKLWDYrm", + "VPUNPCKLWDZ256rm(b?)(k?)(z?)", + "VPUNPCKLWDZrm(b?)(k?)(z?)", + "VSHUFPDYrmi", + "VSHUFPDZ256rm(b?)i(k?)(z?)", + "VSHUFPDZrm(b?)i(k?)(z?)", + "VSHUFPSYrmi", + "VSHUFPSZ256rm(b?)i(k?)(z?)", + "VSHUFPSZrm(b?)i(k?)(z?)", + "VUNPCKHPDYrm", + "VUNPCKHPDZ256rm(b?)(k?)(z?)", + "VUNPCKHPDZrm(b?)(k?)(z?)", + "VUNPCKHPSYrm", + "VUNPCKHPSZ256rm(b?)(k?)(z?)", + "VUNPCKHPSZrm(b?)(k?)(z?)", + "VUNPCKLPDYrm", + "VUNPCKLPDZ256rm(b?)(k?)(z?)", + "VUNPCKLPDZrm(b?)(k?)(z?)", + "VUNPCKLPSYrm", + "VUNPCKLPSZ256rm(b?)(k?)(z?)", + "VUNPCKLPSZrm(b?)(k?)(z?)")>; def SKXWriteResGroup120 : SchedWriteRes<[SKXPort01,SKXPort23]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPABSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPADDUSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPAVGWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPEQBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPEQDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPEQQYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPEQWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPGTBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPGTDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPCMPGTWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAX(C?)SDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAX(C?)SDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAX(C?)SDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMAXUWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMIN(C?)SDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMIN(C?)SDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMIN(C?)SDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPMINUWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLVDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLVDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLVQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPROLVQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORVDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORVDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORVQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPRORVQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSIGNBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSIGNDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSIGNWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLQYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVQYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLVWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLWZ256mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLWZmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSLLWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRADYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRADZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRADZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRADZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRADZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAVWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAWZ256mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAWZmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRAWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLQYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVDYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVQYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLVWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLWZ256mi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLWZmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSRLWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSBYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSWYrm")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup120], (instregex "VPSUBUSWZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup120], (instregex "VPABSBYrm", + "VPABSBZ256rm(b?)(k?)(z?)", + "VPABSBZrm(b?)(k?)(z?)", + "VPABSDYrm", + "VPABSDZ256rm(b?)(k?)(z?)", + "VPABSDZrm(b?)(k?)(z?)", + "VPABSQZ256rm(b?)(k?)(z?)", + "VPABSQZrm(b?)(k?)(z?)", + "VPABSWYrm", + "VPABSWZ256rm(b?)(k?)(z?)", + "VPABSWZrm(b?)(k?)(z?)", + "VPADDSBYrm", + "VPADDSBZ256rm(b?)(k?)(z?)", + "VPADDSBZrm(b?)(k?)(z?)", + "VPADDSWYrm", + "VPADDSWZ256rm(b?)(k?)(z?)", + "VPADDSWZrm(b?)(k?)(z?)", + "VPADDUSBYrm", + "VPADDUSBZ256rm(b?)(k?)(z?)", + "VPADDUSBZrm(b?)(k?)(z?)", + "VPADDUSWYrm", + "VPADDUSWZ256rm(b?)(k?)(z?)", + "VPADDUSWZrm(b?)(k?)(z?)", + "VPAVGBYrm", + "VPAVGBZ256rm(b?)(k?)(z?)", + "VPAVGBZrm(b?)(k?)(z?)", + "VPAVGWYrm", + "VPAVGWZ256rm(b?)(k?)(z?)", + "VPAVGWZrm(b?)(k?)(z?)", + "VPCMPEQBYrm", + "VPCMPEQDYrm", + "VPCMPEQQYrm", + "VPCMPEQWYrm", + "VPCMPGTBYrm", + "VPCMPGTDYrm", + "VPCMPGTWYrm", + "VPMAXSBYrm", + "VPMAXSBZ256rm(b?)(k?)(z?)", + "VPMAXSBZrm(b?)(k?)(z?)", + "VPMAX(C?)SDYrm", + "VPMAX(C?)SDZ256rm(b?)(k?)(z?)", + "VPMAX(C?)SDZrm(b?)(k?)(z?)", + "VPMAXSWYrm", + "VPMAXSWZ256rm(b?)(k?)(z?)", + "VPMAXSWZrm(b?)(k?)(z?)", + "VPMAXUBYrm", + "VPMAXUBZ256rm(b?)(k?)(z?)", + "VPMAXUBZrm(b?)(k?)(z?)", + "VPMAXUDYrm", + "VPMAXUDZ256rm(b?)(k?)(z?)", + "VPMAXUDZrm(b?)(k?)(z?)", + "VPMAXUWYrm", + "VPMAXUWZ256rm(b?)(k?)(z?)", + "VPMAXUWZrm(b?)(k?)(z?)", + "VPMINSBYrm", + "VPMINSBZ256rm(b?)(k?)(z?)", + "VPMINSBZrm(b?)(k?)(z?)", + "VPMIN(C?)SDYrm", + "VPMIN(C?)SDZ256rm(b?)(k?)(z?)", + "VPMIN(C?)SDZrm(b?)(k?)(z?)", + "VPMINSWYrm", + "VPMINSWZ256rm(b?)(k?)(z?)", + "VPMINSWZrm(b?)(k?)(z?)", + "VPMINUBYrm", + "VPMINUBZ256rm(b?)(k?)(z?)", + "VPMINUBZrm(b?)(k?)(z?)", + "VPMINUDYrm", + "VPMINUDZ256rm(b?)(k?)(z?)", + "VPMINUDZrm(b?)(k?)(z?)", + "VPMINUWYrm", + "VPMINUWZ256rm(b?)(k?)(z?)", + "VPMINUWZrm(b?)(k?)(z?)", + "VPROLDZ256m(b?)i(k?)(z?)", + "VPROLDZm(b?)i(k?)(z?)", + "VPROLQZ256m(b?)i(k?)(z?)", + "VPROLQZm(b?)i(k?)(z?)", + "VPROLVDZ256rm(b?)(k?)(z?)", + "VPROLVDZrm(b?)(k?)(z?)", + "VPROLVQZ256rm(b?)(k?)(z?)", + "VPROLVQZrm(b?)(k?)(z?)", + "VPRORDZ256m(b?)i(k?)(z?)", + "VPRORDZm(b?)i(k?)(z?)", + "VPRORQZ256m(b?)i(k?)(z?)", + "VPRORQZm(b?)i(k?)(z?)", + "VPRORVDZ256rm(b?)(k?)(z?)", + "VPRORVDZrm(b?)(k?)(z?)", + "VPRORVQZ256rm(b?)(k?)(z?)", + "VPRORVQZrm(b?)(k?)(z?)", + "VPSIGNBYrm", + "VPSIGNDYrm", + "VPSIGNWYrm", + "VPSLLDYrm", + "VPSLLDZ256m(b?)i(k?)(z?)", + "VPSLLDZ256rm(b?)(k?)(z?)", + "VPSLLDZm(b?)i(k?)(z?)", + "VPSLLDZrm(b?)(k?)(z?)", + "VPSLLQYrm", + "VPSLLQZ256m(b?)i(k?)(z?)", + "VPSLLQZ256rm(b?)(k?)(z?)", + "VPSLLQZm(b?)i(k?)(z?)", + "VPSLLQZrm(b?)(k?)(z?)", + "VPSLLVDYrm", + "VPSLLVDZ256rm(b?)(k?)(z?)", + "VPSLLVDZrm(b?)(k?)(z?)", + "VPSLLVQYrm", + "VPSLLVQZ256rm(b?)(k?)(z?)", + "VPSLLVQZrm(b?)(k?)(z?)", + "VPSLLVWZ256rm(b?)(k?)(z?)", + "VPSLLVWZrm(b?)(k?)(z?)", + "VPSLLWYrm", + "VPSLLWZ256mi(b?)(k?)(z?)", + "VPSLLWZ256rm(b?)(k?)(z?)", + "VPSLLWZmi(b?)(k?)(z?)", + "VPSLLWZrm(b?)(k?)(z?)", + "VPSRADYrm", + "VPSRADZ256m(b?)i(k?)(z?)", + "VPSRADZ256rm(b?)(k?)(z?)", + "VPSRADZm(b?)i(k?)(z?)", + "VPSRADZrm(b?)(k?)(z?)", + "VPSRAQZ256m(b?)i(k?)(z?)", + "VPSRAQZ256rm(b?)(k?)(z?)", + "VPSRAQZm(b?)i(k?)(z?)", + "VPSRAQZrm(b?)(k?)(z?)", + "VPSRAVDYrm", + "VPSRAVDZ256rm(b?)(k?)(z?)", + "VPSRAVDZrm(b?)(k?)(z?)", + "VPSRAVQZ256rm(b?)(k?)(z?)", + "VPSRAVQZrm(b?)(k?)(z?)", + "VPSRAVWZ256rm(b?)(k?)(z?)", + "VPSRAVWZrm(b?)(k?)(z?)", + "VPSRAWYrm", + "VPSRAWZ256mi(b?)(k?)(z?)", + "VPSRAWZ256rm(b?)(k?)(z?)", + "VPSRAWZmi(b?)(k?)(z?)", + "VPSRAWZrm(b?)(k?)(z?)", + "VPSRLDYrm", + "VPSRLDZ256m(b?)i(k?)(z?)", + "VPSRLDZ256rm(b?)(k?)(z?)", + "VPSRLDZm(b?)i(k?)(z?)", + "VPSRLDZrm(b?)(k?)(z?)", + "VPSRLQYrm", + "VPSRLQZ256m(b?)i(k?)(z?)", + "VPSRLQZ256rm(b?)(k?)(z?)", + "VPSRLQZm(b?)i(k?)(z?)", + "VPSRLQZrm(b?)(k?)(z?)", + "VPSRLVDYrm", + "VPSRLVDZ256rm(b?)(k?)(z?)", + "VPSRLVDZrm(b?)(k?)(z?)", + "VPSRLVQYrm", + "VPSRLVQZ256rm(b?)(k?)(z?)", + "VPSRLVQZrm(b?)(k?)(z?)", + "VPSRLVWZ256rm(b?)(k?)(z?)", + "VPSRLVWZrm(b?)(k?)(z?)", + "VPSRLWYrm", + "VPSRLWZ256mi(b?)(k?)(z?)", + "VPSRLWZ256rm(b?)(k?)(z?)", + "VPSRLWZmi(b?)(k?)(z?)", + "VPSRLWZrm(b?)(k?)(z?)", + "VPSUBSBYrm", + "VPSUBSBZ256rm(b?)(k?)(z?)", + "VPSUBSBZrm(b?)(k?)(z?)", + "VPSUBSWYrm", + "VPSUBSWZ256rm(b?)(k?)(z?)", + "VPSUBSWZrm(b?)(k?)(z?)", + "VPSUBUSBYrm", + "VPSUBUSBZ256rm(b?)(k?)(z?)", + "VPSUBUSBZrm(b?)(k?)(z?)", + "VPSUBUSWYrm", + "VPSUBUSWZ256rm(b?)(k?)(z?)", + "VPSUBUSWZrm(b?)(k?)(z?)")>; def SKXWriteResGroup121 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 8; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPSYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPSYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VANDPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDMPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDMPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDMPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDMPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDPDYrmi")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBLENDPSYrmi")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF32X2Z256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF32X2Zm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF32X4Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF32X4rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF32X8rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF64X2Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF64X2rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTF64X4rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI32X2Z256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI32X2Zm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI32X4Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI32X4rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI32X8rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI64X2Z128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI64X2rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTI64X4rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTSDZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTSDZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTSSZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VBROADCASTSSZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF32x4Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF32x4Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF32x8Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF64x2Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF64x2Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTF64x4Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI32x4Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI32x4Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI32x8Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI64x2Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI64x2Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VINSERTI64x4Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMASKMOVPDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMASKMOVPSYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVAPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVAPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVAPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVAPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDDUPZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDDUPZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQA32Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQA32Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQA64Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQA64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU16Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU16Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU32Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU32Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU64Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU8Z256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVDQU8Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVNTDQAZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVSHDUPZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVSHDUPZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVSLDUPZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVSLDUPZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVUPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVUPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVUPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VMOVUPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPSYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VORPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDBYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDQYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDWYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPADDWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDNDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDNDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDNQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDNQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDNYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPANDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDDYrmi")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBLENDMWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBROADCASTDZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBROADCASTDZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBROADCASTQZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPBROADCASTQZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPMASKMOVDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPMASKMOVQYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPORDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPORDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPORQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPORQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPORYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBBYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBQYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBWYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPSUBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPTERNLOGDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPTERNLOGDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPTERNLOGQZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPTERNLOGQZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPXORDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPXORDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPXORQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPXORQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VPXORYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPDYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPSYrm")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup121], (instregex "VXORPSZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup121], (instregex "VANDNPDYrm", + "VANDNPDZ256rm(b?)(k?)(z?)", + "VANDNPDZrm(b?)(k?)(z?)", + "VANDNPSYrm", + "VANDNPSZ256rm(b?)(k?)(z?)", + "VANDNPSZrm(b?)(k?)(z?)", + "VANDPDYrm", + "VANDPDZ256rm(b?)(k?)(z?)", + "VANDPDZrm(b?)(k?)(z?)", + "VANDPSYrm", + "VANDPSZ256rm(b?)(k?)(z?)", + "VANDPSZrm(b?)(k?)(z?)", + "VBLENDMPDZ256rm(b?)(k?)(z?)", + "VBLENDMPDZrm(b?)(k?)(z?)", + "VBLENDMPSZ256rm(b?)(k?)(z?)", + "VBLENDMPSZrm(b?)(k?)(z?)", + "VBLENDPDYrmi", + "VBLENDPSYrmi", + "VBROADCASTF32X2Z256m(b?)(k?)(z?)", + "VBROADCASTF32X2Zm(b?)(k?)(z?)", + "VBROADCASTF32X4Z256rm(b?)(k?)(z?)", + "VBROADCASTF32X4rm(b?)(k?)(z?)", + "VBROADCASTF32X8rm(b?)(k?)(z?)", + "VBROADCASTF64X2Z128rm(b?)(k?)(z?)", + "VBROADCASTF64X2rm(b?)(k?)(z?)", + "VBROADCASTF64X4rm(b?)(k?)(z?)", + "VBROADCASTI32X2Z256m(b?)(k?)(z?)", + "VBROADCASTI32X2Zm(b?)(k?)(z?)", + "VBROADCASTI32X4Z256rm(b?)(k?)(z?)", + "VBROADCASTI32X4rm(b?)(k?)(z?)", + "VBROADCASTI32X8rm(b?)(k?)(z?)", + "VBROADCASTI64X2Z128rm(b?)(k?)(z?)", + "VBROADCASTI64X2rm(b?)(k?)(z?)", + "VBROADCASTI64X4rm(b?)(k?)(z?)", + "VBROADCASTSDZ256m(b?)(k?)(z?)", + "VBROADCASTSDZm(b?)(k?)(z?)", + "VBROADCASTSSZ256m(b?)(k?)(z?)", + "VBROADCASTSSZm(b?)(k?)(z?)", + "VINSERTF32x4Z256rm(b?)(k?)(z?)", + "VINSERTF32x4Zrm(b?)(k?)(z?)", + "VINSERTF32x8Zrm(b?)(k?)(z?)", + "VINSERTF64x2Z256rm(b?)(k?)(z?)", + "VINSERTF64x2Zrm(b?)(k?)(z?)", + "VINSERTF64x4Zrm(b?)(k?)(z?)", + "VINSERTI32x4Z256rm(b?)(k?)(z?)", + "VINSERTI32x4Zrm(b?)(k?)(z?)", + "VINSERTI32x8Zrm(b?)(k?)(z?)", + "VINSERTI64x2Z256rm(b?)(k?)(z?)", + "VINSERTI64x2Zrm(b?)(k?)(z?)", + "VINSERTI64x4Zrm(b?)(k?)(z?)", + "VMASKMOVPDYrm", + "VMASKMOVPSYrm", + "VMOVAPDZ256rm(b?)(k?)(z?)", + "VMOVAPDZrm(b?)(k?)(z?)", + "VMOVAPSZ256rm(b?)(k?)(z?)", + "VMOVAPSZrm(b?)(k?)(z?)", + "VMOVDDUPZ256rm(b?)(k?)(z?)", + "VMOVDDUPZrm(b?)(k?)(z?)", + "VMOVDQA32Z256rm(b?)(k?)(z?)", + "VMOVDQA32Zrm(b?)(k?)(z?)", + "VMOVDQA64Z256rm(b?)(k?)(z?)", + "VMOVDQA64Zrm(b?)(k?)(z?)", + "VMOVDQU16Z256rm(b?)(k?)(z?)", + "VMOVDQU16Zrm(b?)(k?)(z?)", + "VMOVDQU32Z256rm(b?)(k?)(z?)", + "VMOVDQU32Zrm(b?)(k?)(z?)", + "VMOVDQU64Z256rm(b?)(k?)(z?)", + "VMOVDQU64Zrm(b?)(k?)(z?)", + "VMOVDQU8Z256rm(b?)(k?)(z?)", + "VMOVDQU8Zrm(b?)(k?)(z?)", + "VMOVNTDQAZ256rm(b?)(k?)(z?)", + "VMOVSHDUPZ256rm(b?)(k?)(z?)", + "VMOVSHDUPZrm(b?)(k?)(z?)", + "VMOVSLDUPZ256rm(b?)(k?)(z?)", + "VMOVSLDUPZrm(b?)(k?)(z?)", + "VMOVUPDZ256rm(b?)(k?)(z?)", + "VMOVUPDZrm(b?)(k?)(z?)", + "VMOVUPSZ256rm(b?)(k?)(z?)", + "VMOVUPSZrm(b?)(k?)(z?)", + "VORPDYrm", + "VORPDZ256rm(b?)(k?)(z?)", + "VORPDZrm(b?)(k?)(z?)", + "VORPSYrm", + "VORPSZ256rm(b?)(k?)(z?)", + "VORPSZrm(b?)(k?)(z?)", + "VPADDBYrm", + "VPADDBZ256rm(b?)(k?)(z?)", + "VPADDBZrm(b?)(k?)(z?)", + "VPADDDYrm", + "VPADDDZ256rm(b?)(k?)(z?)", + "VPADDDZrm(b?)(k?)(z?)", + "VPADDQYrm", + "VPADDQZ256rm(b?)(k?)(z?)", + "VPADDQZrm(b?)(k?)(z?)", + "VPADDWYrm", + "VPADDWZ256rm(b?)(k?)(z?)", + "VPADDWZrm(b?)(k?)(z?)", + "VPANDDZ256rm(b?)(k?)(z?)", + "VPANDDZrm(b?)(k?)(z?)", + "VPANDNDZ256rm(b?)(k?)(z?)", + "VPANDNDZrm(b?)(k?)(z?)", + "VPANDNQZ256rm(b?)(k?)(z?)", + "VPANDNQZrm(b?)(k?)(z?)", + "VPANDNYrm", + "VPANDQZ256rm(b?)(k?)(z?)", + "VPANDQZrm(b?)(k?)(z?)", + "VPANDYrm", + "VPBLENDDYrmi", + "VPBLENDMBZ256rm(b?)(k?)(z?)", + "VPBLENDMBZrm(b?)(k?)(z?)", + "VPBLENDMDZ256rm(b?)(k?)(z?)", + "VPBLENDMDZrm(b?)(k?)(z?)", + "VPBLENDMQZ256rm(b?)(k?)(z?)", + "VPBLENDMQZrm(b?)(k?)(z?)", + "VPBLENDMWZ256rm(b?)(k?)(z?)", + "VPBLENDMWZrm(b?)(k?)(z?)", + "VPBROADCASTDZ256m(b?)(k?)(z?)", + "VPBROADCASTDZm(b?)(k?)(z?)", + "VPBROADCASTQZ256m(b?)(k?)(z?)", + "VPBROADCASTQZm(b?)(k?)(z?)", + "VPMASKMOVDYrm", + "VPMASKMOVQYrm", + "VPORDZ256rm(b?)(k?)(z?)", + "VPORDZrm(b?)(k?)(z?)", + "VPORQZ256rm(b?)(k?)(z?)", + "VPORQZrm(b?)(k?)(z?)", + "VPORYrm", + "VPSUBBYrm", + "VPSUBBZ256rm(b?)(k?)(z?)", + "VPSUBBZrm(b?)(k?)(z?)", + "VPSUBDYrm", + "VPSUBDZ256rm(b?)(k?)(z?)", + "VPSUBDZrm(b?)(k?)(z?)", + "VPSUBQYrm", + "VPSUBQZ256rm(b?)(k?)(z?)", + "VPSUBQZrm(b?)(k?)(z?)", + "VPSUBWYrm", + "VPSUBWZrm(b?)(k?)(z?)", + "VPTERNLOGDZ256rm(b?)i(k?)(z?)", + "VPTERNLOGDZrm(b?)i(k?)(z?)", + "VPTERNLOGQZ256rm(b?)i(k?)(z?)", + "VPTERNLOGQZrm(b?)i(k?)(z?)", + "VPXORDZ256rm(b?)(k?)(z?)", + "VPXORDZrm(b?)(k?)(z?)", + "VPXORQZ256rm(b?)(k?)(z?)", + "VPXORQZrm(b?)(k?)(z?)", + "VPXORYrm", + "VXORPDYrm", + "VXORPDZ256rm(b?)(k?)(z?)", + "VXORPDZrm(b?)(k?)(z?)", + "VXORPSYrm", + "VXORPSZ256rm(b?)(k?)(z?)", + "VXORPSZrm(b?)(k?)(z?)")>; def SKXWriteResGroup122 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 8; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup122], (instregex "BLENDVPDrm0")>; -def: InstRW<[SKXWriteResGroup122], (instregex "BLENDVPSrm0")>; -def: InstRW<[SKXWriteResGroup122], (instregex "PBLENDVBrm0")>; -def: InstRW<[SKXWriteResGroup122], (instregex "VBLENDVPDrm")>; -def: InstRW<[SKXWriteResGroup122], (instregex "VBLENDVPSrm")>; -def: InstRW<[SKXWriteResGroup122], (instregex "VPBLENDVBYrm")>; -def: InstRW<[SKXWriteResGroup122], (instregex "VPBLENDVBrm")>; +def: InstRW<[SKXWriteResGroup122], (instregex "BLENDVPDrm0", + "BLENDVPSrm0", + "PBLENDVBrm0", + "VBLENDVPDrm", + "VBLENDVPSrm", + "VPBLENDVBYrm", + "VPBLENDVBrm")>; def SKXWriteResGroup123 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 8; let NumMicroOps = 4; let ResourceCycles = [1,2,1]; } -def: InstRW<[SKXWriteResGroup123], (instregex "MMX_PHADDSWrm")>; -def: InstRW<[SKXWriteResGroup123], (instregex "MMX_PHSUBSWrm")>; +def: InstRW<[SKXWriteResGroup123], (instregex "MMX_PHADDSWrm", + "MMX_PHSUBSWrm")>; def SKXWriteResGroup124 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort05]> { let Latency = 8; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup124], (instregex "MMX_PHADDDrm")>; -def: InstRW<[SKXWriteResGroup124], (instregex "MMX_PHADDWrm")>; -def: InstRW<[SKXWriteResGroup124], (instregex "MMX_PHSUBDrm")>; -def: InstRW<[SKXWriteResGroup124], (instregex "MMX_PHSUBWrm")>; +def: InstRW<[SKXWriteResGroup124], (instregex "MMX_PHADDDrm", + "MMX_PHADDWrm", + "MMX_PHSUBDrm", + "MMX_PHSUBWrm")>; def SKXWriteResGroup125 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237,SKXPort015]> { let Latency = 8; @@ -4440,20 +4431,20 @@ def SKXWriteResGroup127 : SchedWriteRes<[SKXPort23,SKXPort237,SKXPort06,SKXPort0 let NumMicroOps = 5; let ResourceCycles = [1,1,1,2]; } -def: InstRW<[SKXWriteResGroup127], (instregex "RCL(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup127], (instregex "RCL(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup127], (instregex "RCR(8|16|32|64)m1")>; -def: InstRW<[SKXWriteResGroup127], (instregex "RCR(8|16|32|64)mi")>; +def: InstRW<[SKXWriteResGroup127], (instregex "RCL(8|16|32|64)m1", + "RCL(8|16|32|64)mi", + "RCR(8|16|32|64)m1", + "RCR(8|16|32|64)mi")>; def SKXWriteResGroup128 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort06]> { let Latency = 8; let NumMicroOps = 6; let ResourceCycles = [1,1,1,3]; } -def: InstRW<[SKXWriteResGroup128], (instregex "ROL(8|16|32|64)mCL")>; -def: InstRW<[SKXWriteResGroup128], (instregex "SAR(8|16|32|64)mCL")>; -def: InstRW<[SKXWriteResGroup128], (instregex "SHL(8|16|32|64)mCL")>; -def: InstRW<[SKXWriteResGroup128], (instregex "SHR(8|16|32|64)mCL")>; +def: InstRW<[SKXWriteResGroup128], (instregex "ROL(8|16|32|64)mCL", + "SAR(8|16|32|64)mCL", + "SHL(8|16|32|64)mCL", + "SHR(8|16|32|64)mCL")>; def SKXWriteResGroup129 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort0156]> { let Latency = 8; @@ -4467,10 +4458,10 @@ def SKXWriteResGroup130 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort06 let NumMicroOps = 6; let ResourceCycles = [1,1,1,2,1]; } -def: InstRW<[SKXWriteResGroup130], (instregex "ADC(8|16|32|64)mr")>; -def: InstRW<[SKXWriteResGroup130], (instregex "CMPXCHG(8|16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup130], (instregex "SBB(8|16|32|64)mi")>; -def: InstRW<[SKXWriteResGroup130], (instregex "SBB(8|16|32|64)mr")>; +def: InstRW<[SKXWriteResGroup130], (instregex "ADC(8|16|32|64)mr", + "CMPXCHG(8|16|32|64)rm", + "SBB(8|16|32|64)mi", + "SBB(8|16|32|64)mr")>; def SKXWriteResGroup131 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort5,SKXPort237,SKXPort0156]> { let Latency = 8; @@ -4510,162 +4501,160 @@ def SKXWriteResGroup135 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_CVTPI2PSirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMADDUBSWrm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMADDWDirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMULHRSWrm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMULHUWirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMULHWirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMULLWirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "MMX_PMULUDQirm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "RCPSSm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "RSQRTSSm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "VRCPSSm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "VRSQRTSSm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "VTESTPDYrm")>; -def: InstRW<[SKXWriteResGroup135], (instregex "VTESTPSYrm")>; +def: InstRW<[SKXWriteResGroup135], (instregex "MMX_CVTPI2PSirm", + "MMX_PMADDUBSWrm", + "MMX_PMADDWDirm", + "MMX_PMULHRSWrm", + "MMX_PMULHUWirm", + "MMX_PMULHWirm", + "MMX_PMULLWirm", + "MMX_PMULUDQirm", + "RCPSSm", + "RSQRTSSm", + "VRCPSSm", + "VRSQRTSSm", + "VTESTPDYrm", + "VTESTPSYrm")>; def SKXWriteResGroup136 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup136], (instregex "PCMPGTQrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "PSADBWrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VALIGNDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VALIGNQZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VCMPPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VCMPPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VCMPSDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VCMPSSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VDBPSADBWZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VFPCLASSSSrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPBZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPDZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPEQBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPEQDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPEQQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPEQWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPGTBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPGTDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPGTQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPGTQrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPGTWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPQZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPUBZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPUDZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPUQZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPUWZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPCMPWZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMI2D128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMI2PD128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMI2PS128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMI2Q128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMT2D128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMT2PD128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMT2PS128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPERMT2Q128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMAXSQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMAXUQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMINSQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMINUQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXBDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXBQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXBWYrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXDQYrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXWDYrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXWDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVSXWQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXBDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXBQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXWDYrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXWDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPMOVZXWQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPSADBWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPSADBWrm")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTMBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTMDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTMQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTMWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTNMBZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTNMDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTNMQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup136], (instregex "VPTESTNMWZ128rm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup136], (instregex "PCMPGTQrm", + "PSADBWrm", + "VALIGNDZ128rm(b?)i(k?)(z?)", + "VALIGNQZ128rm(b?)i(k?)(z?)", + "VCMPPDZ128rm(b?)i(k?)(z?)", + "VCMPPSZ128rm(b?)i(k?)(z?)", + "VCMPSDZrm(_Int)?(k?)(z?)", + "VCMPSSZrm(_Int)?(k?)(z?)", + "VDBPSADBWZ128rmi(b?)(k?)(z?)", + "VFPCLASSSSrm(b?)(k?)(z?)", + "VPCMPBZ128rmi(b?)(k?)(z?)", + "VPCMPDZ128rmi(b?)(k?)(z?)", + "VPCMPEQBZ128rm(b?)(k?)(z?)", + "VPCMPEQDZ128rm(b?)(k?)(z?)", + "VPCMPEQQZ128rm(b?)(k?)(z?)", + "VPCMPEQWZ128rm(b?)(k?)(z?)", + "VPCMPGTBZ128rm(b?)(k?)(z?)", + "VPCMPGTDZ128rm(b?)(k?)(z?)", + "VPCMPGTQZ128rm(b?)(k?)(z?)", + "VPCMPGTQrm", + "VPCMPGTWZ128rm(b?)(k?)(z?)", + "VPCMPQZ128rmi(b?)(k?)(z?)", + "VPCMPUBZ128rmi(b?)(k?)(z?)", + "VPCMPUDZ128rmi(b?)(k?)(z?)", + "VPCMPUQZ128rmi(b?)(k?)(z?)", + "VPCMPUWZ128rmi(b?)(k?)(z?)", + "VPCMPWZ128rmi(b?)(k?)(z?)", + "VPERMI2D128rm(b?)(k?)(z?)", + "VPERMI2PD128rm(b?)(k?)(z?)", + "VPERMI2PS128rm(b?)(k?)(z?)", + "VPERMI2Q128rm(b?)(k?)(z?)", + "VPERMT2D128rm(b?)(k?)(z?)", + "VPERMT2PD128rm(b?)(k?)(z?)", + "VPERMT2PS128rm(b?)(k?)(z?)", + "VPERMT2Q128rm(b?)(k?)(z?)", + "VPMAXSQZ128rm(b?)(k?)(z?)", + "VPMAXUQZ128rm(b?)(k?)(z?)", + "VPMINSQZ128rm(b?)(k?)(z?)", + "VPMINUQZ128rm(b?)(k?)(z?)", + "VPMOVSXBDZ128rm(b?)(k?)(z?)", + "VPMOVSXBQZ128rm(b?)(k?)(z?)", + "VPMOVSXBWYrm", + "VPMOVSXBWZ128rm(b?)(k?)(z?)", + "VPMOVSXDQYrm", + "VPMOVSXDQZ128rm(b?)(k?)(z?)", + "VPMOVSXWDYrm", + "VPMOVSXWDZ128rm(b?)(k?)(z?)", + "VPMOVSXWQZ128rm(b?)(k?)(z?)", + "VPMOVZXBDZ128rm(b?)(k?)(z?)", + "VPMOVZXBQZ128rm(b?)(k?)(z?)", + "VPMOVZXBWZ128rm(b?)(k?)(z?)", + "VPMOVZXDQZ128rm(b?)(k?)(z?)", + "VPMOVZXWDYrm", + "VPMOVZXWDZ128rm(b?)(k?)(z?)", + "VPMOVZXWQZ128rm(b?)(k?)(z?)", + "VPSADBWZ128rm(b?)(k?)(z?)", + "VPSADBWrm", + "VPTESTMBZ128rm(b?)(k?)(z?)", + "VPTESTMDZ128rm(b?)(k?)(z?)", + "VPTESTMQZ128rm(b?)(k?)(z?)", + "VPTESTMWZ128rm(b?)(k?)(z?)", + "VPTESTNMBZ128rm(b?)(k?)(z?)", + "VPTESTNMDZ128rm(b?)(k?)(z?)", + "VPTESTNMQZ128rm(b?)(k?)(z?)", + "VPTESTNMWZ128rm(b?)(k?)(z?)")>; def SKXWriteResGroup137 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 9; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup137], (instregex "ADDSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "ADDSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "CMPSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "CMPSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "CVTPS2PDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MAX(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MAX(C?)SSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MIN(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MIN(C?)SSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MMX_CVTPS2PIirm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MMX_CVTTPS2PIirm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MULSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "MULSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "SUBSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "SUBSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VADDSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VADDSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VCMPSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VCMPSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VCVTPH2PSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VCVTPS2PDrm")>; def: InstRW<[SKXWriteResGroup137], (instregex "VF(N)?M(ADD|SUB)(132|213|231)S(D|S)m")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMAX(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMAX(C?)SSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMIN(C?)SDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMIN(C?)SSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMULSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VMULSSrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VSUBSDrm")>; -def: InstRW<[SKXWriteResGroup137], (instregex "VSUBSSrm")>; +def: InstRW<[SKXWriteResGroup137], (instregex "ADDSDrm", + "ADDSSrm", + "CMPSDrm", + "CMPSSrm", + "CVTPS2PDrm", + "MAX(C?)SDrm", + "MAX(C?)SSrm", + "MIN(C?)SDrm", + "MIN(C?)SSrm", + "MMX_CVTPS2PIirm", + "MMX_CVTTPS2PIirm", + "MULSDrm", + "MULSSrm", + "SUBSDrm", + "SUBSSrm", + "VADDSDrm", + "VADDSSrm", + "VCMPSDrm", + "VCMPSSrm", + "VCVTPH2PSrm", + "VCVTPS2PDrm", + "VMAX(C?)SDrm", + "VMAX(C?)SSrm", + "VMIN(C?)SDrm", + "VMIN(C?)SSrm", + "VMULSDrm", + "VMULSSrm", + "VSUBSDrm", + "VSUBSSrm")>; def SKXWriteResGroup138 : SchedWriteRes<[SKXPort0,SKXPort015]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup138], (instregex "VRCP14PDZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup138], (instregex "VRCP14PSZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup138], (instregex "VRSQRT14PDZr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup138], (instregex "VRSQRT14PSZr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup138], (instregex "VRCP14PDZr(b?)(k?)(z?)", + "VRCP14PSZr(b?)(k?)(z?)", + "VRSQRT14PDZr(b?)(k?)(z?)", + "VRSQRT14PSZr(b?)(k?)(z?)")>; def SKXWriteResGroup139 : SchedWriteRes<[SKXPort5,SKXPort015]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup139], (instregex "DPPDrri")>; -def: InstRW<[SKXWriteResGroup139], (instregex "VDPPDrri")>; +def: InstRW<[SKXWriteResGroup139], (instregex "(V?)DPPDrri")>; def SKXWriteResGroup140 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup140], (instregex "VBLENDVPDYrm")>; -def: InstRW<[SKXWriteResGroup140], (instregex "VBLENDVPSYrm")>; +def: InstRW<[SKXWriteResGroup140], (instregex "VBLENDVPDYrm", + "VBLENDVPSYrm")>; def SKXWriteResGroup141 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 9; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup141], (instregex "PTESTrm")>; -def: InstRW<[SKXWriteResGroup141], (instregex "VPTESTrm")>; +def: InstRW<[SKXWriteResGroup141], (instregex "(V?)PTESTrm")>; def SKXWriteResGroup142 : SchedWriteRes<[SKXPort1,SKXPort5,SKXPort23]> { let Latency = 9; @@ -4679,421 +4668,414 @@ def SKXWriteResGroup143 : SchedWriteRes<[SKXPort5,SKXPort01,SKXPort23]> { let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup143], (instregex "PHADDSWrm")>; -def: InstRW<[SKXWriteResGroup143], (instregex "PHSUBSWrm")>; -def: InstRW<[SKXWriteResGroup143], (instregex "VPHADDSWrm")>; -def: InstRW<[SKXWriteResGroup143], (instregex "VPHSUBSWrm")>; +def: InstRW<[SKXWriteResGroup143], (instregex "(V?)PHADDSWrm", + "(V?)PHSUBSWrm")>; def SKXWriteResGroup144 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 9; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup144], (instregex "PHADDDrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "PHADDWrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "PHSUBDrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "PHSUBWrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "VPHADDDrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "VPHADDWrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "VPHSUBDrm")>; -def: InstRW<[SKXWriteResGroup144], (instregex "VPHSUBWrm")>; +def: InstRW<[SKXWriteResGroup144], (instregex "(V?)PHADDDrm", + "(V?)PHADDWrm", + "(V?)PHSUBDrm", + "(V?)PHSUBWrm")>; def SKXWriteResGroup145 : SchedWriteRes<[SKXPort1,SKXPort23,SKXPort237,SKXPort0156]> { let Latency = 9; let NumMicroOps = 4; let ResourceCycles = [1,1,1,1]; } -def: InstRW<[SKXWriteResGroup145], (instregex "SHLD(16|32|64)mri8")>; -def: InstRW<[SKXWriteResGroup145], (instregex "SHRD(16|32|64)mri8")>; +def: InstRW<[SKXWriteResGroup145], (instregex "SHLD(16|32|64)mri8", + "SHRD(16|32|64)mri8")>; def SKXWriteResGroup146 : SchedWriteRes<[SKXPort1,SKXPort6,SKXPort23,SKXPort0156]> { let Latency = 9; let NumMicroOps = 5; let ResourceCycles = [1,2,1,1]; } -def: InstRW<[SKXWriteResGroup146], (instregex "LAR(16|32|64)rm")>; -def: InstRW<[SKXWriteResGroup146], (instregex "LSL(16|32|64)rm")>; +def: InstRW<[SKXWriteResGroup146], (instregex "LAR(16|32|64)rm", + "LSL(16|32|64)rm")>; def SKXWriteResGroup147 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup147], (instregex "AESDECLASTrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "AESDECrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "AESENCLASTrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "AESENCrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "RCPPSm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "RSQRTPSm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VAESDECLASTrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VAESDECrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VAESENCLASTrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VAESENCrm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRCP14PDZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRCP14PSZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRCP14SDrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRCP14SSrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRCPPSm")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRSQRT14PDZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRSQRT14PSZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRSQRT14SDrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRSQRT14SSrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup147], (instregex "VRSQRTPSm")>; +def: InstRW<[SKXWriteResGroup147], (instregex "AESDECLASTrm", + "AESDECrm", + "AESENCLASTrm", + "AESENCrm", + "RCPPSm", + "RSQRTPSm", + "VAESDECLASTrm", + "VAESDECrm", + "VAESENCLASTrm", + "VAESENCrm", + "VRCP14PDZ128m(b?)(k?)(z?)", + "VRCP14PSZ128m(b?)(k?)(z?)", + "VRCP14SDrm(b?)(k?)(z?)", + "VRCP14SSrm(b?)(k?)(z?)", + "VRCPPSm", + "VRSQRT14PDZ128m(b?)(k?)(z?)", + "VRSQRT14PSZ128m(b?)(k?)(z?)", + "VRSQRT14SDrm(b?)(k?)(z?)", + "VRSQRT14SSrm(b?)(k?)(z?)", + "VRSQRTPSm")>; def SKXWriteResGroup148 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup148], (instregex "ADD_F32m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "ADD_F64m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "ILD_F16m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "ILD_F32m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "ILD_F64m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "SUBR_F32m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "SUBR_F64m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "SUB_F32m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "SUB_F64m")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VALIGNDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VALIGNDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VALIGNQZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VALIGNQZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VCMPPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VCMPPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VCMPPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VCMPPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VDBPSADBWZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VDBPSADBWZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPBZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPBZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPDZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPDZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPEQWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTQYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPGTWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPQZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPQZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUBZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUBZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUDZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUDZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUQZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUQZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUWZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPUWZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPWZ256rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPCMPWZrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERM2F128rm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERM2I128rm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMDYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2D256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2Drm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2PD256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2PDrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2PS256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2PSrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2Q256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMI2Qrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPDYmi")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPDZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPDZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPSYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMQYmi")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMQZ256m(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMQZm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2D256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2Drm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2PD256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2PDrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2PS256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2PSrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2Q256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPERMT2Qrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMAXSQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMAXSQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMAXUQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMAXUQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMINSQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMINSQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMINUQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMINUQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXWDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXWDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXWQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVSXWQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBDYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBQYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBWYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXDQYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXWDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXWDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXWQYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXWQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPMOVZXWQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPSADBWYrm")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPSADBWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPSADBWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTMWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMBZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMBZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VPTESTNMWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFF32X4Z256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFF32X4Zrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFF64X2Z256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFF64X2Zrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFI32X4Z256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFI32X4Zrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFI64X2Z256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup148], (instregex "VSHUFI64X2Zrm(b?)i(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup148], (instregex "ADD_F32m", + "ADD_F64m", + "ILD_F16m", + "ILD_F32m", + "ILD_F64m", + "SUBR_F32m", + "SUBR_F64m", + "SUB_F32m", + "SUB_F64m", + "VALIGNDZ256rm(b?)i(k?)(z?)", + "VALIGNDZrm(b?)i(k?)(z?)", + "VALIGNQZ256rm(b?)i(k?)(z?)", + "VALIGNQZrm(b?)i(k?)(z?)", + "VCMPPDZ256rm(b?)i(k?)(z?)", + "VCMPPDZrm(b?)i(k?)(z?)", + "VCMPPSZ256rm(b?)i(k?)(z?)", + "VCMPPSZrm(b?)i(k?)(z?)", + "VDBPSADBWZ256rmi(b?)(k?)(z?)", + "VDBPSADBWZrmi(b?)(k?)(z?)", + "VPCMPBZ256rmi(b?)(k?)(z?)", + "VPCMPBZrmi(b?)(k?)(z?)", + "VPCMPDZ256rmi(b?)(k?)(z?)", + "VPCMPDZrmi(b?)(k?)(z?)", + "VPCMPEQBZ256rm(b?)(k?)(z?)", + "VPCMPEQBZrm(b?)(k?)(z?)", + "VPCMPEQDZ256rm(b?)(k?)(z?)", + "VPCMPEQDZrm(b?)(k?)(z?)", + "VPCMPEQQZ256rm(b?)(k?)(z?)", + "VPCMPEQQZrm(b?)(k?)(z?)", + "VPCMPEQWZ256rm(b?)(k?)(z?)", + "VPCMPEQWZrm(b?)(k?)(z?)", + "VPCMPGTBZ256rm(b?)(k?)(z?)", + "VPCMPGTBZrm(b?)(k?)(z?)", + "VPCMPGTDZ256rm(b?)(k?)(z?)", + "VPCMPGTDZrm(b?)(k?)(z?)", + "VPCMPGTQYrm", + "VPCMPGTQZ256rm(b?)(k?)(z?)", + "VPCMPGTQZrm(b?)(k?)(z?)", + "VPCMPGTWZ256rm(b?)(k?)(z?)", + "VPCMPGTWZrm(b?)(k?)(z?)", + "VPCMPQZ256rmi(b?)(k?)(z?)", + "VPCMPQZrmi(b?)(k?)(z?)", + "VPCMPUBZ256rmi(b?)(k?)(z?)", + "VPCMPUBZrmi(b?)(k?)(z?)", + "VPCMPUDZ256rmi(b?)(k?)(z?)", + "VPCMPUDZrmi(b?)(k?)(z?)", + "VPCMPUQZ256rmi(b?)(k?)(z?)", + "VPCMPUQZrmi(b?)(k?)(z?)", + "VPCMPUWZ256rmi(b?)(k?)(z?)", + "VPCMPUWZrmi(b?)(k?)(z?)", + "VPCMPWZ256rmi(b?)(k?)(z?)", + "VPCMPWZrmi(b?)(k?)(z?)", + "VPERM2F128rm", + "VPERM2I128rm", + "VPERMDYrm", + "VPERMDZ256rm(b?)(k?)(z?)", + "VPERMDZrm(b?)(k?)(z?)", + "VPERMI2D256rm(b?)(k?)(z?)", + "VPERMI2Drm(b?)(k?)(z?)", + "VPERMI2PD256rm(b?)(k?)(z?)", + "VPERMI2PDrm(b?)(k?)(z?)", + "VPERMI2PS256rm(b?)(k?)(z?)", + "VPERMI2PSrm(b?)(k?)(z?)", + "VPERMI2Q256rm(b?)(k?)(z?)", + "VPERMI2Qrm(b?)(k?)(z?)", + "VPERMPDYmi", + "VPERMPDZ256m(b?)i(k?)(z?)", + "VPERMPDZ256rm(b?)(k?)(z?)", + "VPERMPDZm(b?)i(k?)(z?)", + "VPERMPDZrm(b?)(k?)(z?)", + "VPERMPSYrm", + "VPERMPSZ256rm(b?)(k?)(z?)", + "VPERMPSZrm(b?)(k?)(z?)", + "VPERMQYmi", + "VPERMQZ256m(b?)i(k?)(z?)", + "VPERMQZ256rm(b?)(k?)(z?)", + "VPERMQZm(b?)i(k?)(z?)", + "VPERMQZrm(b?)(k?)(z?)", + "VPERMT2D256rm(b?)(k?)(z?)", + "VPERMT2Drm(b?)(k?)(z?)", + "VPERMT2PD256rm(b?)(k?)(z?)", + "VPERMT2PDrm(b?)(k?)(z?)", + "VPERMT2PS256rm(b?)(k?)(z?)", + "VPERMT2PSrm(b?)(k?)(z?)", + "VPERMT2Q256rm(b?)(k?)(z?)", + "VPERMT2Qrm(b?)(k?)(z?)", + "VPMAXSQZ256rm(b?)(k?)(z?)", + "VPMAXSQZrm(b?)(k?)(z?)", + "VPMAXUQZ256rm(b?)(k?)(z?)", + "VPMAXUQZrm(b?)(k?)(z?)", + "VPMINSQZ256rm(b?)(k?)(z?)", + "VPMINSQZrm(b?)(k?)(z?)", + "VPMINUQZ256rm(b?)(k?)(z?)", + "VPMINUQZrm(b?)(k?)(z?)", + "VPMOVSXBDZ256rm(b?)(k?)(z?)", + "VPMOVSXBDZrm(b?)(k?)(z?)", + "VPMOVSXBQZ256rm(b?)(k?)(z?)", + "VPMOVSXBQZrm(b?)(k?)(z?)", + "VPMOVSXBWZ256rm(b?)(k?)(z?)", + "VPMOVSXBWZrm(b?)(k?)(z?)", + "VPMOVSXDQZ256rm(b?)(k?)(z?)", + "VPMOVSXDQZrm(b?)(k?)(z?)", + "VPMOVSXWDZ256rm(b?)(k?)(z?)", + "VPMOVSXWDZrm(b?)(k?)(z?)", + "VPMOVSXWQZ256rm(b?)(k?)(z?)", + "VPMOVSXWQZrm(b?)(k?)(z?)", + "VPMOVZXBDYrm", + "VPMOVZXBDZ256rm(b?)(k?)(z?)", + "VPMOVZXBDZrm(b?)(k?)(z?)", + "VPMOVZXBQYrm", + "VPMOVZXBQZ256rm(b?)(k?)(z?)", + "VPMOVZXBQZrm(b?)(k?)(z?)", + "VPMOVZXBWYrm", + "VPMOVZXBWZ256rm(b?)(k?)(z?)", + "VPMOVZXBWZrm(b?)(k?)(z?)", + "VPMOVZXDQYrm", + "VPMOVZXDQZ256rm(b?)(k?)(z?)", + "VPMOVZXDQZrm(b?)(k?)(z?)", + "VPMOVZXWDZ256rm(b?)(k?)(z?)", + "VPMOVZXWDZrm(b?)(k?)(z?)", + "VPMOVZXWQYrm", + "VPMOVZXWQZ256rm(b?)(k?)(z?)", + "VPMOVZXWQZrm(b?)(k?)(z?)", + "VPSADBWYrm", + "VPSADBWZ256rm(b?)(k?)(z?)", + "VPSADBWZrm(b?)(k?)(z?)", + "VPTESTMBZ256rm(b?)(k?)(z?)", + "VPTESTMBZrm(b?)(k?)(z?)", + "VPTESTMDZ256rm(b?)(k?)(z?)", + "VPTESTMDZrm(b?)(k?)(z?)", + "VPTESTMQZ256rm(b?)(k?)(z?)", + "VPTESTMQZrm(b?)(k?)(z?)", + "VPTESTMWZ256rm(b?)(k?)(z?)", + "VPTESTMWZrm(b?)(k?)(z?)", + "VPTESTNMBZ256rm(b?)(k?)(z?)", + "VPTESTNMBZrm(b?)(k?)(z?)", + "VPTESTNMDZ256rm(b?)(k?)(z?)", + "VPTESTNMDZrm(b?)(k?)(z?)", + "VPTESTNMQZ256rm(b?)(k?)(z?)", + "VPTESTNMQZrm(b?)(k?)(z?)", + "VPTESTNMWZ256rm(b?)(k?)(z?)", + "VPTESTNMWZrm(b?)(k?)(z?)", + "VSHUFF32X4Z256rm(b?)i(k?)(z?)", + "VSHUFF32X4Zrm(b?)i(k?)(z?)", + "VSHUFF64X2Z256rm(b?)i(k?)(z?)", + "VSHUFF64X2Zrm(b?)i(k?)(z?)", + "VSHUFI32X4Z256rm(b?)i(k?)(z?)", + "VSHUFI32X4Zrm(b?)i(k?)(z?)", + "VSHUFI64X2Z256rm(b?)i(k?)(z?)", + "VSHUFI64X2Zrm(b?)i(k?)(z?)")>; def SKXWriteResGroup149 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 10; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup149], (instregex "ADDPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "ADDPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "ADDSUBPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "ADDSUBPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CMPPDrmi")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CMPPSrmi")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CVTDQ2PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CVTPS2DQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CVTSS2SDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "CVTTPS2DQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MAX(C?)PDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MAX(C?)PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MIN(C?)PDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MIN(C?)PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MULPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "MULPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PHMINPOSUWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMADDUBSWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMADDWDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULDQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULHRSWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULHUWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULHWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULLWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "PMULUDQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "SUBPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "SUBPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDSDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDSSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDSUBPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VADDSUBPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCMPPDrmi")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCMPPSrmi")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTDQ2PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTDQ2PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTDQ2PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPD2QQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPD2UQQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPH2PSYrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPH2PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2DQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2DQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2QQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2UDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTPS2UQQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTQQ2PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTQQ2PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTSS2SDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTSS2SDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPD2QQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPD2UQQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPS2DQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPS2DQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPS2QQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPS2UDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTTPS2UQQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTUDQ2PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTUDQ2PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTUQQ2PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VCVTUQQ2PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VFIXUPIMMPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VFIXUPIMMPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VFIXUPIMMSDrmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VFIXUPIMMSSrmi(b?)(k?)(z?)")>; def: InstRW<[SKXWriteResGroup149], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Z128m(b?)(k?)(z?)", "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)m", "VF(N)?M(ADD|SUB)(132|213|231)S(D|S)Zm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETEXPPDZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETEXPPSZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETEXPSDm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETEXPSSm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETMANTPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETMANTPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETMANTSDZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VGETMANTSSZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)PDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)SDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMAX(C?)SSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)PDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)PDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)PSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)PSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)SDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMIN(C?)SSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULSDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VMULSSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPHMINPOSUWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPLZCNTDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPLZCNTQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMADDUBSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMADDUBSWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMADDWDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMADDWDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULDQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHRSWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHRSWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHUWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHUWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULHWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULLWZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULLWrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULUDQZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VPMULUDQrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VRANGEPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VRANGEPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VRANGESDZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VRANGESSZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VREDUCEPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VREDUCEPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VREDUCESDZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VREDUCESSZ128rmi(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSCALEFPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSCALEFPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSCALEFSDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSCALEFSSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBPDrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBPSrm")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBSDZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup149], (instregex "VSUBSSZrm(_Int)?(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup149], (instregex "ADDPDrm", + "ADDPSrm", + "ADDSUBPDrm", + "ADDSUBPSrm", + "CMPPDrmi", + "CMPPSrmi", + "CVTDQ2PSrm", + "CVTPS2DQrm", + "CVTSS2SDrm", + "CVTTPS2DQrm", + "MAX(C?)PDrm", + "MAX(C?)PSrm", + "MIN(C?)PDrm", + "MIN(C?)PSrm", + "MULPDrm", + "MULPSrm", + "PHMINPOSUWrm", + "PMADDUBSWrm", + "PMADDWDrm", + "PMULDQrm", + "PMULHRSWrm", + "PMULHUWrm", + "PMULHWrm", + "PMULLWrm", + "PMULUDQrm", + "SUBPDrm", + "SUBPSrm", + "VADDPDZ128rm(b?)(k?)(z?)", + "VADDPDrm", + "VADDPSZ128rm(b?)(k?)(z?)", + "VADDPSrm", + "VADDSDZrm(_Int)?(k?)(z?)", + "VADDSSZrm(_Int)?(k?)(z?)", + "VADDSUBPDrm", + "VADDSUBPSrm", + "VCMPPDrmi", + "VCMPPSrmi", + "VCVTDQ2PDZ128rm(b?)(k?)(z?)", + "VCVTDQ2PSZ128rm(b?)(k?)(z?)", + "VCVTDQ2PSrm", + "VCVTPD2QQZ128rm(b?)(k?)(z?)", + "VCVTPD2UQQZ128rm(b?)(k?)(z?)", + "VCVTPH2PSYrm", + "VCVTPH2PSZ128rm(b?)(k?)(z?)", + "VCVTPS2DQZ128rm(b?)(k?)(z?)", + "VCVTPS2DQrm", + "VCVTPS2PDZ128rm(b?)(k?)(z?)", + "VCVTPS2QQZ128rm(b?)(k?)(z?)", + "VCVTPS2UDQZ128rm(b?)(k?)(z?)", + "VCVTPS2UQQZ128rm(b?)(k?)(z?)", + "VCVTQQ2PDZ128rm(b?)(k?)(z?)", + "VCVTQQ2PSZ128rm(b?)(k?)(z?)", + "VCVTSS2SDZrm(_Int)?(k?)(z?)", + "VCVTSS2SDrm", + "VCVTTPD2QQZ128rm(b?)(k?)(z?)", + "VCVTTPD2UQQZ128rm(b?)(k?)(z?)", + "VCVTTPS2DQZ128rm(b?)(k?)(z?)", + "VCVTTPS2DQrm", + "VCVTTPS2QQZ128rm(b?)(k?)(z?)", + "VCVTTPS2UDQZ128rm(b?)(k?)(z?)", + "VCVTTPS2UQQZ128rm(b?)(k?)(z?)", + "VCVTUDQ2PDZ128rm(b?)(k?)(z?)", + "VCVTUDQ2PSZ128rm(b?)(k?)(z?)", + "VCVTUQQ2PDZ128rm(b?)(k?)(z?)", + "VCVTUQQ2PSZ128rm(b?)(k?)(z?)", + "VFIXUPIMMPDZ128rm(b?)i(k?)(z?)", + "VFIXUPIMMPSZ128rm(b?)i(k?)(z?)", + "VFIXUPIMMSDrmi(b?)(k?)(z?)", + "VFIXUPIMMSSrmi(b?)(k?)(z?)", + "VGETEXPPDZ128m(b?)(k?)(z?)", + "VGETEXPPSZ128m(b?)(k?)(z?)", + "VGETEXPSDm(b?)(k?)(z?)", + "VGETEXPSSm(b?)(k?)(z?)", + "VGETMANTPDZ128rm(b?)i(k?)(z?)", + "VGETMANTPSZ128rm(b?)i(k?)(z?)", + "VGETMANTSDZ128rmi(b?)(k?)(z?)", + "VGETMANTSSZ128rmi(b?)(k?)(z?)", + "VMAX(C?)PDZ128rm(b?)(k?)(z?)", + "VMAX(C?)PDrm", + "VMAX(C?)PSZ128rm(b?)(k?)(z?)", + "VMAX(C?)PSrm", + "VMAX(C?)SDZrm(_Int)?(k?)(z?)", + "VMAX(C?)SSZrm(_Int)?(k?)(z?)", + "VMIN(C?)PDZ128rm(b?)(k?)(z?)", + "VMIN(C?)PDrm", + "VMIN(C?)PSZ128rm(b?)(k?)(z?)", + "VMIN(C?)PSrm", + "VMIN(C?)SDZrm(_Int)?(k?)(z?)", + "VMIN(C?)SSZrm(_Int)?(k?)(z?)", + "VMULPDZ128rm(b?)(k?)(z?)", + "VMULPDrm", + "VMULPSZ128rm(b?)(k?)(z?)", + "VMULPSrm", + "VMULSDZrm(_Int)?(k?)(z?)", + "VMULSSZrm(_Int)?(k?)(z?)", + "VPHMINPOSUWrm", + "VPLZCNTDZ128rm(b?)(k?)(z?)", + "VPLZCNTQZ128rm(b?)(k?)(z?)", + "VPMADDUBSWZ128rm(b?)(k?)(z?)", + "VPMADDUBSWrm", + "VPMADDWDZ128rm(b?)(k?)(z?)", + "VPMADDWDrm", + "VPMULDQZ128rm(b?)(k?)(z?)", + "VPMULDQrm", + "VPMULHRSWZ128rm(b?)(k?)(z?)", + "VPMULHRSWrm", + "VPMULHUWZ128rm(b?)(k?)(z?)", + "VPMULHUWrm", + "VPMULHWZ128rm(b?)(k?)(z?)", + "VPMULHWrm", + "VPMULLWZ128rm(b?)(k?)(z?)", + "VPMULLWrm", + "VPMULUDQZ128rm(b?)(k?)(z?)", + "VPMULUDQrm", + "VRANGEPDZ128rm(b?)i(k?)(z?)", + "VRANGEPSZ128rm(b?)i(k?)(z?)", + "VRANGESDZ128rmi(b?)(k?)(z?)", + "VRANGESSZ128rmi(b?)(k?)(z?)", + "VREDUCEPDZ128rm(b?)i(k?)(z?)", + "VREDUCEPSZ128rm(b?)i(k?)(z?)", + "VREDUCESDZ128rmi(b?)(k?)(z?)", + "VREDUCESSZ128rmi(b?)(k?)(z?)", + "VSCALEFPDZ128rm(b?)(k?)(z?)", + "VSCALEFPSZ128rm(b?)(k?)(z?)", + "VSCALEFSDZ128rm(b?)(k?)(z?)", + "VSCALEFSSZ128rm(b?)(k?)(z?)", + "VSUBPDZ128rm(b?)(k?)(z?)", + "VSUBPDrm", + "VSUBPSZ128rm(b?)(k?)(z?)", + "VSUBPSrm", + "VSUBSDZrm(_Int)?(k?)(z?)", + "VSUBSSZrm(_Int)?(k?)(z?)")>; def SKXWriteResGroup150 : SchedWriteRes<[SKXPort0]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKXWriteResGroup150], (instregex "PCMPISTRIrr")>; -def: InstRW<[SKXWriteResGroup150], (instregex "PCMPISTRM128rr")>; -def: InstRW<[SKXWriteResGroup150], (instregex "VPCMPISTRIrr")>; -def: InstRW<[SKXWriteResGroup150], (instregex "VPCMPISTRM128rr")>; +def: InstRW<[SKXWriteResGroup150], (instregex "PCMPISTRIrr", + "PCMPISTRM128rr", + "VPCMPISTRIrr", + "VPCMPISTRM128rr")>; def SKXWriteResGroup151 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup151], (instregex "MPSADBWrmi")>; -def: InstRW<[SKXWriteResGroup151], (instregex "VEXPANDPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup151], (instregex "VEXPANDPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup151], (instregex "VMPSADBWrmi")>; -def: InstRW<[SKXWriteResGroup151], (instregex "VPEXPANDDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup151], (instregex "VPEXPANDQZ128rm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup151], (instregex "MPSADBWrmi", + "VEXPANDPDZ128rm(b?)(k?)(z?)", + "VEXPANDPSZ128rm(b?)(k?)(z?)", + "VMPSADBWrmi", + "VPEXPANDDZ128rm(b?)(k?)(z?)", + "VPEXPANDQZ128rm(b?)(k?)(z?)")>; def SKXWriteResGroup152 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup152], (instregex "MMX_CVTPI2PDirm")>; -def: InstRW<[SKXWriteResGroup152], (instregex "VPTESTYrm")>; +def: InstRW<[SKXWriteResGroup152], (instregex "MMX_CVTPI2PDirm", + "VPTESTYrm")>; def SKXWriteResGroup153 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 10; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup153], (instregex "CVTSD2SSrm")>; -def: InstRW<[SKXWriteResGroup153], (instregex "VCVTSD2SSrm")>; +def: InstRW<[SKXWriteResGroup153], (instregex "(V?)CVTSD2SSrm")>; def SKXWriteResGroup154 : SchedWriteRes<[SKXPort5,SKXPort01,SKXPort23]> { let Latency = 10; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup154], (instregex "VPHADDSWYrm")>; -def: InstRW<[SKXWriteResGroup154], (instregex "VPHSUBSWYrm")>; +def: InstRW<[SKXWriteResGroup154], (instregex "VPHADDSWYrm", + "VPHSUBSWYrm")>; def SKXWriteResGroup155 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 10; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup155], (instregex "VPHADDDYrm")>; -def: InstRW<[SKXWriteResGroup155], (instregex "VPHADDWYrm")>; -def: InstRW<[SKXWriteResGroup155], (instregex "VPHSUBDYrm")>; -def: InstRW<[SKXWriteResGroup155], (instregex "VPHSUBWYrm")>; +def: InstRW<[SKXWriteResGroup155], (instregex "VPHADDDYrm", + "VPHADDWYrm", + "VPHSUBDYrm", + "VPHSUBWYrm")>; def SKXWriteResGroup156 : SchedWriteRes<[SKXPort1,SKXPort23,SKXPort06,SKXPort0156]> { let Latency = 10; @@ -5121,186 +5103,186 @@ def SKXWriteResGroup159 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup159], (instregex "DIVPSrr")>; -def: InstRW<[SKXWriteResGroup159], (instregex "DIVSSrr")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVPSYrr")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVPSZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVPSZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVPSrr")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVSSZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup159], (instregex "VDIVSSrr")>; +def: InstRW<[SKXWriteResGroup159], (instregex "DIVPSrr", + "DIVSSrr", + "VDIVPSYrr", + "VDIVPSZ128rr(b?)(k?)(z?)", + "VDIVPSZ256rr(b?)(k?)(z?)", + "VDIVPSrr", + "VDIVSSZrr(b?)(_Int)?(k?)(z?)", + "VDIVSSrr")>; def SKXWriteResGroup160 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 11; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup160], (instregex "MUL_F32m")>; -def: InstRW<[SKXWriteResGroup160], (instregex "MUL_F64m")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRCP14PDZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRCP14PSZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRCPPSYm")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRSQRT14PDZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRSQRT14PSZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup160], (instregex "VRSQRTPSYm")>; +def: InstRW<[SKXWriteResGroup160], (instregex "MUL_F32m", + "MUL_F64m", + "VRCP14PDZ256m(b?)(k?)(z?)", + "VRCP14PSZ256m(b?)(k?)(z?)", + "VRCPPSYm", + "VRSQRT14PDZ256m(b?)(k?)(z?)", + "VRSQRT14PSZ256m(b?)(k?)(z?)", + "VRSQRTPSYm")>; def SKXWriteResGroup161 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 11; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDSUBPDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VADDSUBPSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCMPPDYrmi")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCMPPSYrmi")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTDQ2PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTDQ2PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTDQ2PSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTDQ2PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTDQ2PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPD2QQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPD2QQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPD2UQQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPD2UQQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPH2PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPH2PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2DQYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2DQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2DQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2PDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2QQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2UDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2UDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTPS2UQQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTQQ2PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTQQ2PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTQQ2PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPD2QQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPD2QQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPD2UQQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPD2UQQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2DQYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2DQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2DQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2QQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2UDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2UDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTTPS2UQQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUDQ2PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUDQ2PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUDQ2PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUDQ2PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUQQ2PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUQQ2PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VCVTUQQ2PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VFIXUPIMMPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VFIXUPIMMPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VFIXUPIMMPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VFIXUPIMMPSZrm(b?)i(k?)(z?)")>; def: InstRW<[SKXWriteResGroup161], (instregex "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Ym", "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Z256m(b?)(k?)(z?)", "VF(N)?M(ADD|SUB|ADDSUB|SUBADD)(132|213|231)P(D|S)Zm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETEXPPDZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETEXPPDm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETEXPPSZ256m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETEXPPSm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETMANTPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETMANTPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETMANTPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VGETMANTPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMAX(C?)PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMIN(C?)PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VMULPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPLZCNTDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPLZCNTDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPLZCNTQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPLZCNTQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDUBSWYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDUBSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDUBSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDWDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDWDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMADDWDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULDQYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHRSWYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHRSWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHRSWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHUWYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHUWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHUWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHWYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULHWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULLWYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULLWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULLWZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULUDQYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULUDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VPMULUDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VRANGEPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VRANGEPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VRANGEPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VRANGEPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VREDUCEPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VREDUCEPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VREDUCEPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VREDUCEPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSCALEFPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSCALEFPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSCALEFPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSCALEFPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPDYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPSYrm")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup161], (instregex "VSUBPSZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup161], (instregex "VADDPDYrm", + "VADDPDZ256rm(b?)(k?)(z?)", + "VADDPDZrm(b?)(k?)(z?)", + "VADDPSYrm", + "VADDPSZ256rm(b?)(k?)(z?)", + "VADDPSZrm(b?)(k?)(z?)", + "VADDSUBPDYrm", + "VADDSUBPSYrm", + "VCMPPDYrmi", + "VCMPPSYrmi", + "VCVTDQ2PDZ256rm(b?)(k?)(z?)", + "VCVTDQ2PDZrm(b?)(k?)(z?)", + "VCVTDQ2PSYrm", + "VCVTDQ2PSZ256rm(b?)(k?)(z?)", + "VCVTDQ2PSZrm(b?)(k?)(z?)", + "VCVTPD2QQZ256rm(b?)(k?)(z?)", + "VCVTPD2QQZrm(b?)(k?)(z?)", + "VCVTPD2UQQZ256rm(b?)(k?)(z?)", + "VCVTPD2UQQZrm(b?)(k?)(z?)", + "VCVTPH2PSZ256rm(b?)(k?)(z?)", + "VCVTPH2PSZrm(b?)(k?)(z?)", + "VCVTPS2DQYrm", + "VCVTPS2DQZ256rm(b?)(k?)(z?)", + "VCVTPS2DQZrm(b?)(k?)(z?)", + "VCVTPS2PDYrm", + "VCVTPS2PDZ256rm(b?)(k?)(z?)", + "VCVTPS2PDZrm(b?)(k?)(z?)", + "VCVTPS2QQZ256rm(b?)(k?)(z?)", + "VCVTPS2UDQZ256rm(b?)(k?)(z?)", + "VCVTPS2UDQZrm(b?)(k?)(z?)", + "VCVTPS2UQQZ256rm(b?)(k?)(z?)", + "VCVTQQ2PDZ256rm(b?)(k?)(z?)", + "VCVTQQ2PDZrm(b?)(k?)(z?)", + "VCVTQQ2PSZ256rm(b?)(k?)(z?)", + "VCVTTPD2QQZ256rm(b?)(k?)(z?)", + "VCVTTPD2QQZrm(b?)(k?)(z?)", + "VCVTTPD2UQQZ256rm(b?)(k?)(z?)", + "VCVTTPD2UQQZrm(b?)(k?)(z?)", + "VCVTTPS2DQYrm", + "VCVTTPS2DQZ256rm(b?)(k?)(z?)", + "VCVTTPS2DQZrm(b?)(k?)(z?)", + "VCVTTPS2QQZ256rm(b?)(k?)(z?)", + "VCVTTPS2UDQZ256rm(b?)(k?)(z?)", + "VCVTTPS2UDQZrm(b?)(k?)(z?)", + "VCVTTPS2UQQZ256rm(b?)(k?)(z?)", + "VCVTUDQ2PDZ256rm(b?)(k?)(z?)", + "VCVTUDQ2PDZrm(b?)(k?)(z?)", + "VCVTUDQ2PSZ256rm(b?)(k?)(z?)", + "VCVTUDQ2PSZrm(b?)(k?)(z?)", + "VCVTUQQ2PDZ256rm(b?)(k?)(z?)", + "VCVTUQQ2PDZrm(b?)(k?)(z?)", + "VCVTUQQ2PSZ256rm(b?)(k?)(z?)", + "VFIXUPIMMPDZ256rm(b?)i(k?)(z?)", + "VFIXUPIMMPDZrm(b?)i(k?)(z?)", + "VFIXUPIMMPSZ256rm(b?)i(k?)(z?)", + "VFIXUPIMMPSZrm(b?)i(k?)(z?)", + "VGETEXPPDZ256m(b?)(k?)(z?)", + "VGETEXPPDm(b?)(k?)(z?)", + "VGETEXPPSZ256m(b?)(k?)(z?)", + "VGETEXPPSm(b?)(k?)(z?)", + "VGETMANTPDZ256rm(b?)i(k?)(z?)", + "VGETMANTPDZrm(b?)i(k?)(z?)", + "VGETMANTPSZ256rm(b?)i(k?)(z?)", + "VGETMANTPSZrm(b?)i(k?)(z?)", + "VMAX(C?)PDYrm", + "VMAX(C?)PDZ256rm(b?)(k?)(z?)", + "VMAX(C?)PDZrm(b?)(k?)(z?)", + "VMAX(C?)PSYrm", + "VMAX(C?)PSZ256rm(b?)(k?)(z?)", + "VMAX(C?)PSZrm(b?)(k?)(z?)", + "VMIN(C?)PDYrm", + "VMIN(C?)PDZ256rm(b?)(k?)(z?)", + "VMIN(C?)PDZrm(b?)(k?)(z?)", + "VMIN(C?)PSYrm", + "VMIN(C?)PSZ256rm(b?)(k?)(z?)", + "VMIN(C?)PSZrm(b?)(k?)(z?)", + "VMULPDYrm", + "VMULPDZ256rm(b?)(k?)(z?)", + "VMULPDZrm(b?)(k?)(z?)", + "VMULPSYrm", + "VMULPSZ256rm(b?)(k?)(z?)", + "VMULPSZrm(b?)(k?)(z?)", + "VPLZCNTDZ256rm(b?)(k?)(z?)", + "VPLZCNTDZrm(b?)(k?)(z?)", + "VPLZCNTQZ256rm(b?)(k?)(z?)", + "VPLZCNTQZrm(b?)(k?)(z?)", + "VPMADDUBSWYrm", + "VPMADDUBSWZ256rm(b?)(k?)(z?)", + "VPMADDUBSWZrm(b?)(k?)(z?)", + "VPMADDWDYrm", + "VPMADDWDZ256rm(b?)(k?)(z?)", + "VPMADDWDZrm(b?)(k?)(z?)", + "VPMULDQYrm", + "VPMULDQZ256rm(b?)(k?)(z?)", + "VPMULDQZrm(b?)(k?)(z?)", + "VPMULHRSWYrm", + "VPMULHRSWZ256rm(b?)(k?)(z?)", + "VPMULHRSWZrm(b?)(k?)(z?)", + "VPMULHUWYrm", + "VPMULHUWZ256rm(b?)(k?)(z?)", + "VPMULHUWZrm(b?)(k?)(z?)", + "VPMULHWYrm", + "VPMULHWZ256rm(b?)(k?)(z?)", + "VPMULHWZrm(b?)(k?)(z?)", + "VPMULLWYrm", + "VPMULLWZ256rm(b?)(k?)(z?)", + "VPMULLWZrm(b?)(k?)(z?)", + "VPMULUDQYrm", + "VPMULUDQZ256rm(b?)(k?)(z?)", + "VPMULUDQZrm(b?)(k?)(z?)", + "VRANGEPDZ256rm(b?)i(k?)(z?)", + "VRANGEPDZrm(b?)i(k?)(z?)", + "VRANGEPSZ256rm(b?)i(k?)(z?)", + "VRANGEPSZrm(b?)i(k?)(z?)", + "VREDUCEPDZ256rm(b?)i(k?)(z?)", + "VREDUCEPDZrm(b?)i(k?)(z?)", + "VREDUCEPSZ256rm(b?)i(k?)(z?)", + "VREDUCEPSZrm(b?)i(k?)(z?)", + "VSCALEFPDZ256rm(b?)(k?)(z?)", + "VSCALEFPDZrm(b?)(k?)(z?)", + "VSCALEFPSZ256rm(b?)(k?)(z?)", + "VSCALEFPSZrm(b?)(k?)(z?)", + "VSUBPDYrm", + "VSUBPDZ256rm(b?)(k?)(z?)", + "VSUBPDZrm(b?)(k?)(z?)", + "VSUBPSYrm", + "VSUBPSZ256rm(b?)(k?)(z?)", + "VSUBPSZrm(b?)(k?)(z?)")>; def SKXWriteResGroup162 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup162], (instregex "FICOM16m")>; -def: InstRW<[SKXWriteResGroup162], (instregex "FICOM32m")>; -def: InstRW<[SKXWriteResGroup162], (instregex "FICOMP16m")>; -def: InstRW<[SKXWriteResGroup162], (instregex "FICOMP32m")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VEXPANDPDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VEXPANDPDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VEXPANDPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VEXPANDPSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VMPSADBWYrmi")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VPEXPANDDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VPEXPANDDZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VPEXPANDQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup162], (instregex "VPEXPANDQZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup162], (instregex "FICOM16m", + "FICOM32m", + "FICOMP16m", + "FICOMP32m", + "VEXPANDPDZ256rm(b?)(k?)(z?)", + "VEXPANDPDZrm(b?)(k?)(z?)", + "VEXPANDPSZ256rm(b?)(k?)(z?)", + "VEXPANDPSZrm(b?)(k?)(z?)", + "VMPSADBWYrmi", + "VPEXPANDDZ256rm(b?)(k?)(z?)", + "VPEXPANDDZrm(b?)(k?)(z?)", + "VPEXPANDQZ256rm(b?)(k?)(z?)", + "VPEXPANDQZrm(b?)(k?)(z?)")>; def SKXWriteResGroup163 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 11; @@ -5314,52 +5296,51 @@ def SKXWriteResGroup164 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup164], (instregex "CVTDQ2PDrm")>; -def: InstRW<[SKXWriteResGroup164], (instregex "VCVTDQ2PDrm")>; +def: InstRW<[SKXWriteResGroup164], (instregex "(V?)CVTDQ2PDrm")>; def SKXWriteResGroup165 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup165], (instregex "CVTSD2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTSD2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTSS2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTSS2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTTSD2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTTSD2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "CVTTSS2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSD2SI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSD2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSD2SIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSD2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSD2USI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSS2SI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSS2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSS2SIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSS2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTSS2USIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSD2SI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSD2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSD2SIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSD2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSD2USI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSS2SI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSS2SI64rm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSS2SIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSS2SIrm")>; -def: InstRW<[SKXWriteResGroup165], (instregex "VCVTTSS2USIZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup165], (instregex "CVTSD2SI64rm", + "CVTSD2SIrm", + "CVTSS2SI64rm", + "CVTSS2SIrm", + "CVTTSD2SI64rm", + "CVTTSD2SIrm", + "CVTTSS2SIrm", + "VCVTSD2SI64Zrm(b?)(k?)(z?)", + "VCVTSD2SI64rm", + "VCVTSD2SIZrm(b?)(k?)(z?)", + "VCVTSD2SIrm", + "VCVTSD2USI64Zrm(b?)(k?)(z?)", + "VCVTSS2SI64Zrm(b?)(k?)(z?)", + "VCVTSS2SI64rm", + "VCVTSS2SIZrm(b?)(k?)(z?)", + "VCVTSS2SIrm", + "VCVTSS2USIZrm(b?)(k?)(z?)", + "VCVTTSD2SI64Zrm(b?)(k?)(z?)", + "VCVTTSD2SI64rm", + "VCVTTSD2SIZrm(b?)(k?)(z?)", + "VCVTTSD2SIrm", + "VCVTTSD2USI64Zrm(b?)(k?)(z?)", + "VCVTTSS2SI64Zrm(b?)(k?)(z?)", + "VCVTTSS2SI64rm", + "VCVTTSS2SIZrm(b?)(k?)(z?)", + "VCVTTSS2SIrm", + "VCVTTSS2USIZrm(b?)(k?)(z?)")>; def SKXWriteResGroup166 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 11; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup166], (instregex "CVTPD2DQrm")>; -def: InstRW<[SKXWriteResGroup166], (instregex "CVTPD2PSrm")>; -def: InstRW<[SKXWriteResGroup166], (instregex "CVTTPD2DQrm")>; -def: InstRW<[SKXWriteResGroup166], (instregex "MMX_CVTPD2PIirm")>; -def: InstRW<[SKXWriteResGroup166], (instregex "MMX_CVTTPD2PIirm")>; +def: InstRW<[SKXWriteResGroup166], (instregex "CVTPD2DQrm", + "CVTPD2PSrm", + "CVTTPD2DQrm", + "MMX_CVTPD2PIirm", + "MMX_CVTTPD2PIirm")>; def SKXWriteResGroup167 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 11; @@ -5373,16 +5354,16 @@ def SKXWriteResGroup168 : SchedWriteRes<[SKXPort1,SKXPort23,SKXPort237,SKXPort06 let NumMicroOps = 6; let ResourceCycles = [1,1,1,2,1]; } -def: InstRW<[SKXWriteResGroup168], (instregex "SHLD(16|32|64)mrCL")>; -def: InstRW<[SKXWriteResGroup168], (instregex "SHRD(16|32|64)mrCL")>; +def: InstRW<[SKXWriteResGroup168], (instregex "SHLD(16|32|64)mrCL", + "SHRD(16|32|64)mrCL")>; def SKXWriteResGroup169 : SchedWriteRes<[SKXPort1,SKXPort06,SKXPort0156]> { let Latency = 11; let NumMicroOps = 7; let ResourceCycles = [2,3,2]; } -def: InstRW<[SKXWriteResGroup169], (instregex "RCL(16|32|64)rCL")>; -def: InstRW<[SKXWriteResGroup169], (instregex "RCR(16|32|64)rCL")>; +def: InstRW<[SKXWriteResGroup169], (instregex "RCL(16|32|64)rCL", + "RCR(16|32|64)rCL")>; def SKXWriteResGroup170 : SchedWriteRes<[SKXPort1,SKXPort06,SKXPort15,SKXPort0156]> { let Latency = 11; @@ -5396,39 +5377,37 @@ def SKXWriteResGroup171 : SchedWriteRes<[SKXPort06,SKXPort0156]> { let NumMicroOps = 11; let ResourceCycles = [2,9]; } -def: InstRW<[SKXWriteResGroup171], (instrs LOOPE)>; -def: InstRW<[SKXWriteResGroup171], (instrs LOOPNE)>; +def: InstRW<[SKXWriteResGroup171], (instrs LOOPE, LOOPNE)>; def SKXWriteResGroup172 : SchedWriteRes<[SKXPort0]> { let Latency = 12; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup172], (instregex "SQRTPSr")>; -def: InstRW<[SKXWriteResGroup172], (instregex "SQRTSSr")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTPSYr")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTPSZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTPSZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTPSr")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTSSZr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup172], (instregex "VSQRTSSr")>; +def: InstRW<[SKXWriteResGroup172], (instregex "SQRTPSr", + "SQRTSSr", + "VSQRTPSYr", + "VSQRTPSZ128r(b?)(k?)(z?)", + "VSQRTPSZ256r(b?)(k?)(z?)", + "VSQRTPSr", + "VSQRTSSZr(b?)(_Int)?(k?)(z?)", + "VSQRTSSr")>; def SKXWriteResGroup173 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 12; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup173], (instregex "PCLMULQDQrm")>; -def: InstRW<[SKXWriteResGroup173], (instregex "VPCLMULQDQrm")>; +def: InstRW<[SKXWriteResGroup173], (instregex "(V?)PCLMULQDQrm")>; def SKXWriteResGroup174 : SchedWriteRes<[SKXPort015]> { let Latency = 12; let NumMicroOps = 3; let ResourceCycles = [3]; } -def: InstRW<[SKXWriteResGroup174], (instregex "VPMULLQZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup174], (instregex "VPMULLQZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup174], (instregex "VPMULLQZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup174], (instregex "VPMULLQZ128rr(b?)(k?)(z?)", + "VPMULLQZ256rr(b?)(k?)(z?)", + "VPMULLQZrr(b?)(k?)(z?)")>; def SKXWriteResGroup175 : SchedWriteRes<[SKXPort5,SKXPort23]> { let Latency = 12; @@ -5442,34 +5421,30 @@ def SKXWriteResGroup176 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup176], (instregex "VCVTSD2USIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup176], (instregex "VCVTSS2USI64Zrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup176], (instregex "VCVTTSD2USIZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup176], (instregex "VCVTTSS2USI64Zrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup176], (instregex "VCVTSD2USIZrm(b?)(k?)(z?)", + "VCVTSS2USI64Zrm(b?)(k?)(z?)", + "VCVTTSD2USIZrm(b?)(k?)(z?)", + "VCVTTSS2USI64Zrm(b?)(k?)(z?)")>; def SKXWriteResGroup177 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 12; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup177], (instregex "VCVTPS2QQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup177], (instregex "VCVTPS2UQQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup177], (instregex "VCVTTPS2QQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup177], (instregex "VCVTTPS2UQQZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup177], (instregex "VCVTPS2QQZrm(b?)(k?)(z?)", + "VCVTPS2UQQZrm(b?)(k?)(z?)", + "VCVTTPS2QQZrm(b?)(k?)(z?)", + "VCVTTPS2UQQZrm(b?)(k?)(z?)")>; def SKXWriteResGroup178 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 12; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup178], (instregex "HADDPDrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "HADDPSrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "HSUBPDrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "HSUBPSrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "VHADDPDrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "VHADDPSrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "VHSUBPDrm")>; -def: InstRW<[SKXWriteResGroup178], (instregex "VHSUBPSrm")>; +def: InstRW<[SKXWriteResGroup178], (instregex "(V?)HADDPDrm", + "(V?)HADDPSrm", + "(V?)HSUBPDrm", + "(V?)HSUBPSrm")>; def SKXWriteResGroup179 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23,SKXPort015]> { let Latency = 12; @@ -5483,14 +5458,14 @@ def SKXWriteResGroup180 : SchedWriteRes<[SKXPort5,SKXPort23]> { let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup180], (instregex "ADD_FI16m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "ADD_FI32m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "SUBR_FI16m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "SUBR_FI32m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "SUB_FI16m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "SUB_FI32m")>; -def: InstRW<[SKXWriteResGroup180], (instregex "VPERMWZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup180], (instregex "VPERMWZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup180], (instregex "ADD_FI16m", + "ADD_FI32m", + "SUBR_FI16m", + "SUBR_FI32m", + "SUB_FI16m", + "SUB_FI32m", + "VPERMWZ256rm(b?)(k?)(z?)", + "VPERMWZrm(b?)(k?)(z?)")>; def SKXWriteResGroup181 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 13; @@ -5504,101 +5479,100 @@ def SKXWriteResGroup182 : SchedWriteRes<[SKXPort5,SKXPort015]> { let NumMicroOps = 4; let ResourceCycles = [1,3]; } -def: InstRW<[SKXWriteResGroup182], (instregex "DPPSrri")>; -def: InstRW<[SKXWriteResGroup182], (instregex "VDPPSYrri")>; -def: InstRW<[SKXWriteResGroup182], (instregex "VDPPSrri")>; +def: InstRW<[SKXWriteResGroup182], (instregex "DPPSrri", + "VDPPSYrri", + "VDPPSrri")>; def SKXWriteResGroup183 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 13; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup183], (instregex "VHADDPDYrm")>; -def: InstRW<[SKXWriteResGroup183], (instregex "VHADDPSYrm")>; -def: InstRW<[SKXWriteResGroup183], (instregex "VHSUBPDYrm")>; -def: InstRW<[SKXWriteResGroup183], (instregex "VHSUBPSYrm")>; -def: InstRW<[SKXWriteResGroup183], (instregex "VPERMI2W128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup183], (instregex "VPERMT2W128rm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup183], (instregex "VHADDPDYrm", + "VHADDPSYrm", + "VHSUBPDYrm", + "VHSUBPSYrm", + "VPERMI2W128rm(b?)(k?)(z?)", + "VPERMT2W128rm(b?)(k?)(z?)")>; def SKXWriteResGroup184 : SchedWriteRes<[SKXPort0]> { let Latency = 14; let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup184], (instregex "DIVPDrr")>; -def: InstRW<[SKXWriteResGroup184], (instregex "DIVSDrr")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVPDYrr")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVPDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVPDZ256rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVPDrr")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVSDZrr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup184], (instregex "VDIVSDrr")>; +def: InstRW<[SKXWriteResGroup184], (instregex "DIVPDrr", + "DIVSDrr", + "VDIVPDYrr", + "VDIVPDZ128rr(b?)(k?)(z?)", + "VDIVPDZ256rr(b?)(k?)(z?)", + "VDIVPDrr", + "VDIVSDZrr(b?)(_Int)?(k?)(z?)", + "VDIVSDrr")>; def SKXWriteResGroup185 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup185], (instregex "AESIMCrm")>; -def: InstRW<[SKXWriteResGroup185], (instregex "VAESIMCrm")>; +def: InstRW<[SKXWriteResGroup185], (instregex "(V?)AESIMCrm")>; def SKXWriteResGroup186 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup186], (instregex "ROUNDPDm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "ROUNDPSm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "ROUNDSDm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "ROUNDSSm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VRNDSCALEPDZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VRNDSCALEPSZ128rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VRNDSCALESDm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VRNDSCALESSm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VROUNDPDm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VROUNDPSm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VROUNDSDm")>; -def: InstRW<[SKXWriteResGroup186], (instregex "VROUNDSSm")>; +def: InstRW<[SKXWriteResGroup186], (instregex "ROUNDPDm", + "ROUNDPSm", + "ROUNDSDm", + "ROUNDSSm", + "VRNDSCALEPDZ128rm(b?)i(k?)(z?)", + "VRNDSCALEPSZ128rm(b?)i(k?)(z?)", + "VRNDSCALESDm(b?)(k?)(z?)", + "VRNDSCALESSm(b?)(k?)(z?)", + "VROUNDPDm", + "VROUNDPSm", + "VROUNDSDm", + "VROUNDSSm")>; def SKXWriteResGroup186_2 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 16; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup186_2], (instregex "PMULLDrm")>; -def: InstRW<[SKXWriteResGroup186_2], (instregex "VPMULLDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup186_2], (instregex "VPMULLDrm")>; +def: InstRW<[SKXWriteResGroup186_2], (instregex "PMULLDrm", + "VPMULLDZ128rm(b?)(k?)(z?)", + "VPMULLDrm")>; def SKXWriteResGroup187 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup187], (instregex "MUL_FI16m")>; -def: InstRW<[SKXWriteResGroup187], (instregex "MUL_FI32m")>; +def: InstRW<[SKXWriteResGroup187], (instregex "MUL_FI16m", + "MUL_FI32m")>; def SKXWriteResGroup188 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 14; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTPD2DQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTPD2PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTPD2UDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTQQ2PSZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTTPD2DQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTTPD2UDQZrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup188], (instregex "VCVTUQQ2PSZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup188], (instregex "VCVTPD2DQZrm(b?)(k?)(z?)", + "VCVTPD2PSZrm(b?)(k?)(z?)", + "VCVTPD2UDQZrm(b?)(k?)(z?)", + "VCVTQQ2PSZrm(b?)(k?)(z?)", + "VCVTTPD2DQZrm(b?)(k?)(z?)", + "VCVTTPD2UDQZrm(b?)(k?)(z?)", + "VCVTUQQ2PSZrm(b?)(k?)(z?)")>; def SKXWriteResGroup189 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 14; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup189], (instregex "VPERMI2W256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup189], (instregex "VPERMI2Wrm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup189], (instregex "VPERMT2W256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup189], (instregex "VPERMT2Wrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup189], (instregex "VPERMI2W256rm(b?)(k?)(z?)", + "VPERMI2Wrm(b?)(k?)(z?)", + "VPERMT2W256rm(b?)(k?)(z?)", + "VPERMT2Wrm(b?)(k?)(z?)")>; def SKXWriteResGroup190 : SchedWriteRes<[SKXPort1,SKXPort06,SKXPort15,SKXPort0156]> { let Latency = 14; @@ -5612,21 +5586,21 @@ def SKXWriteResGroup191 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup191], (instregex "DIVR_FPrST0")>; -def: InstRW<[SKXWriteResGroup191], (instregex "DIVR_FST0r")>; -def: InstRW<[SKXWriteResGroup191], (instregex "DIVR_FrST0")>; +def: InstRW<[SKXWriteResGroup191], (instregex "DIVR_FPrST0", + "DIVR_FST0r", + "DIVR_FrST0")>; def SKXWriteResGroup192 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 15; let NumMicroOps = 3; let ResourceCycles = [1,2]; } -def: InstRW<[SKXWriteResGroup192], (instregex "VRNDSCALEPDZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup192], (instregex "VRNDSCALEPDZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup192], (instregex "VRNDSCALEPSZ256rm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup192], (instregex "VRNDSCALEPSZrm(b?)i(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup192], (instregex "VROUNDYPDm")>; -def: InstRW<[SKXWriteResGroup192], (instregex "VROUNDYPSm")>; +def: InstRW<[SKXWriteResGroup192], (instregex "VRNDSCALEPDZ256rm(b?)i(k?)(z?)", + "VRNDSCALEPDZrm(b?)i(k?)(z?)", + "VRNDSCALEPSZ256rm(b?)i(k?)(z?)", + "VRNDSCALEPSZrm(b?)i(k?)(z?)", + "VROUNDYPDm", + "VROUNDYPSm")>; def SKXWriteResGroup192_2 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 17; @@ -5642,8 +5616,7 @@ def SKXWriteResGroup193 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let NumMicroOps = 4; let ResourceCycles = [1,1,2]; } -def: InstRW<[SKXWriteResGroup193], (instregex "DPPDrmi")>; -def: InstRW<[SKXWriteResGroup193], (instregex "VDPPDrmi")>; +def: InstRW<[SKXWriteResGroup193], (instregex "(V?)DPPDrmi")>; def SKXWriteResGroup194 : SchedWriteRes<[SKXPort1,SKXPort5,SKXPort01,SKXPort23,SKXPort015]> { let Latency = 15; @@ -5664,28 +5637,27 @@ def SKXWriteResGroup196 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup196], (instregex "DIVSSrm")>; -def: InstRW<[SKXWriteResGroup196], (instregex "VDIVSSrm")>; +def: InstRW<[SKXWriteResGroup196], (instregex "(V?)DIVSSrm")>; def SKXWriteResGroup197 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 16; let NumMicroOps = 4; let ResourceCycles = [3,1]; } -def: InstRW<[SKXWriteResGroup197], (instregex "PCMPISTRIrm")>; -def: InstRW<[SKXWriteResGroup197], (instregex "PCMPISTRM128rm")>; -def: InstRW<[SKXWriteResGroup197], (instregex "VPCMPISTRIrm")>; -def: InstRW<[SKXWriteResGroup197], (instregex "VPCMPISTRM128rm")>; +def: InstRW<[SKXWriteResGroup197], (instregex "PCMPISTRIrm", + "PCMPISTRM128rm", + "VPCMPISTRIrm", + "VPCMPISTRM128rm")>; def SKXWriteResGroup198 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let Latency = 16; let NumMicroOps = 4; let ResourceCycles = [2,1,1]; } -def: InstRW<[SKXWriteResGroup198], (instregex "VRCP14PDZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup198], (instregex "VRCP14PSZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup198], (instregex "VRSQRT14PDZm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup198], (instregex "VRSQRT14PSZm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup198], (instregex "VRCP14PDZm(b?)(k?)(z?)", + "VRCP14PSZm(b?)(k?)(z?)", + "VRSQRT14PDZm(b?)(k?)(z?)", + "VRSQRT14PSZm(b?)(k?)(z?)")>; def SKXWriteResGroup199 : SchedWriteRes<[SKXPort4,SKXPort23,SKXPort237,SKXPort06,SKXPort15,SKXPort0156]> { let Latency = 16; @@ -5706,12 +5678,12 @@ def SKXWriteResGroup201 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup201], (instregex "DIVPSrm")>; -def: InstRW<[SKXWriteResGroup201], (instregex "SQRTSSm")>; -def: InstRW<[SKXWriteResGroup201], (instregex "VDIVPSZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup201], (instregex "VDIVPSrm")>; -def: InstRW<[SKXWriteResGroup201], (instregex "VDIVSSZrm(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup201], (instregex "VSQRTSSm")>; +def: InstRW<[SKXWriteResGroup201], (instregex "DIVPSrm", + "SQRTSSm", + "VDIVPSZ128rm(b?)(k?)(z?)", + "VDIVPSrm", + "VDIVSSZrm(_Int)?(k?)(z?)", + "VSQRTSSm")>; def SKXWriteResGroup202 : SchedWriteRes<[SKXPort0,SKXPort1,SKXPort5,SKXPort6,SKXPort05,SKXPort0156]> { let Latency = 17; @@ -5725,26 +5697,26 @@ def SKXWriteResGroup203 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup203], (instregex "SQRTPDr")>; -def: InstRW<[SKXWriteResGroup203], (instregex "SQRTSDr")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTPDYr")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTPDZ128r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTPDZ256r(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTPDr")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTSDZr(b?)(_Int)?(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup203], (instregex "VSQRTSDr")>; +def: InstRW<[SKXWriteResGroup203], (instregex "SQRTPDr", + "SQRTSDr", + "VSQRTPDYr", + "VSQRTPDZ128r(b?)(k?)(z?)", + "VSQRTPDZ256r(b?)(k?)(z?)", + "VSQRTPDr", + "VSQRTSDZr(b?)(_Int)?(k?)(z?)", + "VSQRTSDr")>; def SKXWriteResGroup204 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 18; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup204], (instregex "SQRTPSm")>; -def: InstRW<[SKXWriteResGroup204], (instregex "VDIVPSYrm")>; -def: InstRW<[SKXWriteResGroup204], (instregex "VDIVPSZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup204], (instregex "VSQRTPSZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup204], (instregex "VSQRTPSm")>; -def: InstRW<[SKXWriteResGroup204], (instregex "VSQRTSSZm(_Int)?(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup204], (instregex "SQRTPSm", + "VDIVPSYrm", + "VDIVPSZ256rm(b?)(k?)(z?)", + "VSQRTPSZ128m(b?)(k?)(z?)", + "VSQRTPSm", + "VSQRTSSZm(_Int)?(k?)(z?)")>; def SKXWriteResGroup205 : SchedWriteRes<[SKXPort23,SKXPort015]> { let Latency = 18; @@ -5758,16 +5730,14 @@ def SKXWriteResGroup206 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort0156]> { let NumMicroOps = 8; let ResourceCycles = [4,3,1]; } -def: InstRW<[SKXWriteResGroup206], (instregex "PCMPESTRIrr")>; -def: InstRW<[SKXWriteResGroup206], (instregex "VPCMPESTRIrr")>; +def: InstRW<[SKXWriteResGroup206], (instregex "(V?)PCMPESTRIrr")>; def SKXWriteResGroup207 : SchedWriteRes<[SKXPort5,SKXPort6,SKXPort06,SKXPort0156]> { let Latency = 18; let NumMicroOps = 8; let ResourceCycles = [1,1,1,5]; } -def: InstRW<[SKXWriteResGroup207], (instregex "CPUID")>; -def: InstRW<[SKXWriteResGroup207], (instrs RDTSC)>; +def: InstRW<[SKXWriteResGroup207], (instrs CPUID, RDTSC)>; def SKXWriteResGroup208 : SchedWriteRes<[SKXPort1,SKXPort23,SKXPort237,SKXPort06,SKXPort15,SKXPort0156]> { let Latency = 18; @@ -5781,10 +5751,10 @@ def SKXWriteResGroup209 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup209], (instregex "DIVSDrm")>; -def: InstRW<[SKXWriteResGroup209], (instregex "VDIVSDrm")>; -def: InstRW<[SKXWriteResGroup209], (instregex "VSQRTPSYm")>; -def: InstRW<[SKXWriteResGroup209], (instregex "VSQRTPSZ256m(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup209], (instregex "DIVSDrm", + "VDIVSDrm", + "VSQRTPSYm", + "VSQRTPSZ256m(b?)(k?)(z?)")>; def SKXWriteResGroup210 : SchedWriteRes<[SKXPort0,SKXPort015]> { let Latency = 19; @@ -5798,24 +5768,22 @@ def SKXWriteResGroup211 : SchedWriteRes<[SKXPort23,SKXPort015]> { let NumMicroOps = 4; let ResourceCycles = [1,3]; } -def: InstRW<[SKXWriteResGroup211], (instregex "VPMULLQZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup211], (instregex "VPMULLQZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup211], (instregex "VPMULLQZ256rm(b?)(k?)(z?)", + "VPMULLQZrm(b?)(k?)(z?)")>; def SKXWriteResGroup212 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 19; let NumMicroOps = 5; let ResourceCycles = [1,1,3]; } -def: InstRW<[SKXWriteResGroup212], (instregex "DPPSrmi")>; -def: InstRW<[SKXWriteResGroup212], (instregex "VDPPSrmi")>; +def: InstRW<[SKXWriteResGroup212], (instregex "(V?)DPPSrmi")>; def SKXWriteResGroup213 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort015,SKXPort0156]> { let Latency = 19; let NumMicroOps = 9; let ResourceCycles = [4,3,1,1]; } -def: InstRW<[SKXWriteResGroup213], (instregex "PCMPESTRM128rr")>; -def: InstRW<[SKXWriteResGroup213], (instregex "VPCMPESTRM128rr")>; +def: InstRW<[SKXWriteResGroup213], (instregex "(V?)PCMPESTRM128rr")>; def SKXWriteResGroup214 : SchedWriteRes<[]> { let Latency = 20; @@ -5830,19 +5798,18 @@ def SKXWriteResGroup215 : SchedWriteRes<[SKXPort0]> { let NumMicroOps = 1; let ResourceCycles = [1]; } -def: InstRW<[SKXWriteResGroup215], (instregex "DIV_FPrST0")>; -def: InstRW<[SKXWriteResGroup215], (instregex "DIV_FST0r")>; -def: InstRW<[SKXWriteResGroup215], (instregex "DIV_FrST0")>; +def: InstRW<[SKXWriteResGroup215], (instregex "DIV_FPrST0", + "DIV_FST0r", + "DIV_FrST0")>; def SKXWriteResGroup216 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 20; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup216], (instregex "DIVPDrm")>; -def: InstRW<[SKXWriteResGroup216], (instregex "VDIVPDZ128rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup216], (instregex "VDIVPDrm")>; -def: InstRW<[SKXWriteResGroup216], (instregex "VDIVSDZrm(_Int)?(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup216], (instregex "(V?)DIVPDrm", + "VDIVPDZ128rm(b?)(k?)(z?)", + "VDIVSDZrm(_Int)?(k?)(z?)")>; def SKXWriteResGroup217 : SchedWriteRes<[SKXPort5,SKXPort23,SKXPort015]> { let Latency = 20; @@ -5866,9 +5833,9 @@ def SKXWriteResGroup219 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort6,SKXPort23,SK let NumMicroOps = 8; let ResourceCycles = [1,1,1,1,1,1,2]; } -def: InstRW<[SKXWriteResGroup219], (instregex "INSB")>; -def: InstRW<[SKXWriteResGroup219], (instregex "INSL")>; -def: InstRW<[SKXWriteResGroup219], (instregex "INSW")>; +def: InstRW<[SKXWriteResGroup219], (instregex "INSB", + "INSL", + "INSW")>; def SKXWriteResGroup220 : SchedWriteRes<[SKXPort5,SKXPort6,SKXPort0156]> { let Latency = 20; @@ -5882,24 +5849,23 @@ def SKXWriteResGroup221 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort015]> { let NumMicroOps = 11; let ResourceCycles = [3,6,2]; } -def: InstRW<[SKXWriteResGroup221], (instregex "AESKEYGENASSIST128rr")>; -def: InstRW<[SKXWriteResGroup221], (instregex "VAESKEYGENASSIST128rr")>; +def: InstRW<[SKXWriteResGroup221], (instregex "(V?)AESKEYGENASSIST128rr")>; def SKXWriteResGroup222 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 21; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup222], (instregex "VDIVPDYrm")>; -def: InstRW<[SKXWriteResGroup222], (instregex "VDIVPDZ256rm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup222], (instregex "VDIVPDYrm", + "VDIVPDZ256rm(b?)(k?)(z?)")>; def SKXWriteResGroup223 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 22; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup223], (instregex "DIV_F32m")>; -def: InstRW<[SKXWriteResGroup223], (instregex "DIV_F64m")>; +def: InstRW<[SKXWriteResGroup223], (instregex "DIV_F32m", + "DIV_F64m")>; def SKXWriteResGroup224 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015,SKXPort0156]> { let Latency = 22; @@ -5958,24 +5924,23 @@ def SKXWriteResGroup225 : SchedWriteRes<[SKXPort5,SKXPort01,SKXPort015]> { let NumMicroOps = 14; let ResourceCycles = [5,5,4]; } -def: InstRW<[SKXWriteResGroup225], (instregex "VPCONFLICTDZ128rr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup225], (instregex "VPCONFLICTQZ256rr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup225], (instregex "VPCONFLICTDZ128rr(b?)(k?)(z?)", + "VPCONFLICTQZ256rr(b?)(k?)(z?)")>; def SKXWriteResGroup226 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 23; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup226], (instregex "SQRTSDm")>; -def: InstRW<[SKXWriteResGroup226], (instregex "VSQRTSDm")>; +def: InstRW<[SKXWriteResGroup226], (instregex "(V?)SQRTSDm")>; def SKXWriteResGroup227 : SchedWriteRes<[SKXPort0,SKXPort015]> { let Latency = 23; let NumMicroOps = 3; let ResourceCycles = [2,1]; } -def: InstRW<[SKXWriteResGroup227], (instregex "VDIVPDZrr(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup227], (instregex "VDIVPSZrr(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup227], (instregex "VDIVPDZrr(b?)(k?)(z?)", + "VDIVPSZrr(b?)(k?)(z?)")>; def SKXWriteResGroup228 : SchedWriteRes<[SKXPort0,SKXPort4,SKXPort5,SKXPort23,SKXPort237,SKXPort06,SKXPort0156]> { let Latency = 23; @@ -5989,10 +5954,10 @@ def SKXWriteResGroup229 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup229], (instregex "SQRTPDm")>; -def: InstRW<[SKXWriteResGroup229], (instregex "VSQRTPDZ128m(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup229], (instregex "VSQRTPDm")>; -def: InstRW<[SKXWriteResGroup229], (instregex "VSQRTSDZm(_Int)?(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup229], (instregex "SQRTPDm", + "VSQRTPDZ128m(b?)(k?)(z?)", + "VSQRTPDm", + "VSQRTSDZm(_Int)?(k?)(z?)")>; def SKXWriteResGroup230 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let Latency = 24; @@ -6006,24 +5971,23 @@ def SKXWriteResGroup231 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23,SKXPort0156 let NumMicroOps = 9; let ResourceCycles = [4,3,1,1]; } -def: InstRW<[SKXWriteResGroup231], (instregex "PCMPESTRIrm")>; -def: InstRW<[SKXWriteResGroup231], (instregex "VPCMPESTRIrm")>; +def: InstRW<[SKXWriteResGroup231], (instregex "(V?)PCMPESTRIrm")>; def SKXWriteResGroup232 : SchedWriteRes<[SKXPort0,SKXPort23]> { let Latency = 25; let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup232], (instregex "VSQRTPDYm")>; -def: InstRW<[SKXWriteResGroup232], (instregex "VSQRTPDZ256m(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup232], (instregex "VSQRTPDYm", + "VSQRTPDZ256m(b?)(k?)(z?)")>; def SKXWriteResGroup233 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let Latency = 25; let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup233], (instregex "DIV_FI16m")>; -def: InstRW<[SKXWriteResGroup233], (instregex "DIV_FI32m")>; +def: InstRW<[SKXWriteResGroup233], (instregex "DIV_FI16m", + "DIV_FI32m")>; def SKXWriteResGroup234 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015,SKXPort0156]> { let Latency = 25; @@ -6041,16 +6005,14 @@ def SKXWriteResGroup235 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23,SKXPort015, let NumMicroOps = 10; let ResourceCycles = [4,3,1,1,1]; } -def: InstRW<[SKXWriteResGroup235], (instregex "PCMPESTRM128rm")>; -def: InstRW<[SKXWriteResGroup235], (instregex "VPCMPESTRM128rm")>; +def: InstRW<[SKXWriteResGroup235], (instregex "(V?)PCMPESTRM128rm")>; def SKXWriteResGroup236 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23,SKXPort015]> { let Latency = 25; let NumMicroOps = 11; let ResourceCycles = [3,6,1,1]; } -def: InstRW<[SKXWriteResGroup236], (instregex "AESKEYGENASSIST128rm")>; -def: InstRW<[SKXWriteResGroup236], (instregex "VAESKEYGENASSIST128rm")>; +def: InstRW<[SKXWriteResGroup236], (instregex "(V?)AESKEYGENASSIST128rm")>; def SKXWriteResGroup237 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let Latency = 26; @@ -6074,8 +6036,8 @@ def SKXWriteResGroup239 : SchedWriteRes<[SKXPort0,SKXPort23]> { let NumMicroOps = 2; let ResourceCycles = [1,1]; } -def: InstRW<[SKXWriteResGroup239], (instregex "DIVR_F32m")>; -def: InstRW<[SKXWriteResGroup239], (instregex "DIVR_F64m")>; +def: InstRW<[SKXWriteResGroup239], (instregex "DIVR_F32m", + "DIVR_F64m")>; def SKXWriteResGroup240 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015,SKXPort0156]> { let Latency = 27; @@ -6104,8 +6066,8 @@ def SKXWriteResGroup243 : SchedWriteRes<[SKXPort0,SKXPort5,SKXPort23]> { let NumMicroOps = 3; let ResourceCycles = [1,1,1]; } -def: InstRW<[SKXWriteResGroup243], (instregex "DIVR_FI16m")>; -def: InstRW<[SKXWriteResGroup243], (instregex "DIVR_FI32m")>; +def: InstRW<[SKXWriteResGroup243], (instregex "DIVR_FI16m", + "DIVR_FI32m")>; def SKXWriteResGroup244 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort015]> { let Latency = 30; @@ -6134,16 +6096,16 @@ def SKXWriteResGroup247 : SchedWriteRes<[SKXPort5,SKXPort6,SKXPort23,SKXPort06,S let NumMicroOps = 23; let ResourceCycles = [1,5,3,4,10]; } -def: InstRW<[SKXWriteResGroup247], (instregex "IN(8|16|32)ri")>; -def: InstRW<[SKXWriteResGroup247], (instregex "IN(8|16|32)rr")>; +def: InstRW<[SKXWriteResGroup247], (instregex "IN(8|16|32)ri", + "IN(8|16|32)rr")>; def SKXWriteResGroup248 : SchedWriteRes<[SKXPort5,SKXPort6,SKXPort23,SKXPort237,SKXPort06,SKXPort0156]> { let Latency = 35; let NumMicroOps = 23; let ResourceCycles = [1,5,2,1,4,10]; } -def: InstRW<[SKXWriteResGroup248], (instregex "OUT(8|16|32)ir")>; -def: InstRW<[SKXWriteResGroup248], (instregex "OUT(8|16|32)rr")>; +def: InstRW<[SKXWriteResGroup248], (instregex "OUT(8|16|32)ir", + "OUT(8|16|32)rr")>; def SKXWriteResGroup249 : SchedWriteRes<[SKXPort5,SKXPort01,SKXPort015]> { let Latency = 37; @@ -6200,8 +6162,8 @@ def SKXWriteResGroup256 : SchedWriteRes<[SKXPort5,SKXPort01,SKXPort23,SKXPort015 let NumMicroOps = 22; let ResourceCycles = [9,7,1,5]; } -def: InstRW<[SKXWriteResGroup256], (instregex "VPCONFLICTDZ256rm(b?)(k?)(z?)")>; -def: InstRW<[SKXWriteResGroup256], (instregex "VPCONFLICTQZrm(b?)(k?)(z?)")>; +def: InstRW<[SKXWriteResGroup256], (instregex "VPCONFLICTDZ256rm(b?)(k?)(z?)", + "VPCONFLICTQZrm(b?)(k?)(z?)")>; def SKXWriteResGroup258 : SchedWriteRes<[SKXPort0,SKXPort23,SKXPort05,SKXPort06,SKXPort0156]> { let Latency = 62;