lib/Target/X86/X86ScheduleBdVer2.td

   1 //=- X86ScheduleBdVer2.td - X86 BdVer2 (Piledriver) Scheduling * tablegen -*-=//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the machine model for AMD bdver2 (Piledriver) to support
  10 // instruction scheduling and other instruction cost heuristics.
  11 // Based on:
  12 //  * AMD Software Optimization Guide for AMD Family 15h Processors.
  13 //    https://support.amd.com/TechDocs/47414_15h_sw_opt_guide.pdf
  14 //  * The microarchitecture of Intel, AMD and VIA CPUs, By Agner Fog
  15 //    http://www.agner.org/optimize/microarchitecture.pdf
  16 //  * https://www.realworldtech.com/bulldozer/
  17 //    Yes, that is for Bulldozer aka bdver1, not Piledriver aka bdver2.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 def BdVer2Model : SchedMachineModel {
  22   let IssueWidth = 4; // Up to 4 IPC can be decoded, issued, retired.
  23   let MicroOpBufferSize = 128; // RCU reorder buffer size, which is unconfirmed.
  24   let LoopMicroOpBufferSize = -1; // There does not seem to be a loop buffer.
  25   let LoadLatency = 4; // L1 data cache has a 4-cycle load-to-use latency.
  26   let HighLatency = 25; // FIXME: any better choice?
  27   let MispredictPenalty = 20; // Minimum branch misdirection penalty.
  28
  29   let PostRAScheduler = 1; // Enable Post RegAlloc Scheduler pass.
  30
  31   // FIXME: Incomplete. This flag is set to allow the scheduler to assign
  32   //        a default model to unrecognized opcodes.
  33   let CompleteModel = 0;
  34 } // SchedMachineModel
  35
  36 let SchedModel = BdVer2Model in {
  37
  38
  39 //===----------------------------------------------------------------------===//
  40 // Pipes
  41 //===----------------------------------------------------------------------===//
  42
  43 // There are total of eight pipes.
  44
  45 //===----------------------------------------------------------------------===//
  46 // Integer execution pipes
  47 //
  48
  49 // Two EX (ALU) pipes.
  50 def PdEX0  : ProcResource<1>; // ALU, Integer Pipe0
  51 def PdEX1  : ProcResource<1>; // ALU, Integer Pipe1
  52 def PdEX01 : ProcResGroup<[PdEX0, PdEX1]>;
  53
  54 // Two AGLU pipes, identical.
  55 def PdAGLU01 : ProcResource<2>; // AGU, Integer Pipe[23]
  56
  57 //===----------------------------------------------------------------------===//
  58 // Floating point execution pipes
  59 //
  60
  61 // Four FPU pipes.
  62
  63 def PdFPU0 : ProcResource<1>; // Vector/FPU Pipe0
  64 def PdFPU1 : ProcResource<1>; // Vector/FPU Pipe1
  65 def PdFPU2 : ProcResource<1>; // Vector/FPU Pipe2
  66 def PdFPU3 : ProcResource<1>; // Vector/FPU Pipe3
  67
  68 // FPU grouping
  69 def PdFPU01 : ProcResGroup<[PdFPU0, PdFPU1]>;
  70 def PdFPU23 : ProcResGroup<[PdFPU2, PdFPU3]>;
  71
  72
  73 //===----------------------------------------------------------------------===//
  74 // RCU
  75 //===----------------------------------------------------------------------===//
  76
  77 // The Retire Control Unit on Piledriver can retire up to 4 macro-ops per cycle.
  78 // On the other hand, the RCU reorder buffer size for Piledriver does not
  79 // seem be specified in any trustworthy source.
  80 // But as per https://www.realworldtech.com/bulldozer/6/ the Bulldozer had
  81 // RCU reorder buffer size of 128. So that is a good guess for now.
  82 def PdRCU : RetireControlUnit<128, 4>;
  83
  84
  85 //===----------------------------------------------------------------------===//
  86 // Pipelines
  87 //===----------------------------------------------------------------------===//
  88
  89 // There are total of two pipelines, each one with it's own scheduler.
  90
  91 //===----------------------------------------------------------------------===//
  92 // Integer Pipeline Scheduling
  93 //
  94
  95 // There is one Integer Scheduler per core.
  96
  97 // Integer physical register file has 96 registers of 64-bit.
  98 def PdIntegerPRF : RegisterFile<96, [GR64, CCR]>;
  99
 100 // Unified Integer, Memory Scheduler has 40 entries.
 101 def PdEX : ProcResGroup<[PdEX0, PdEX1, PdAGLU01]> {
 102   // Up to 4 IPC can be decoded, issued, retired.
 103   let BufferSize = 40;
 104 }
 105
 106
 107 //===----------------------------------------------------------------------===//
 108 // FPU Pipeline Scheduling
 109 //
 110
 111 // The FPU unit is shared between the two cores.
 112
 113 // FP physical register file has 160 registers of 128-bit.
 114 // Operations on 256-bit data types are cracked into two COPs.
 115 def PdFpuPRF : RegisterFile<160, [VR64, VR128, VR256], [1, 1, 2]>;
 116
 117 // Unified FP Scheduler has 64 entries,
 118 def PdFPU : ProcResGroup<[PdFPU0, PdFPU1, PdFPU2, PdFPU3]> {
 119   // Up to 4 IPC can be decoded, issued, retired.
 120   let BufferSize = 64;
 121 }
 122
 123
 124 //===----------------------------------------------------------------------===//
 125 // Functional units
 126 //===----------------------------------------------------------------------===//
 127
 128 //===----------------------------------------------------------------------===//
 129 // Load-Store Units
 130 //
 131
 132 let Super = PdAGLU01 in
 133 def PdLoad  : ProcResource<2> {
 134   // For Piledriver, the load queue is 40 entries deep.
 135   let BufferSize = 40;
 136 }
 137
 138 def PdLoadQueue : LoadQueue<PdLoad>;
 139
 140 let Super = PdAGLU01 in
 141 def PdStore : ProcResource<1> {
 142   // For Piledriver, the store queue is 24 entries deep.
 143   let BufferSize = 24;
 144 }
 145
 146 def PdStoreQueue : StoreQueue<PdStore>;
 147
 148 //===----------------------------------------------------------------------===//
 149 // Integer Execution Units
 150 //
 151
 152 def PdDiv    : ProcResource<1>; // PdEX0; unpipelined integer division
 153 def PdCount  : ProcResource<1>; // PdEX0; POPCNT, LZCOUNT
 154
 155 def PdMul    : ProcResource<1>; // PdEX1; integer multiplication
 156 def PdBranch : ProcResource<1>; // PdEX1; JMP, fused branches
 157
 158 //===----------------------------------------------------------------------===//
 159 // Floating-Point Units
 160 //
 161
 162 // Two FMAC/FPFMA units.
 163 def PdFPFMA  : ProcResource<2>; // PdFPU0, PdFPU1
 164
 165 // One 128-bit integer multiply-accumulate unit.
 166 def PdFPMMA  : ProcResource<1>; // PdFPU0
 167
 168 // One fp conversion unit.
 169 def PdFPCVT  : ProcResource<1>; // PdFPU0
 170
 171 // One unit for shuffles, packs, permutes, shifts.
 172 def PdFPXBR  : ProcResource<1>; // PdFPU1
 173
 174 // Two 128-bit packed integer units.
 175 def PdFPMAL  : ProcResource<2>; // PdFPU2, PdFPU3
 176
 177 // One FP store unit.
 178 def PdFPSTO  : ProcResource<1>; // PdFPU3
 179
 180
 181 //===----------------------------------------------------------------------===//
 182 // Basic helper classes.
 183 //===----------------------------------------------------------------------===//
 184
 185 // Many SchedWrites are defined in pairs with and without a folded load.
 186 // Instructions with folded loads are usually micro-fused, so they only appear
 187 // as two micro-ops when dispatched by the schedulers.
 188 // This multiclass defines the resource usage for variants with and without
 189 // folded loads.
 190 multiclass PdWriteRes<SchedWrite SchedRW,
 191                       list<ProcResourceKind> ExePorts, int Lat = 1,
 192                       list<int> Res = [], int UOps = 1> {
 193   def : WriteRes<SchedRW, ExePorts> {
 194     let Latency = Lat;
 195     let ResourceCycles = Res;
 196     let NumMicroOps = UOps;
 197   }
 198 }
 199
 200 multiclass __pdWriteResPair<X86FoldableSchedWrite SchedRW,
 201                             list<ProcResourceKind> ExePorts, int Lat,
 202                             list<int> Res, int UOps,
 203                             int LoadLat, int LoadRes, int LoadUOps> {
 204   defm : PdWriteRes<SchedRW, ExePorts, Lat, Res, UOps>;
 205
 206   defm : PdWriteRes<SchedRW.Folded,
 207                     !listconcat([PdLoad], ExePorts),
 208                     !add(Lat, LoadLat),
 209                     !if(!and(!empty(Res), !eq(LoadRes, 1)),
 210                       [],
 211                       !listconcat([LoadRes], Res)),
 212                     !add(UOps, LoadUOps)>;
 213 }
 214
 215 multiclass PdWriteResExPair<X86FoldableSchedWrite SchedRW,
 216                             list<ProcResourceKind> ExePorts, int Lat = 1,
 217                             list<int> Res = [], int UOps = 1,
 218                             int LoadUOps = 0> {
 219   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
 220                           /*LoadLat*/4, /*LoadRes*/1, LoadUOps>;
 221 }
 222
 223 multiclass PdWriteResXMMPair<X86FoldableSchedWrite SchedRW,
 224                              list<ProcResourceKind> ExePorts, int Lat = 1,
 225                              list<int> Res = [], int UOps = 1,
 226                              int LoadUOps = 0> {
 227   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
 228                            /*LoadLat*/5, /*LoadRes*/1, LoadUOps>;
 229 }
 230
 231 multiclass PdWriteResYMMPair<X86FoldableSchedWrite SchedRW,
 232                              list<ProcResourceKind> ExePorts, int Lat,
 233                              list<int> Res, int UOps = 2,
 234                              int LoadUOps = 0> {
 235   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
 236                            /*LoadLat*/5, /*LoadRes*/2, LoadUOps>;
 237 }
 238
 239 //===----------------------------------------------------------------------===//
 240 // Here be dragons.
 241 //===----------------------------------------------------------------------===//
 242
 243 // L1 data cache has a 4-cycle load-to-use latency, so ReadAfterLd registers
 244 // needn't be available until 4 cycles after the memory operand.
 245 def : ReadAdvance<ReadAfterLd, 4>;
 246
 247 // Vector loads are 5 cycles, so ReadAfterVec*Ld registers needn't be available
 248 // until 5 cycles after the memory operand.
 249 def : ReadAdvance<ReadAfterVecLd, 5>;
 250 def : ReadAdvance<ReadAfterVecXLd, 5>;
 251 def : ReadAdvance<ReadAfterVecYLd, 5>;
 252
 253 // Transfer from int domain to ivec domain incurs additional latency of 8..10cy
 254 // Reference: Agner, Microarchitecture, "AMD Bulldozer, Piledriver, Steamroller
 255 // and Excavator pipeline", "Data delay between different execution domains"
 256 def : ReadAdvance<ReadInt2Fpu, -10>;
 257
 258 // A folded store needs a cycle on the PdStore for the store data.
 259 def : WriteRes<WriteRMW, [PdStore]>;
 260
 261 ////////////////////////////////////////////////////////////////////////////////
 262 // Loads, stores, and moves, not folded with other operations.
 263 ////////////////////////////////////////////////////////////////////////////////
 264
 265 def : WriteRes<WriteLoad,    [PdLoad]> { let Latency = 5; }
 266 def : WriteRes<WriteStore,   [PdStore]>;
 267 def : WriteRes<WriteStoreNT, [PdStore]>;
 268 def : WriteRes<WriteMove,    [PdEX01]>;
 269
 270 // Load/store MXCSR.
 271 // FIXME: These are copy and pasted from WriteLoad/Store.
 272 def : WriteRes<WriteLDMXCSR, [PdLoad]> { let Latency = 5; }
 273 def : WriteRes<WriteSTMXCSR, [PdStore]> { let NumMicroOps = 2; }
 274
 275 // Treat misc copies as a move.
 276 def : InstRW<[WriteMove], (instrs COPY)>;
 277
 278 ////////////////////////////////////////////////////////////////////////////////
 279 // Idioms that clear a register, like xorps %xmm0, %xmm0.
 280 // These can often bypass execution ports completely.
 281 ////////////////////////////////////////////////////////////////////////////////
 282
 283 def : WriteRes<WriteZero, [/*No ExePorts*/]>;
 284
 285 ////////////////////////////////////////////////////////////////////////////////
 286 // Branches don't produce values, so they have no latency, but they still
 287 // consume resources. Indirect branches can fold loads.
 288 ////////////////////////////////////////////////////////////////////////////////
 289
 290 defm : PdWriteResExPair<WriteJump,  [PdEX1, PdBranch]>;
 291
 292 ////////////////////////////////////////////////////////////////////////////////
 293 // Special case scheduling classes.
 294 ////////////////////////////////////////////////////////////////////////////////
 295
 296 def : WriteRes<WriteSystem,     [PdEX01]> { let Latency = 100; }
 297 def : WriteRes<WriteMicrocoded, [PdEX01]> { let Latency = 100; }
 298 def : WriteRes<WriteFence,      [PdStore]>;
 299
 300 def PdWriteXLAT : SchedWriteRes<[PdEX01]> {
 301   let Latency = 6;
 302 }
 303 def : InstRW<[PdWriteXLAT], (instrs XLAT)>;
 304
 305 def PdWriteLARrr : SchedWriteRes<[PdEX01]> {
 306   let Latency = 184;
 307   let NumMicroOps = 45;
 308 }
 309 def : InstRW<[PdWriteLARrr], (instregex "LAR(16|32|64)rr",
 310                                         "LSL(16|32|64)rr")>;
 311
 312 // Nops don't have dependencies, so there's no actual latency, but we set this
 313 // to '1' to tell the scheduler that the nop uses an ALU slot for a cycle.
 314 def : WriteRes<WriteNop, [PdEX01]>;
 315
 316 ////////////////////////////////////////////////////////////////////////////////
 317 // Arithmetic.
 318 ////////////////////////////////////////////////////////////////////////////////
 319
 320 defm : PdWriteResExPair<WriteALU,     [PdEX01]>;
 321
 322 def PdWriteLXADD : SchedWriteRes<[PdEX01]> {
 323   let Latency = 6;
 324   let NumMicroOps = 4;
 325 }
 326 def : InstRW<[PdWriteLXADD], (instrs LXADD8, LXADD16, LXADD32, LXADD64)>;
 327
 328 def PdWriteBMI1 : SchedWriteRes<[PdEX01]> {
 329   let Latency = 2;
 330   let NumMicroOps = 2;
 331 }
 332 def : InstRW<[PdWriteBMI1],
 333              (instrs BLCFILL32rr, BLCFILL64rr, BLCI32rr, BLCI64rr,
 334                      BLCIC32rr, BLCIC64rr, BLCMSK32rr, BLCMSK64rr,
 335                      BLCS32rr, BLCS64rr, BLSFILL32rr, BLSFILL64rr,
 336                      BLSIC32rr, BLSIC64rr, T1MSKC32rr, T1MSKC64rr,
 337                      TZMSK32rr, TZMSK64rr)>;
 338
 339 def PdWriteBMI1m : SchedWriteRes<[PdEX01]> {
 340   let Latency = 6;
 341   let NumMicroOps = 2;
 342 }
 343 def : InstRW<[PdWriteBMI1m],
 344              (instrs BLCFILL32rm, BLCFILL64rm, BLCI32rm, BLCI64rm,
 345                      BLCIC32rm, BLCIC64rm, BLCMSK32rm, BLCMSK64rm,
 346                      BLCS32rm, BLCS64rm, BLSFILL32rm, BLSFILL64rm,
 347                      BLSIC32rm, BLSIC64rm, T1MSKC32rm, T1MSKC64rm,
 348                      TZMSK32rm, TZMSK64rm)>;
 349
 350 defm : PdWriteResExPair<WriteADC,    [PdEX01],                  1,  [2]>;
 351
 352 defm : PdWriteRes<WriteBSWAP32,      [PdEX1]>;
 353 defm : PdWriteRes<WriteBSWAP64,      [PdEX1]>;
 354 defm : PdWriteRes<WriteCMPXCHG,      [PdEX1],                   3,  [],       5>;
 355 defm : PdWriteRes<WriteCMPXCHGRMW,   [PdEX1, PdStore, PdLoad],  3,  [], 2>;
 356 defm : PdWriteRes<WriteXCHG,         [PdEX1],                   1,  [],       2>;
 357
 358 def PdWriteCMPXCHG8rr : SchedWriteRes<[PdEX1]> {
 359   let Latency = 3;
 360   let NumMicroOps = 3;
 361 }
 362 def : InstRW<[PdWriteCMPXCHG8rr], (instrs CMPXCHG8rr)>;
 363
 364 def PdWriteCMPXCHG8rm : SchedWriteRes<[PdEX1]> {
 365   let Latency = 3;
 366   let NumMicroOps = 5;
 367 }
 368 def : InstRW<[PdWriteCMPXCHG8rm], (instrs CMPXCHG8rm)>;
 369
 370 def PdWriteCMPXCHG16rm_CMPXCHG32rm_CMPXCHG64rm : SchedWriteRes<[PdEX1]> {
 371   let Latency = 3;
 372   let NumMicroOps = 6;
 373 }
 374 def : InstRW<[PdWriteCMPXCHG16rm_CMPXCHG32rm_CMPXCHG64rm],
 375              (instrs CMPXCHG16rm, CMPXCHG32rm, CMPXCHG64rm)>;
 376
 377 def PdWriteCMPXCHG8B : SchedWriteRes<[PdEX1]> {
 378   let Latency = 3;
 379   let NumMicroOps = 18;
 380 }
 381 def : InstRW<[PdWriteCMPXCHG8B], (instrs CMPXCHG8B)>;
 382
 383 def PdWriteCMPXCHG16B : SchedWriteRes<[PdEX1]> {
 384   let Latency = 3;
 385   let NumMicroOps = 22;
 386 }
 387 def : InstRW<[PdWriteCMPXCHG16B], (instrs CMPXCHG16B)>;
 388
 389 def PdWriteXCHG16rr : SchedWriteRes<[PdEX1]> {
 390   let Latency = 2;
 391   let NumMicroOps = 2;
 392 }
 393 def : InstRW<[PdWriteXCHG16rr], (instrs XCHG16rr)>;
 394
 395 def PdWriteXADD : SchedWriteRes<[PdEX1]> {
 396   let Latency = 2;
 397   let NumMicroOps = 4;
 398 }
 399 def : InstRW<[PdWriteXADD], (instrs XADD8rr, XADD16rr, XADD32rr, XADD64rr)>;
 400
 401 def PdWriteXADDm : SchedWriteRes<[PdEX1]> {
 402 let Latency = 6;
 403 let NumMicroOps = 4;
 404 }
 405 def : InstRW<[PdWriteXADDm], (instrs XADD8rm, XADD16rm, XADD32rm, XADD64rm)>;
 406
 407 defm : PdWriteResExPair<WriteIMul8,     [PdEX1, PdMul],          4>;
 408 defm : PdWriteResExPair<WriteIMul16,    [PdEX1, PdMul],          4,  [],    2>;
 409 defm : PdWriteResExPair<WriteIMul16Imm, [PdEX1, PdMul],          5,  [],    2>;
 410 defm : PdWriteResExPair<WriteIMul16Reg, [PdEX1, PdMul],          4>;
 411 defm : PdWriteResExPair<WriteIMul32,    [PdEX1, PdMul],          4>;
 412 defm : PdWriteResExPair<WriteIMul32Imm, [PdEX1, PdMul],          4,  [],    1, 1>;
 413 defm : PdWriteResExPair<WriteIMul32Reg, [PdEX1, PdMul],          4>;
 414 defm : PdWriteResExPair<WriteIMul64,    [PdEX1, PdMul],          6,  [1, 4]>;
 415 defm : PdWriteResExPair<WriteIMul64Imm, [PdEX1, PdMul],          6,  [1, 4],1, 1>;
 416 defm : PdWriteResExPair<WriteIMul64Reg, [PdEX1, PdMul],          6,  [1, 4]>;
 417 defm : X86WriteResUnsupported<WriteIMulH>; // BMI2 MULX
 418
 419 defm : PdWriteResExPair<WriteDiv8,    [PdEX1, PdDiv],           12,  [1, 12]>;
 420 defm : PdWriteResExPair<WriteDiv16,   [PdEX1, PdDiv],           15,  [1, 15],   2>;
 421 defm : PdWriteResExPair<WriteDiv32,   [PdEX1, PdDiv],           14,  [1, 14],   2>;
 422 defm : PdWriteResExPair<WriteDiv64,   [PdEX1, PdDiv],           14,  [1, 14],   2>;
 423
 424 defm : PdWriteResExPair<WriteIDiv8,   [PdEX1, PdDiv],           12,  [1, 12]>;
 425 defm : PdWriteResExPair<WriteIDiv16,  [PdEX1, PdDiv],           15,  [1, 17],   2>;
 426 defm : PdWriteResExPair<WriteIDiv32,  [PdEX1, PdDiv],           14,  [1, 25],   2>;
 427 defm : PdWriteResExPair<WriteIDiv64,  [PdEX1, PdDiv],           14,  [1, 14],   2>;
 428
 429 defm : PdWriteResExPair<WriteCRC32,   [PdEX01],                  3,  [4],       3>;
 430
 431 def PdWriteCRC32r32r16 : SchedWriteRes<[PdEX01]> {
 432   let Latency = 5;
 433   let ResourceCycles = [4];
 434   let NumMicroOps = 5;
 435 }
 436 def : InstRW<[PdWriteCRC32r32r16], (instrs CRC32r32r16)>;
 437
 438 def PdWriteCRC32r32r32 : SchedWriteRes<[PdEX01]> {
 439   let Latency = 6;
 440   let ResourceCycles = [4];
 441   let NumMicroOps = 7;
 442 }
 443 def : InstRW<[PdWriteCRC32r32r32], (instrs CRC32r32r32)>;
 444
 445 def PdWriteCRC32r64r64 : SchedWriteRes<[PdEX01]> {
 446   let Latency = 10;
 447   let ResourceCycles = [4];
 448   let NumMicroOps = 11;
 449 }
 450 def : InstRW<[PdWriteCRC32r64r64], (instrs CRC32r64r64)>;
 451
 452 defm : PdWriteResExPair<WriteCMOV,    [PdEX01]>; // Conditional move.
 453 defm : PdWriteResExPair<WriteCMOV2,   [PdEX01], 1, [], 1, 1>; // Conditional (CF + ZF flag) move.
 454
 455 def : InstRW<[WriteCMOV2.Folded], (instrs CMOVG16rm, CMOVG32rm, CMOVG64rm,
 456                                           CMOVGE16rm, CMOVGE32rm, CMOVGE64rm,
 457                                           CMOVL16rm, CMOVL32rm, CMOVL64rm,
 458                                           CMOVLE16rm, CMOVLE32rm, CMOVLE64rm)>;
 459
 460 defm : PdWriteRes<WriteFCMOV,        [PdFPU0, PdFPFMA]>; // x87 conditional move.
 461
 462 def : WriteRes<WriteSETCC,           [PdEX01]>; // Setcc.
 463 def : WriteRes<WriteSETCCStore,      [PdEX01, PdStore]>;
 464
 465 def PdWriteSETGEmSETGmSETLEmSETLm : SchedWriteRes<[PdEX01]> {
 466   let ResourceCycles = [2];
 467   let NumMicroOps = 2;
 468 }
 469 def : InstRW<[PdWriteSETGEmSETGmSETLEmSETLm], (instrs SETGEm, SETGm,
 470                                                       SETLEm, SETLm)>;
 471
 472 defm : PdWriteRes<WriteLAHFSAHF,      [PdEX01],          2,  [],     2>;
 473
 474 def WriteLAHF : SchedWriteRes<[PdEX01]> {
 475   let Latency = 2;
 476   let NumMicroOps = 4;
 477 }
 478 def : InstRW<[WriteLAHF], (instrs LAHF)>;
 479
 480 def WriteSAHF : SchedWriteRes<[PdEX01]> {
 481   let Latency = 2;
 482   let NumMicroOps = 2;
 483 }
 484 def : InstRW<[WriteSAHF], (instrs SAHF)>;
 485
 486 defm : PdWriteRes<WriteBitTest,          [PdEX01],         1, [1],     1>;
 487 defm : PdWriteRes<WriteBitTestImmLd,     [PdEX01, PdLoad], 5, [1, 1],  1>;
 488 defm : PdWriteRes<WriteBitTestRegLd,     [PdEX01, PdLoad], 5, [1, 1],  7>;
 489 defm : PdWriteRes<WriteBitTestSet,       [PdEX01],         2, [1],     2>;
 490 defm : PdWriteRes<WriteBitTestSetImmLd,  [PdEX01, PdLoad], 6, [1, 1],  4>;
 491 defm : PdWriteRes<WriteBitTestSetImmRMW, [PdEX01, PdLoad], 6, [1, 1],  4>;
 492 defm : PdWriteRes<WriteBitTestSetRegLd,  [PdEX01, PdLoad], 6, [1, 1], 10>;
 493 defm : PdWriteRes<WriteBitTestSetRegRMW, [PdEX01, PdLoad], 6, [1, 1], 10>;
 494
 495 // This is for simple LEAs with one or two input operands.
 496 // FIXME: SAGU 3-operand LEA
 497 def : WriteRes<WriteLEA,              [PdEX01]> { let NumMicroOps = 2; }
 498
 499 // Bit counts.
 500 defm : PdWriteResExPair<WriteBSF,     [PdEX01],          3,  [4],     6, 2>;
 501 defm : PdWriteResExPair<WriteBSR,     [PdEX01],          4,  [4],     7, 2>;
 502 defm : PdWriteResExPair<WritePOPCNT,  [PdEX01],          4>;
 503 defm : PdWriteResExPair<WriteLZCNT,   [PdEX01],          2,  [],      2>;
 504 defm : PdWriteResExPair<WriteTZCNT,   [PdEX01],          2,  [2],     2>;
 505
 506 // BMI1 BEXTR, BMI2 BZHI
 507 defm : PdWriteResExPair<WriteBEXTR,   [PdEX01],          2,  [],     2>;
 508 defm : PdWriteResExPair<WriteBLS,     [PdEX01],          2,  [],     2>;
 509 defm : PdWriteResExPair<WriteBZHI,    [PdEX01]>;
 510
 511 ////////////////////////////////////////////////////////////////////////////////
 512 // Integer shifts and rotates.
 513 ////////////////////////////////////////////////////////////////////////////////
 514
 515 defm : PdWriteResExPair<WriteShift,    [PdEX01]>;
 516 defm : PdWriteResExPair<WriteShiftCL,  [PdEX01]>;
 517 defm : PdWriteResExPair<WriteRotate,   [PdEX01]>;
 518 defm : PdWriteResExPair<WriteRotateCL, [PdEX01]>;
 519
 520 def PdWriteRCL8rCL : SchedWriteRes<[PdEX01]> {
 521   let Latency = 12;
 522   let NumMicroOps = 26;
 523 }
 524 def : InstRW<[PdWriteRCL8rCL], (instrs RCL8rCL)>;
 525
 526 def PdWriteRCR8ri : SchedWriteRes<[PdEX01]> {
 527   let Latency = 12;
 528   let NumMicroOps = 23;
 529 }
 530 def : InstRW<[PdWriteRCR8ri], (instrs RCR8ri)>;
 531
 532 def PdWriteRCR8rCL : SchedWriteRes<[PdEX01]> {
 533   let Latency = 11;
 534   let NumMicroOps = 24;
 535 }
 536 def : InstRW<[PdWriteRCR8rCL], (instrs RCR8rCL)>;
 537
 538 def PdWriteRCL16rCL : SchedWriteRes<[PdEX01]> {
 539   let Latency = 10;
 540   let NumMicroOps = 22;
 541 }
 542 def : InstRW<[PdWriteRCL16rCL], (instrs RCL16rCL)>;
 543
 544 def PdWriteRCR16ri : SchedWriteRes<[PdEX01]> {
 545   let Latency = 10;
 546   let NumMicroOps = 19;
 547 }
 548 def : InstRW<[PdWriteRCR16ri], (instrs RCR16ri)>;
 549
 550 def PdWriteRCL32rCLRCL64rCL : SchedWriteRes<[PdEX01]> {
 551   let Latency = 7;
 552   let NumMicroOps = 17;
 553 }
 554 def : InstRW<[PdWriteRCL32rCLRCL64rCL], (instrs RCL32rCL, RCL64rCL)>;
 555
 556 def PdWriteRCR64rCL : SchedWriteRes<[PdEX01]> {
 557   let Latency = 7;
 558   let NumMicroOps = 16;
 559 }
 560 def : InstRW<[PdWriteRCR64rCL], (instrs RCR64rCL)>;
 561
 562 def PdWriteRCR32rCL : SchedWriteRes<[PdEX01]> {
 563   let Latency = 7;
 564   let NumMicroOps = 16;
 565 }
 566 def : InstRW<[PdWriteRCR32rCL ], (instrs RCR32rCL)>;
 567
 568 def PdWriteRCR32riRCR64ri : SchedWriteRes<[PdEX01]> {
 569   let Latency = 7;
 570   let NumMicroOps = 15;
 571 }
 572 def : InstRW<[PdWriteRCR32riRCR64ri], (instrs RCR32ri, RCR64ri)>;
 573
 574
 575 def PdWriteRCR16rCL : SchedWriteRes<[PdEX01]> {
 576   let Latency = 9;
 577   let NumMicroOps = 20;
 578 }
 579 def : InstRW<[PdWriteRCR16rCL], (instrs RCR16rCL)>;
 580
 581 def PdWriteRCL16ri : SchedWriteRes<[PdEX01]> {
 582   let Latency = 11;
 583   let NumMicroOps = 21;
 584 }
 585 def : InstRW<[PdWriteRCL16ri], (instrs RCL16ri)>;
 586
 587 def PdWriteRCL3264ri : SchedWriteRes<[PdEX01]> {
 588   let Latency = 8;
 589   let NumMicroOps = 16;
 590 }
 591 def : InstRW<[PdWriteRCL3264ri], (instrs RCL32ri, RCL64ri)>;
 592
 593 def PdWriteRCL8ri : SchedWriteRes<[PdEX01]> {
 594   let Latency = 13;
 595   let NumMicroOps = 25;
 596 }
 597 def : InstRW<[PdWriteRCL8ri], (instrs RCL8ri)>;
 598
 599 // SHLD/SHRD.
 600 defm : PdWriteRes<WriteSHDrri,       [PdEX01],         4, [6], 6>;
 601 defm : PdWriteRes<WriteSHDrrcl,      [PdEX01],         4, [8], 7>;
 602
 603 def PdWriteSHLD32rri8SHRD16rri8 : SchedWriteRes<[PdEX01]> {
 604   let Latency = 3;
 605   let ResourceCycles = [6];
 606   let NumMicroOps = 6;
 607 }
 608 def : InstRW<[PdWriteSHLD32rri8SHRD16rri8 ], (instrs SHLD32rri8, SHRD16rri8)>;
 609
 610 def PdWriteSHLD16rrCLSHLD32rrCLSHRD32rrCL : SchedWriteRes<[PdEX01]> {
 611   let Latency = 4;
 612   let ResourceCycles = [8];
 613   let NumMicroOps = 7;
 614 }
 615 def : InstRW<[PdWriteSHLD16rrCLSHLD32rrCLSHRD32rrCL], (instrs SHLD16rrCL,
 616                                                               SHLD32rrCL,
 617                                                               SHRD32rrCL)>;
 618
 619 defm : PdWriteRes<WriteSHDmri,       [PdLoad, PdEX01], 4, [1, 22], 8>;
 620 defm : PdWriteRes<WriteSHDmrcl,      [PdLoad, PdEX01], 4, [1, 22], 8>;
 621
 622 ////////////////////////////////////////////////////////////////////////////////
 623 // Floating point. This covers both scalar and vector operations.
 624 ////////////////////////////////////////////////////////////////////////////////
 625
 626 defm : PdWriteRes<WriteFLD0,               [PdFPU1, PdFPSTO], 3>;
 627 defm : PdWriteRes<WriteFLD1,               [PdFPU1, PdFPSTO], 3>;
 628 defm : PdWriteRes<WriteFLDC,               [PdFPU1, PdFPSTO], 3>;
 629
 630 defm : PdWriteRes<WriteFLoad,              [PdLoad, PdFPU01, PdFPFMA], 5>;
 631 defm : PdWriteRes<WriteFLoadX,             [PdLoad, PdFPU01, PdFPFMA], 5>;
 632 defm : PdWriteRes<WriteFLoadY,             [PdLoad, PdFPU01, PdFPFMA], 5, [], 2>;
 633
 634 defm : PdWriteRes<WriteFMaskedLoad,        [PdLoad, PdFPU01, PdFPFMA], 6, [1, 1, 2]>;
 635 defm : PdWriteRes<WriteFMaskedLoadY,       [PdLoad, PdFPU01, PdFPFMA], 6, [2, 2, 4], 2>;
 636
 637 defm : PdWriteRes<WriteFStore,             [PdStore, PdFPU1,  PdFPSTO], 2>;
 638 defm : PdWriteRes<WriteFStoreX,            [PdStore, PdFPU1,  PdFPSTO]>;
 639 defm : PdWriteRes<WriteFStoreY,            [PdStore, PdFPU1,  PdFPSTO], 1, [], 4>;
 640
 641 def PdWriteMOVHPm : SchedWriteRes<[PdStore, PdFPU1,  PdFPSTO]> {
 642   let Latency = 2;
 643   let NumMicroOps = 2;
 644 }
 645 def : InstRW<[PdWriteMOVHPm], (instrs MOVHPDmr, MOVHPSmr, VMOVHPDmr, VMOVHPSmr)>;
 646
 647 def PdWriteVMOVUPDYmrVMOVUPSYmr : SchedWriteRes<[PdStore, PdFPU1,  PdFPSTO]> {
 648   let NumMicroOps = 8;
 649 }
 650 def : InstRW<[PdWriteVMOVUPDYmrVMOVUPSYmr], (instrs VMOVUPDYmr, VMOVUPSYmr)>;
 651
 652 defm : PdWriteRes<WriteFStoreNT,           [PdStore, PdFPU1,  PdFPSTO], 3>;
 653 defm : PdWriteRes<WriteFStoreNTX,          [PdStore, PdFPU1,  PdFPSTO], 3>;
 654 defm : PdWriteRes<WriteFStoreNTY,          [PdStore, PdFPU1,  PdFPSTO], 3, [2, 2, 2], 4>;
 655
 656 defm : PdWriteRes<WriteFMaskedStore,       [PdStore, PdFPU01, PdFPFMA], 6, [1, 1, 4], 18>;
 657 defm : PdWriteRes<WriteFMaskedStoreY,      [PdStore, PdFPU01, PdFPFMA], 6, [2, 2, 4], 34>;
 658
 659 defm : PdWriteRes<WriteFMove,              [PdFPU01, PdFPFMA]>;
 660 defm : PdWriteRes<WriteFMoveX,             [PdFPU01, PdFPFMA]>;
 661 defm : PdWriteRes<WriteFMoveY,             [PdFPU01, PdFPFMA], 2, [2, 2], 2>;
 662
 663 defm : PdWriteRes<WriteEMMS,               [PdFPU01, PdFPFMA], 2>;
 664
 665 defm : PdWriteResXMMPair<WriteFAdd,         [PdFPU0, PdFPFMA],  5>;
 666 defm : PdWriteResXMMPair<WriteFAddX,        [PdFPU0, PdFPFMA],  5>;
 667 defm : PdWriteResYMMPair<WriteFAddY,        [PdFPU0, PdFPFMA],  5, [2, 1]>;
 668 defm : X86WriteResPairUnsupported<WriteFAddZ>;
 669
 670 defm : PdWriteResXMMPair<WriteFAdd64,       [PdFPU0, PdFPFMA],  5>;
 671 defm : PdWriteResXMMPair<WriteFAdd64X,      [PdFPU0, PdFPFMA],  5>;
 672 defm : PdWriteResYMMPair<WriteFAdd64Y,      [PdFPU0, PdFPFMA],  5, [2, 1]>;
 673 defm : X86WriteResPairUnsupported<WriteFAdd64Z>;
 674
 675 defm : PdWriteResXMMPair<WriteFCmp,         [PdFPU0, PdFPFMA],  2>;
 676 defm : PdWriteResXMMPair<WriteFCmpX,        [PdFPU0, PdFPFMA],  2>;
 677 defm : PdWriteResYMMPair<WriteFCmpY,        [PdFPU0, PdFPFMA],  2, [2, 1]>;
 678 defm : X86WriteResPairUnsupported<WriteFCmpZ>;
 679
 680 defm : PdWriteResXMMPair<WriteFCmp64,       [PdFPU0, PdFPFMA],  2>;
 681 defm : PdWriteResXMMPair<WriteFCmp64X,      [PdFPU0, PdFPFMA],  2>;
 682 defm : PdWriteResYMMPair<WriteFCmp64Y,      [PdFPU0, PdFPFMA],  2, [2, 1]>;
 683 defm : X86WriteResPairUnsupported<WriteFCmp64Z>;
 684
 685 defm : PdWriteResXMMPair<WriteFCom,         [PdFPU0, PdFPFMA, PdEX0], 1, [], 2>;
 686
 687 def PdWriteFCOMPm : SchedWriteRes<[PdFPU1, PdFPFMA]> {
 688   let Latency = 6;
 689 }
 690 def : InstRW<[PdWriteFCOMPm], (instrs FCOM32m, FCOM64m, FCOMP32m, FCOMP64m)>;
 691
 692 def PdWriteTST_F_UCOM_FPPr : SchedWriteRes<[PdFPU1, PdFPFMA]>;
 693 def : InstRW<[PdWriteTST_F_UCOM_FPPr], (instrs TST_F, UCOM_FPPr)>;
 694
 695 defm : PdWriteResXMMPair<WriteFMul,         [PdFPU1, PdFPFMA],  5>;
 696 defm : PdWriteResXMMPair<WriteFMulX,        [PdFPU1, PdFPFMA],  5>;
 697 defm : PdWriteResYMMPair<WriteFMulY,        [PdFPU1, PdFPFMA],  5, [2, 1]>;
 698 defm : X86WriteResPairUnsupported<WriteFMulZ>;
 699
 700 defm : PdWriteResXMMPair<WriteFMul64,       [PdFPU1, PdFPFMA],  5>;
 701 defm : PdWriteResXMMPair<WriteFMul64X,      [PdFPU1, PdFPFMA],  5>;
 702 defm : PdWriteResYMMPair<WriteFMul64Y,      [PdFPU1, PdFPFMA],  5, [2, 1]>;
 703 defm : X86WriteResPairUnsupported<WriteFMul64Z>;
 704
 705 defm : PdWriteResXMMPair<WriteFMA,          [PdFPU, PdFPFMA], 5>;
 706 defm : PdWriteResXMMPair<WriteFMAX,         [PdFPU, PdFPFMA], 5>;
 707 defm : PdWriteResYMMPair<WriteFMAY,         [PdFPU, PdFPFMA], 5,   [1, 1]>;
 708 defm : X86WriteResPairUnsupported<WriteFMAZ>;
 709
 710
 711 defm : PdWriteResXMMPair<WriteDPPD,         [PdFPU1, PdFPFMA], 15, [1, 3],  15, 2>;
 712
 713 defm : PdWriteResXMMPair<WriteDPPS,         [PdFPU1, PdFPFMA], 25, [1, 3],  16, 2>;
 714 defm : PdWriteResYMMPair<WriteDPPSY,        [PdFPU1, PdFPFMA], 27, [2, 6], /*or 29*/ 25, 4>;
 715 defm : X86WriteResPairUnsupported<WriteDPPSZ>;
 716
 717 def PdWriteVDPPSrri : SchedWriteRes<[PdFPU1, PdFPFMA]> {
 718   let Latency = 25;
 719   let ResourceCycles = [1, 3];
 720   let NumMicroOps = 17;
 721 }
 722 def : InstRW<[PdWriteVDPPSrri], (instrs VDPPSrri)>;
 723
 724 defm : PdWriteResXMMPair<WriteFRcp,         [PdFPU1, PdFPFMA],  5>;
 725 defm : PdWriteResXMMPair<WriteFRcpX,        [PdFPU1, PdFPFMA],  5>;
 726 defm : PdWriteResYMMPair<WriteFRcpY,        [PdFPU1, PdFPFMA],  5, [2, 1]>;
 727 defm : X86WriteResPairUnsupported<WriteFRcpZ>;
 728
 729 defm : PdWriteResXMMPair<WriteFRsqrt,       [PdFPU1, PdFPFMA],  5>;
 730 defm : PdWriteResXMMPair<WriteFRsqrtX,      [PdFPU1, PdFPFMA],  5>;
 731 defm : PdWriteResYMMPair<WriteFRsqrtY,      [PdFPU1, PdFPFMA],  5, [2, 1]>;
 732 defm : X86WriteResPairUnsupported<WriteFRsqrtZ>;
 733
 734 defm : PdWriteResXMMPair<WriteFDiv,         [PdFPU1, PdFPFMA], 9, [1, 19]>;
 735 defm : PdWriteResXMMPair<WriteFDivX,        [PdFPU1, PdFPFMA], 9, [1, 19]>;
 736 defm : PdWriteResYMMPair<WriteFDivY,        [PdFPU1, PdFPFMA], 9, [2, 38]>;
 737 defm : X86WriteResPairUnsupported<WriteFDivZ>;
 738
 739 defm : PdWriteResXMMPair<WriteFDiv64,       [PdFPU1, PdFPFMA], 9, [1, 19]>;
 740 defm : PdWriteResXMMPair<WriteFDiv64X,      [PdFPU1, PdFPFMA], 9, [1, 19]>;
 741 defm : PdWriteResYMMPair<WriteFDiv64Y,      [PdFPU1, PdFPFMA], 9, [2, 38]>;
 742 defm : X86WriteResPairUnsupported<WriteFDiv64Z>;
 743
 744 defm : PdWriteResXMMPair<WriteFSqrt,        [PdFPU1, PdFPFMA], 9, [1, 21]>;
 745 defm : PdWriteResXMMPair<WriteFSqrtX,       [PdFPU1, PdFPFMA], 9, [1, 21]>;
 746 defm : PdWriteResYMMPair<WriteFSqrtY,       [PdFPU1, PdFPFMA], 9, [2, 42]>;
 747 defm : X86WriteResPairUnsupported<WriteFSqrtZ>;
 748
 749 defm : PdWriteResXMMPair<WriteFSqrt64,      [PdFPU1, PdFPFMA], 9, [1, 27]>;
 750 defm : PdWriteResXMMPair<WriteFSqrt64X,     [PdFPU1, PdFPFMA], 9, [1, 27]>;
 751 defm : PdWriteResYMMPair<WriteFSqrt64Y,     [PdFPU1, PdFPFMA], 9, [2, 54]>;
 752 defm : X86WriteResPairUnsupported<WriteFSqrt64Z>;
 753
 754 defm : PdWriteResXMMPair<WriteFSqrt80,      [PdFPU1, PdFPFMA],  1, [1, 35]>;
 755 defm : PdWriteResXMMPair<WriteFSign,        [PdFPU1, PdFPFMA]>;
 756
 757 defm : PdWriteResXMMPair<WriteFRnd,         [PdFPU1, PdFPSTO],  4>;
 758 defm : PdWriteResYMMPair<WriteFRndY,        [PdFPU1, PdFPSTO],  4, [2, 1], 2>;
 759 defm : X86WriteResPairUnsupported<WriteFRndZ>;
 760
 761 def PdWriteVFRCZ : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 762   let Latency = 10;
 763   let NumMicroOps = 2;
 764 }
 765 def : InstRW<[PdWriteVFRCZ], (instrs VFRCZPDrr, VFRCZPSrr,
 766                                      VFRCZSDrr, VFRCZSSrr)>;
 767
 768 def PdWriteVFRCZm : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 769   let Latency = 15;
 770   let NumMicroOps = 2;
 771 }
 772 def : InstRW<[PdWriteVFRCZm], (instrs VFRCZPDrm, VFRCZPSrm,
 773                                       VFRCZSDrm, VFRCZSSrm)>;
 774
 775 def PdWriteVFRCZY : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 776   let Latency = 10;
 777   let ResourceCycles = [2, 1];
 778   let NumMicroOps = 4;
 779 }
 780 def : InstRW<[PdWriteVFRCZY], (instrs VFRCZPSYrr, VFRCZPDYrr)>;
 781
 782 def PdWriteVFRCZYm : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 783   let Latency = 15;
 784   let ResourceCycles = [2, 1];
 785   let NumMicroOps = 8;
 786 }
 787 def : InstRW<[PdWriteVFRCZYm], (instrs VFRCZPSYrm, VFRCZPDYrm)>;
 788
 789 defm : PdWriteResXMMPair<WriteFLogic,       [PdFPU01, PdFPFMA],  2>;
 790 defm : PdWriteResYMMPair<WriteFLogicY,      [PdFPU01, PdFPFMA],  2, [2, 2]>;
 791 defm : X86WriteResPairUnsupported<WriteFLogicZ>;
 792
 793 defm : PdWriteResXMMPair<WriteFTest,        [PdFPU0, PdFPFMA, PdEX0],  1, [], 2>;
 794 defm : PdWriteResYMMPair<WriteFTestY,       [PdFPU01, PdFPFMA, PdEX0], 1, [2, 2, 1], 4, 2>;
 795 defm : X86WriteResPairUnsupported<WriteFTestZ>;
 796
 797 defm : PdWriteResXMMPair<WriteFShuffle,     [PdFPU01, PdFPFMA],  2>;
 798 defm : PdWriteResYMMPair<WriteFShuffleY,    [PdFPU01, PdFPFMA],  2, [2, 2], 2>;
 799 defm : X86WriteResPairUnsupported<WriteFShuffleZ>;
 800
 801 def PdWriteVBROADCASTF128 : SchedWriteRes<[PdFPU01, PdFPFMA]> {
 802   let Latency = 7;
 803   let NumMicroOps = 2;
 804 }
 805 def : InstRW<[PdWriteVBROADCASTF128], (instrs VBROADCASTF128)>;
 806
 807 defm : PdWriteResXMMPair<WriteFVarShuffle,  [PdFPU01, PdFPFMA],  3, [1, 4]>;
 808 defm : PdWriteResYMMPair<WriteFVarShuffleY, [PdFPU01, PdFPFMA],  3, [2, 6], 2>;
 809 defm : X86WriteResPairUnsupported<WriteFVarShuffleZ>;
 810
 811 defm : PdWriteResXMMPair<WriteFBlend,       [PdFPU01, PdFPFMA],  2>;
 812 defm : PdWriteResYMMPair<WriteFBlendY,      [PdFPU01, PdFPFMA],  2, [2, 2], 2>;
 813 defm : X86WriteResPairUnsupported<WriteFBlendZ>;
 814
 815 defm : PdWriteResXMMPair<WriteFVarBlend,    [PdFPU01, PdFPFMA],  2, [1, 4]>;
 816 defm : PdWriteResYMMPair<WriteFVarBlendY,   [PdFPU01, PdFPFMA],  2, [2, 6], 2>;
 817 defm : X86WriteResPairUnsupported<WriteFVarBlendZ>;
 818
 819 defm : PdWriteResXMMPair<WriteFShuffle256,  [PdFPU01, PdFPFMA],  2, [], 2>;
 820 defm : X86WriteResPairUnsupported<WriteFVarShuffle256>;
 821
 822 def PdWriteVEXTRACTF128rr : SchedWriteRes<[PdFPU01, PdFPFMA]> {
 823   let Latency = 2;
 824 }
 825 def : InstRW<[PdWriteVEXTRACTF128rr], (instrs VEXTRACTF128rr)>;
 826
 827 def PdWriteVEXTRACTF128mr : SchedWriteRes<[PdFPU01, PdFPFMA]> {
 828   let Latency = 7;
 829   let NumMicroOps = 2;
 830 }
 831 def : InstRW<[PdWriteVEXTRACTF128mr], (instrs VEXTRACTF128mr)>;
 832
 833 def PdWriteVPERM2F128rr : SchedWriteRes<[PdFPU01, PdFPFMA]> {
 834   let Latency = 4;
 835   let NumMicroOps = 8;
 836 }
 837 def : InstRW<[PdWriteVPERM2F128rr], (instrs VPERM2F128rr)>;
 838
 839 def PdWriteVPERM2F128rm : SchedWriteRes<[PdFPU01, PdFPFMA]> {
 840   let Latency = 8; // 4 + 4
 841   let NumMicroOps = 10;
 842 }
 843 def : InstRW<[PdWriteVPERM2F128rm], (instrs VPERM2F128rm)>;
 844
 845 ////////////////////////////////////////////////////////////////////////////////
 846 // Conversions.
 847 ////////////////////////////////////////////////////////////////////////////////
 848
 849 defm : PdWriteResXMMPair<WriteCvtSS2I,   [PdFPU1, PdFPSTO, PdFPFMA, PdEX0], 13, [], 2>;
 850
 851 defm : PdWriteResXMMPair<WriteCvtPS2I,   [PdFPU1, PdFPSTO], 4>;
 852 defm : PdWriteResYMMPair<WriteCvtPS2IY,  [PdFPU1, PdFPSTO], 4, [2, 1]>;
 853 defm : X86WriteResPairUnsupported<WriteCvtPS2IZ>;
 854
 855 defm : PdWriteResXMMPair<WriteCvtSD2I,   [PdFPU1, PdFPSTO, PdFPFMA, PdEX0], 13, [], 2>;
 856
 857 defm : PdWriteResXMMPair<WriteCvtPD2I,   [PdFPU1, PdFPSTO],          8, [],        2>;
 858 defm : PdWriteResYMMPair<WriteCvtPD2IY,  [PdFPU1, PdFPSTO, PdFPFMA], 8, [2, 1, 1], 4>;
 859 defm : X86WriteResPairUnsupported<WriteCvtPD2IZ>;
 860
 861 def PdWriteMMX_CVTTPD2PIirr : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 862   let Latency = 6;
 863   let NumMicroOps = 2;
 864 }
 865 def : InstRW<[PdWriteMMX_CVTTPD2PIirr], (instrs MMX_CVTTPD2PIirr)>;
 866
 867 // FIXME: f+3 ST, LD+STC latency
 868 defm : PdWriteResXMMPair<WriteCvtI2SS,   [PdFPU1, PdFPSTO], 4, [], 2>;
 869 // FIXME: .Folded version is one NumMicroOp *less*..
 870
 871 defm : PdWriteResXMMPair<WriteCvtI2PS,   [PdFPU1, PdFPSTO], 4>;
 872 defm : PdWriteResYMMPair<WriteCvtI2PSY,  [PdFPU1, PdFPSTO], 4, [2, 1]>;
 873 defm : X86WriteResPairUnsupported<WriteCvtI2PSZ>;
 874
 875 defm : PdWriteResXMMPair<WriteCvtI2SD,   [PdFPU1, PdFPSTO], 4, [], 2>;
 876 // FIXME: .Folded version is one NumMicroOp *less*..
 877
 878 def WriteCVTSI642SDrr : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 879   let Latency = 13;
 880   let NumMicroOps = 2;
 881 }
 882 def : InstRW<[WriteCVTSI642SDrr], (instrs CVTSI642SDrr, CVTSI642SSrr)>;
 883
 884 defm : PdWriteResXMMPair<WriteCvtI2PD,   [PdFPU1, PdFPSTO], 8, [],     2>;
 885 defm : PdWriteResYMMPair<WriteCvtI2PDY,  [PdFPU1, PdFPSTO], 8, [2, 1], 4, 1>;
 886 defm : X86WriteResPairUnsupported<WriteCvtI2PDZ>;
 887
 888 defm : PdWriteResXMMPair<WriteCvtSS2SD,  [PdFPU1, PdFPSTO], 4>;
 889
 890 defm : PdWriteResXMMPair<WriteCvtPS2PD,  [PdFPU1, PdFPSTO], 8, [],     2>;
 891 defm : PdWriteResYMMPair<WriteCvtPS2PDY, [PdFPU1, PdFPSTO], 8, [2, 1], 4, 1>;
 892 defm : X86WriteResPairUnsupported<WriteCvtPS2PDZ>;
 893
 894 defm : PdWriteResXMMPair<WriteCvtSD2SS,  [PdFPU1, PdFPSTO], 4>;
 895
 896 defm : PdWriteResXMMPair<WriteCvtPD2PS,  [PdFPU1, PdFPSTO],          8, [],        2>;
 897 defm : PdWriteResYMMPair<WriteCvtPD2PSY, [PdFPU1, PdFPSTO, PdFPFMA], 8, [2, 1, 1], 4>;
 898 defm : X86WriteResPairUnsupported<WriteCvtPD2PSZ>;
 899
 900 def WriteMMX_CVTPD2PIirrMMX_CVTPI2PDirr : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 901   let Latency = 6;
 902   let NumMicroOps = 2;
 903 }
 904 def : InstRW<[WriteMMX_CVTPD2PIirrMMX_CVTPI2PDirr], (instrs MMX_CVTPD2PIirr,
 905                                                             MMX_CVTPI2PDirr)>;
 906
 907 def WriteMMX_CVTPI2PSirr : SchedWriteRes<[PdFPU1, PdFPSTO]> {
 908   let Latency = 4;
 909   let NumMicroOps = 2;
 910 }
 911 def : InstRW<[WriteMMX_CVTPI2PSirr], (instrs MMX_CVTPI2PSirr)>;
 912
 913 defm : PdWriteResXMMPair<WriteCvtPH2PS,  [PdFPU1, PdFPSTO], 8, [],     2, 1>;
 914 defm : PdWriteResYMMPair<WriteCvtPH2PSY, [PdFPU1, PdFPSTO], 8, [2, 1], 4, 3>;
 915 defm : X86WriteResPairUnsupported<WriteCvtPH2PSZ>;
 916
 917 defm : PdWriteRes<WriteCvtPS2PH,        [PdFPU1, PdFPSTO],          8, [],        2>;
 918 defm : PdWriteRes<WriteCvtPS2PHY,       [PdFPU1, PdFPSTO, PdFPFMA], 8, [2, 1, 1], 4>;
 919 defm : X86WriteResUnsupported<WriteCvtPS2PHZ>;
 920
 921 defm : PdWriteRes<WriteCvtPS2PHSt,      [PdFPU1, PdFPSTO, PdStore],          4, [],           3>;
 922 defm : PdWriteRes<WriteCvtPS2PHYSt,     [PdFPU1, PdFPSTO, PdFPFMA, PdStore], 4, [2, 1, 1, 1], 4>;
 923 defm : X86WriteResUnsupported<WriteCvtPS2PHZSt>;
 924
 925 ////////////////////////////////////////////////////////////////////////////////
 926 // Vector integer operations.
 927 ////////////////////////////////////////////////////////////////////////////////
 928
 929 defm : PdWriteRes<WriteVecLoad,             [PdLoad, PdFPU01, PdFPMAL], 5>;
 930 defm : PdWriteRes<WriteVecLoadX,            [PdLoad, PdFPU01, PdFPMAL], 5>;
 931 defm : PdWriteRes<WriteVecLoadY,            [PdLoad, PdFPU01, PdFPMAL], 5, [], 2>;
 932
 933 defm : PdWriteRes<WriteVecLoadNT,           [PdLoad, PdFPU01, PdFPMAL], 5>;
 934 defm : PdWriteRes<WriteVecLoadNTY,          [PdLoad, PdFPU01, PdFPMAL], 5>;
 935
 936 defm : PdWriteRes<WriteVecMaskedLoad,       [PdLoad, PdFPU01, PdFPMAL], 6, [1, 1, 2]>;
 937 defm : PdWriteRes<WriteVecMaskedLoadY,      [PdLoad, PdFPU01, PdFPMAL], 6, [2, 2, 4], 2>;
 938
 939 defm : PdWriteRes<WriteVecStore,            [PdStore, PdFPU1,   PdFPSTO], 2>;
 940 defm : PdWriteRes<WriteVecStoreX,           [PdStore, PdFPU1,   PdFPSTO]>;
 941 defm : PdWriteRes<WriteVecStoreY,           [PdStore, PdFPU1,   PdFPSTO], 1, [], 4>;
 942
 943 def PdWriteVMOVDQUYmr : SchedWriteRes<[PdStore, PdFPU1,   PdFPSTO]> {
 944   let NumMicroOps = 8;
 945 }
 946 def : InstRW<[PdWriteVMOVDQUYmr], (instrs VMOVDQUYmr)>;
 947
 948 defm : PdWriteRes<WriteVecStoreNT,          [PdStore, PdFPU1,   PdFPSTO], 2>;
 949 defm : PdWriteRes<WriteVecStoreNTY,         [PdStore, PdFPU1,   PdFPSTO], 2, [2, 2, 2], 4>;
 950
 951 defm : PdWriteRes<WriteVecMaskedStore,      [PdStore, PdFPU01, PdFPMAL], 6, [1, 1, 4]>;
 952 defm : PdWriteRes<WriteVecMaskedStoreY,     [PdStore, PdFPU01, PdFPMAL], 6, [2, 2, 4], 2>;
 953
 954 defm : PdWriteRes<WriteVecMove,             [PdFPU01, PdFPMAL], 2>;
 955 defm : PdWriteRes<WriteVecMoveX,            [PdFPU01, PdFPMAL], 2>;
 956 defm : PdWriteRes<WriteVecMoveY,            [PdFPU01, PdFPMAL], 2, [2, 2], 2>;
 957
 958 defm : PdWriteRes<WriteVecMoveToGpr,        [PdFPU0, PdFPFMA, PdEX0], 10>;
 959 defm : PdWriteRes<WriteVecMoveFromGpr,      [PdFPU01, PdFPFMA], 10, [], 2>;
 960
 961 defm : PdWriteResXMMPair<WriteVecALU,        [PdFPU01, PdFPMAL], 2>;
 962 defm : PdWriteResXMMPair<WriteVecALUX,       [PdFPU01, PdFPMAL], 2>;
 963 defm : X86WriteResPairUnsupported<WriteVecALUY>;
 964 defm : X86WriteResPairUnsupported<WriteVecALUZ>;
 965
 966 defm : PdWriteResXMMPair<WriteVecShift,      [PdFPU01, PdFPMAL], 3>;
 967 defm : PdWriteResXMMPair<WriteVecShiftX,     [PdFPU01, PdFPMAL], 3>;
 968 defm : X86WriteResPairUnsupported<WriteVecShiftY>;
 969 defm : X86WriteResPairUnsupported<WriteVecShiftZ>;
 970
 971 defm : PdWriteResXMMPair<WriteVecShiftImm,   [PdFPU01, PdFPMAL], 2>;
 972 defm : PdWriteResXMMPair<WriteVecShiftImmX,  [PdFPU01, PdFPMAL], 2>;
 973 defm : X86WriteResPairUnsupported<WriteVecShiftImmY>;
 974 defm : X86WriteResPairUnsupported<WriteVecShiftImmZ>;
 975
 976 defm : PdWriteResXMMPair<WriteVecIMul,       [PdFPU0, PdFPMMA], 4>;
 977 defm : PdWriteResXMMPair<WriteVecIMulX,      [PdFPU0, PdFPMMA], 4>;
 978 defm : X86WriteResPairUnsupported<WriteVecIMulY>;
 979 defm : X86WriteResPairUnsupported<WriteVecIMulZ>;
 980
 981 defm : PdWriteResXMMPair<WritePMULLD,        [PdFPU0, PdFPU01, PdFPMMA, PdFPMAL], 5, [2, 1, 2, 1]>;
 982 defm : X86WriteResPairUnsupported<WritePMULLDY>;
 983 defm : X86WriteResPairUnsupported<WritePMULLDZ>;
 984
 985 def JWriteVPMACS : SchedWriteRes<[PdFPU0, PdFPU01, PdFPMMA, PdFPMAL]> {
 986   let Latency = 4;
 987   let ResourceCycles = [2, 1, 2, 1];
 988 }
 989 def : InstRW<[JWriteVPMACS], (instrs VPMACSDQHrr, VPMACSDQLrr, VPMACSSDQHrr,
 990                                      VPMACSSDQLrr)>;
 991
 992 defm : PdWriteResXMMPair<WriteMPSAD,         [PdFPU0, PdFPMMA], 9, [1, 2], 9>;
 993 defm : X86WriteResPairUnsupported<WriteMPSADY>;
 994 defm : X86WriteResPairUnsupported<WriteMPSADZ>;
 995
 996 defm : PdWriteResXMMPair<WritePSADBW,        [PdFPU01, PdFPMAL], 4, [], 2>;
 997 defm : PdWriteResXMMPair<WritePSADBWX,       [PdFPU01, PdFPMAL], 4, [], 2>;
 998 defm : X86WriteResPairUnsupported<WritePSADBWY>;
 999 defm : X86WriteResPairUnsupported<WritePSADBWZ>;
1000
1001 defm : PdWriteResXMMPair<WritePHMINPOS,      [PdFPU0,  PdFPMAL], 4, [], 2>;
1002
1003 defm : PdWriteResXMMPair<WriteShuffle,       [PdFPU01, PdFPMAL], 2>;
1004 defm : PdWriteResXMMPair<WriteShuffleX,      [PdFPU01, PdFPMAL], 2>;
1005 defm : PdWriteResYMMPair<WriteShuffleY,      [PdFPU01, PdFPMAL], 2,   [1, 1]>;
1006 defm : X86WriteResPairUnsupported<WriteShuffleZ>;
1007
1008 defm : PdWriteResXMMPair<WriteVarShuffle,    [PdFPU01, PdFPMAL], 3, [1, 4]>;
1009 defm : PdWriteResXMMPair<WriteVarShuffleX,   [PdFPU01, PdFPMAL], 3, [1, 4]>;
1010 defm : X86WriteResPairUnsupported<WriteVarShuffleY>;
1011 defm : X86WriteResPairUnsupported<WriteVarShuffleZ>;
1012
1013 defm : PdWriteResXMMPair<WriteBlend,         [PdFPU01, PdFPMAL], 2>;
1014 defm : X86WriteResPairUnsupported<WriteBlendY>;
1015 defm : X86WriteResPairUnsupported<WriteBlendZ>;
1016
1017 defm : PdWriteResXMMPair<WriteVarBlend,      [PdFPU01, PdFPMAL], 2, [1, 4]>;
1018 defm : X86WriteResPairUnsupported<WriteVarBlendY>;
1019 defm : X86WriteResPairUnsupported<WriteVarBlendZ>;
1020
1021 defm : PdWriteResXMMPair<WriteVecLogic,      [PdFPU01, PdFPMAL], 2>;
1022 defm : PdWriteResXMMPair<WriteVecLogicX,     [PdFPU01, PdFPMAL], 2>;
1023 defm : X86WriteResPairUnsupported<WriteVecLogicY>;
1024 defm : X86WriteResPairUnsupported<WriteVecLogicZ>;
1025
1026 defm : PdWriteResXMMPair<WriteVecTest,       [PdFPU0, PdFPFMA, PdEX0],  1, [], 2>;
1027 defm : PdWriteResYMMPair<WriteVecTestY,      [PdFPU01, PdFPFMA, PdEX0], 1, [2, 2, 1], 4, 2>;
1028 defm : X86WriteResPairUnsupported<WriteVecTestZ>;
1029
1030 defm : PdWriteResXMMPair<WriteShuffle256,    [PdFPU01, PdFPMAL]>;
1031 defm : PdWriteResXMMPair<WriteVarShuffle256, [PdFPU01, PdFPMAL]>;
1032
1033 defm : PdWriteResXMMPair<WriteVarVecShift,   [PdFPU01, PdFPMAL], 3>;
1034 defm : X86WriteResPairUnsupported<WriteVarVecShiftY>;
1035 defm : X86WriteResPairUnsupported<WriteVarVecShiftZ>;
1036
1037 ////////////////////////////////////////////////////////////////////////////////
1038 // Vector insert/extract operations.
1039 ////////////////////////////////////////////////////////////////////////////////
1040
1041 defm : PdWriteRes<WriteVecInsert,    [PdFPU01, PdFPMAL], 2, [], 2>;
1042 defm : PdWriteRes<WriteVecInsertLd,  [PdFPU01, PdFPMAL, PdLoad], 6, [], 2>;
1043
1044 defm : PdWriteRes<WriteVecExtract,   [PdFPU0, PdFPFMA, PdEX0], 13, [], 2>;
1045 defm : PdWriteRes<WriteVecExtractSt, [PdFPU1, PdFPSTO, PdStore], 13, [], 2>;
1046
1047 def PdWriteEXTRQ : SchedWriteRes<[PdFPU01, PdFPMAL]> {
1048   let Latency = 3;
1049 }
1050 def : InstRW<[PdWriteEXTRQ], (instrs EXTRQ, EXTRQI)>;
1051
1052 ////////////////////////////////////////////////////////////////////////////////
1053 // SSE42 String instructions.
1054 ////////////////////////////////////////////////////////////////////////////////
1055
1056 defm : PdWriteResXMMPair<WritePCmpIStrI, [PdFPU1, PdFPFMA, PdEX0], 14, [1, 2, 1], 7, 1>;
1057 defm : PdWriteResXMMPair<WritePCmpIStrM, [PdFPU1, PdFPFMA, PdEX0],  6, [1, 2, 1], 7, 2>;
1058
1059 defm : PdWriteResXMMPair<WritePCmpEStrI, [PdFPU1, PdStore, PdLoad, PdFPMAL, PdFPFMA, PdEX0], 15, [1, 2, 6, 4, 1, 1], 27, 1>;
1060 defm : PdWriteResXMMPair<WritePCmpEStrM, [PdFPU1, PdStore, PdLoad, PdFPMAL, PdFPFMA, PdEX0], 10, [1, 2, 6, 4, 1, 1], 27, 1>;
1061
1062 ////////////////////////////////////////////////////////////////////////////////
1063 // MOVMSK Instructions.
1064 ////////////////////////////////////////////////////////////////////////////////
1065
1066 defm : PdWriteRes<WriteFMOVMSK, [PdFPU0, PdFPFMA, PdEX0],   10, [], 2>;
1067
1068 defm : PdWriteRes<WriteVecMOVMSK, [PdFPU0, PdFPFMA, PdEX0], 13, [], 2>;
1069 defm : X86WriteResUnsupported<WriteVecMOVMSKY>;
1070 // defm : X86WriteResUnsupported<WriteVecMOVMSKZ>;
1071
1072 defm : PdWriteRes<WriteMMXMOVMSK, [PdFPU0, PdFPFMA, PdEX0], 10, [], 2>;
1073
1074 ////////////////////////////////////////////////////////////////////////////////
1075 // AES Instructions.
1076 ////////////////////////////////////////////////////////////////////////////////
1077
1078 defm : PdWriteResXMMPair<WriteAESIMC,    [PdFPU0, PdFPMMA], 5>;
1079 defm : PdWriteResXMMPair<WriteAESKeyGen, [PdFPU0, PdFPMMA], 5>;
1080 defm : PdWriteResXMMPair<WriteAESDecEnc, [PdFPU0, PdFPMMA], 9, [], 2>;
1081
1082 ////////////////////////////////////////////////////////////////////////////////
1083 // Horizontal add/sub  instructions.
1084 ////////////////////////////////////////////////////////////////////////////////
1085
1086 defm : PdWriteResXMMPair<WriteFHAdd,  [PdFPU0, PdFPFMA], 11, [],     3, 1>;
1087 defm : PdWriteResYMMPair<WriteFHAddY, [PdFPU0, PdFPFMA], 11, [2, 1], 8, 2>;
1088 defm : X86WriteResPairUnsupported<WriteFHAddZ>;
1089
1090 defm : PdWriteResXMMPair<WritePHAdd,  [PdFPU01, PdFPMAL], 5, [], 3, 1>;
1091 defm : PdWriteResXMMPair<WritePHAddX, [PdFPU01, PdFPMAL], 2>;
1092 defm : X86WriteResPairUnsupported<WritePHAddY>;
1093 defm : X86WriteResPairUnsupported<WritePHAddZ>;
1094
1095 def : InstRW<[WritePHAdd], (instrs PHADDDrr, PHSUBDrr,
1096                                    PHADDWrr, PHSUBWrr,
1097                                    PHADDSWrr, PHSUBSWrr,
1098                                    VPHADDDrr, VPHSUBDrr,
1099                                    VPHADDWrr, VPHSUBWrr,
1100                                    VPHADDSWrr, VPHSUBSWrr)>;
1101
1102 def : InstRW<[WritePHAdd.Folded], (instrs PHADDDrm, PHSUBDrm,
1103                                           PHADDWrm, PHSUBWrm,
1104                                           PHADDSWrm, PHSUBSWrm,
1105                                           VPHADDDrm, VPHSUBDrm,
1106                                           VPHADDWrm, VPHSUBWrm,
1107                                           VPHADDSWrm, VPHSUBSWrm)>;
1108
1109 ////////////////////////////////////////////////////////////////////////////////
1110 // Carry-less multiplication instructions.
1111 ////////////////////////////////////////////////////////////////////////////////
1112
1113 defm : PdWriteResXMMPair<WriteCLMul, [PdFPU0, PdFPMMA], 12, [], 5, 1>;
1114
1115 def PdWriteVPCLMULQDQrr : SchedWriteRes<[PdFPU0, PdFPMMA]> {
1116   let Latency = 13;
1117   let NumMicroOps = 6;
1118 }
1119 def : InstRW<[PdWriteVPCLMULQDQrr], (instrs VPCLMULQDQrr)>;
1120
1121 ////////////////////////////////////////////////////////////////////////////////
1122 // SSE4A instructions.
1123 ////////////////////////////////////////////////////////////////////////////////
1124
1125 def PdWriteINSERTQ : SchedWriteRes<[PdFPU01, PdFPMAL]> {
1126   let Latency = 3;
1127   let ResourceCycles = [1, 4];
1128 }
1129 def : InstRW<[PdWriteINSERTQ], (instrs INSERTQ, INSERTQI)>;
1130
1131 ////////////////////////////////////////////////////////////////////////////////
1132 // AVX instructions.
1133 ////////////////////////////////////////////////////////////////////////////////
1134
1135 def PdWriteVBROADCASTYLd : SchedWriteRes<[PdLoad, PdFPU01, PdFPFMA]> {
1136   let Latency = 6;
1137   let ResourceCycles = [1, 2, 4];
1138   let NumMicroOps = 2;
1139 }
1140 def : InstRW<[PdWriteVBROADCASTYLd, ReadAfterLd], (instrs VBROADCASTSDYrm,
1141                                                           VBROADCASTSSYrm)>;
1142
1143 def PdWriteVZEROALL : SchedWriteRes<[]> {
1144   let Latency = 90;
1145   let NumMicroOps = 32;
1146 }
1147 def : InstRW<[PdWriteVZEROALL], (instrs VZEROALL)>;
1148
1149 def PdWriteVZEROUPPER : SchedWriteRes<[]> {
1150   let Latency = 46;
1151   let NumMicroOps = 16;
1152 }
1153 def : InstRW<[PdWriteVZEROUPPER], (instrs VZEROUPPER)>;
1154
1155 ///////////////////////////////////////////////////////////////////////////////
1156 //  SchedWriteVariant definitions.
1157 ///////////////////////////////////////////////////////////////////////////////
1158
1159 def PdWriteZeroLatency : SchedWriteRes<[]> {
1160   let Latency = 0;
1161 }
1162
1163 def PdWriteZeroIdiom : SchedWriteVariant<[
1164   SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1165   SchedVar<MCSchedPredicate<TruePred>,           [WriteALU]>
1166 ]>;
1167 def : InstRW<[PdWriteZeroIdiom], (instrs SUB32rr, SUB64rr,
1168                                          XOR32rr, XOR64rr)>;
1169
1170 def PdWriteFZeroIdiom : SchedWriteVariant<[
1171   SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1172   SchedVar<MCSchedPredicate<TruePred>,           [WriteFLogic]>
1173 ]>;
1174 def : InstRW<[PdWriteFZeroIdiom], (instrs XORPSrr,  VXORPSrr,
1175                                           XORPDrr,  VXORPDrr,
1176                                           ANDNPSrr, VANDNPSrr,
1177                                           ANDNPDrr, VANDNPDrr)>;
1178
1179 // VXORPSYrr, VXORPDYrr, VANDNPSYrr, VANDNPDYrr "zero-idioms" have latency of 1.
1180
1181 def PdWriteVZeroIdiomLogic : SchedWriteVariant<[
1182   SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1183   SchedVar<MCSchedPredicate<TruePred>,           [WriteVecLogic]>
1184 ]>;
1185 def : InstRW<[PdWriteVZeroIdiomLogic], (instrs MMX_PXORirr, MMX_PANDNirr)>;
1186
1187 def PdWriteVZeroIdiomLogicX : SchedWriteVariant<[
1188   SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1189   SchedVar<MCSchedPredicate<TruePred>,           [WriteVecLogicX]>
1190 ]>;
1191 def : InstRW<[PdWriteVZeroIdiomLogicX], (instrs PXORrr,  VPXORrr,
1192                                                 PANDNrr, VPANDNrr)>;
1193
1194 def PdWriteVZeroIdiomALU : SchedWriteVariant<[
1195   SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1196   SchedVar<MCSchedPredicate<TruePred>,           [WriteVecALU]>
1197 ]>;
1198 def : InstRW<[PdWriteVZeroIdiomALU], (instrs MMX_PSUBBirr,   MMX_PSUBDirr,
1199                                              MMX_PSUBQirr,   MMX_PSUBWirr,
1200                                              MMX_PCMPGTBirr,
1201                                              MMX_PCMPGTDirr,
1202                                              MMX_PCMPGTWirr)>;
1203
1204 def PdWriteVZeroIdiomALUX : SchedWriteVariant<[
1205     SchedVar<MCSchedPredicate<ZeroIdiomPredicate>, [PdWriteZeroLatency]>,
1206     SchedVar<MCSchedPredicate<TruePred>,           [WriteVecALUX]>
1207 ]>;
1208 def : InstRW<[PdWriteVZeroIdiomALUX], (instrs PSUBBrr, VPSUBBrr,
1209                                               PSUBDrr, VPSUBDrr,
1210                                               PSUBQrr, VPSUBQrr,
1211                                               PSUBWrr, VPSUBWrr,
1212                                               PCMPGTBrr, VPCMPGTBrr,
1213                                               PCMPGTDrr, VPCMPGTDrr,
1214                                               PCMPGTWrr, VPCMPGTWrr)>;
1215
1216 ///////////////////////////////////////////////////////////////////////////////
1217 // Dependency breaking instructions.
1218 ///////////////////////////////////////////////////////////////////////////////
1219
1220 // VPCMPGTQ, but not PCMPGTQ!
1221
1222 def : IsZeroIdiomFunction<[
1223   // GPR Zero-idioms.
1224   DepBreakingClass<[ SUB32rr, SUB64rr, XOR32rr, XOR64rr ], ZeroIdiomPredicate>,
1225
1226   // MMX Zero-idioms.
1227   DepBreakingClass<[
1228     MMX_PXORirr, MMX_PANDNirr, MMX_PSUBBirr,
1229     MMX_PSUBDirr, MMX_PSUBQirr, MMX_PSUBWirr,
1230     MMX_PSUBSBirr, MMX_PSUBSWirr, MMX_PSUBUSBirr, MMX_PSUBUSWirr,
1231     MMX_PCMPGTBirr, MMX_PCMPGTDirr, MMX_PCMPGTWirr
1232   ], ZeroIdiomPredicate>,
1233
1234   // SSE Zero-idioms.
1235   DepBreakingClass<[
1236     // fp variants.
1237     XORPSrr, XORPDrr, ANDNPSrr, ANDNPDrr,
1238
1239     // int variants.
1240     PXORrr, PANDNrr,
1241     PSUBBrr, PSUBWrr, PSUBDrr, PSUBQrr,
1242     PSUBSBrr, PSUBSWrr, PSUBUSBrr, PSUBUSWrr,
1243     PCMPGTBrr, PCMPGTDrr, PCMPGTWrr
1244   ], ZeroIdiomPredicate>,
1245
1246   // AVX Zero-idioms.
1247   DepBreakingClass<[
1248     // xmm fp variants.
1249     VXORPSrr, VXORPDrr, VANDNPSrr, VANDNPDrr,
1250
1251     // xmm int variants.
1252     VPXORrr, VPANDNrr,
1253     VPSUBBrr, VPSUBWrr, VPSUBDrr, VPSUBQrr,
1254     VPSUBSBrr, VPSUBSWrr, VPSUBUSBrr, VPSUBUSWrr,
1255     VPCMPGTBrr, VPCMPGTWrr, VPCMPGTDrr, VPCMPGTQrr,
1256
1257     // ymm variants.
1258     VXORPSYrr, VXORPDYrr, VANDNPSYrr, VANDNPDYrr
1259   ], ZeroIdiomPredicate>
1260 ]>;
1261
1262 def : IsDepBreakingFunction<[
1263   // GPR
1264   DepBreakingClass<[ SBB32rr, SBB64rr ], ZeroIdiomPredicate>,
1265   DepBreakingClass<[ CMP32rr, CMP64rr ], CheckSameRegOperand<0, 1> >,
1266
1267   // MMX
1268   DepBreakingClass<[
1269     MMX_PCMPEQBirr, MMX_PCMPEQDirr, MMX_PCMPEQWirr
1270   ], ZeroIdiomPredicate>,
1271
1272   // SSE
1273   DepBreakingClass<[
1274     PCMPEQBrr, PCMPEQWrr, PCMPEQDrr
1275     // But not PCMPEQQrr.
1276   ], ZeroIdiomPredicate>,
1277
1278   // AVX
1279   DepBreakingClass<[
1280     VPCMPEQBrr, VPCMPEQWrr, VPCMPEQDrr
1281     // But not VPCMPEQQrr.
1282   ], ZeroIdiomPredicate>
1283 ]>;
1284
1285
1286 } // SchedModel