lib/Target/X86/X86SchedHaswell.td

   1 //=- X86SchedHaswell.td - X86 Haswell Scheduling -------------*- tablegen -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the machine model for Haswell to support instruction
  11 // scheduling and other instruction cost heuristics.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 def HaswellModel : SchedMachineModel {
  16   // All x86 instructions are modeled as a single micro-op, and HW can decode 4
  17   // instructions per cycle.
  18   let IssueWidth = 4;
  19   let MicroOpBufferSize = 192; // Based on the reorder buffer.
  20   let LoadLatency = 4;
  21   let MispredictPenalty = 16;
  22
  23   // Based on the LSD (loop-stream detector) queue size and benchmarking data.
  24   let LoopMicroOpBufferSize = 50;
  25
  26   // FIXME: SSE4 and AVX are unimplemented. This flag is set to allow
  27   // the scheduler to assign a default model to unrecognized opcodes.
  28   let CompleteModel = 0;
  29 }
  30
  31 let SchedModel = HaswellModel in {
  32
  33 // Haswell can issue micro-ops to 8 different ports in one cycle.
  34
  35 // Ports 0, 1, 5, and 6 handle all computation.
  36 // Port 4 gets the data half of stores. Store data can be available later than
  37 // the store address, but since we don't model the latency of stores, we can
  38 // ignore that.
  39 // Ports 2 and 3 are identical. They handle loads and the address half of
  40 // stores. Port 7 can handle address calculations.
  41 def HWPort0 : ProcResource<1>;
  42 def HWPort1 : ProcResource<1>;
  43 def HWPort2 : ProcResource<1>;
  44 def HWPort3 : ProcResource<1>;
  45 def HWPort4 : ProcResource<1>;
  46 def HWPort5 : ProcResource<1>;
  47 def HWPort6 : ProcResource<1>;
  48 def HWPort7 : ProcResource<1>;
  49
  50 // Many micro-ops are capable of issuing on multiple ports.
  51 def HWPort23  : ProcResGroup<[HWPort2, HWPort3]>;
  52 def HWPort237 : ProcResGroup<[HWPort2, HWPort3, HWPort7]>;
  53 def HWPort05  : ProcResGroup<[HWPort0, HWPort5]>;
  54 def HWPort06 : ProcResGroup<[HWPort0, HWPort6]>;
  55 def HWPort15  : ProcResGroup<[HWPort1, HWPort5]>;
  56 def HWPort16  : ProcResGroup<[HWPort1, HWPort6]>;
  57 def HWPort015 : ProcResGroup<[HWPort0, HWPort1, HWPort5]>;
  58 def HWPort056: ProcResGroup<[HWPort0, HWPort5, HWPort6]>;
  59 def HWPort0156: ProcResGroup<[HWPort0, HWPort1, HWPort5, HWPort6]>;
  60
  61 // 60 Entry Unified Scheduler
  62 def HWPortAny : ProcResGroup<[HWPort0, HWPort1, HWPort2, HWPort3, HWPort4,
  63                               HWPort5, HWPort6, HWPort7]> {
  64   let BufferSize=60;
  65 }
  66
  67 // Integer division issued on port 0.
  68 def HWDivider : ProcResource<1>;
  69
  70 // Loads are 4 cycles, so ReadAfterLd registers needn't be available until 4
  71 // cycles after the memory operand.
  72 def : ReadAdvance<ReadAfterLd, 4>;
  73
  74 // Many SchedWrites are defined in pairs with and without a folded load.
  75 // Instructions with folded loads are usually micro-fused, so they only appear
  76 // as two micro-ops when queued in the reservation station.
  77 // This multiclass defines the resource usage for variants with and without
  78 // folded loads.
  79 multiclass HWWriteResPair<X86FoldableSchedWrite SchedRW,
  80                           ProcResourceKind ExePort,
  81                           int Lat> {
  82   // Register variant is using a single cycle on ExePort.
  83   def : WriteRes<SchedRW, [ExePort]> { let Latency = Lat; }
  84
  85   // Memory variant also uses a cycle on port 2/3 and adds 4 cycles to the
  86   // latency.
  87   def : WriteRes<SchedRW.Folded, [HWPort23, ExePort]> {
  88      let Latency = !add(Lat, 4);
  89   }
  90 }
  91
  92 // A folded store needs a cycle on port 4 for the store data, but it does not
  93 // need an extra port 2/3 cycle to recompute the address.
  94 def : WriteRes<WriteRMW, [HWPort4]>;
  95
  96 // Store_addr on 237.
  97 // Store_data on 4.
  98 def : WriteRes<WriteStore, [HWPort237, HWPort4]>;
  99 def : WriteRes<WriteLoad,  [HWPort23]> { let Latency = 4; }
 100 def : WriteRes<WriteMove,  [HWPort0156]>;
 101 def : WriteRes<WriteZero,  []>;
 102
 103 defm : HWWriteResPair<WriteALU,   HWPort0156, 1>;
 104 defm : HWWriteResPair<WriteIMul,  HWPort1,   3>;
 105 def  : WriteRes<WriteIMulH, []> { let Latency = 3; }
 106 defm : HWWriteResPair<WriteShift, HWPort06,  1>;
 107 defm : HWWriteResPair<WriteJump,  HWPort06,   1>;
 108
 109 // This is for simple LEAs with one or two input operands.
 110 // The complex ones can only execute on port 1, and they require two cycles on
 111 // the port to read all inputs. We don't model that.
 112 def : WriteRes<WriteLEA, [HWPort15]>;
 113
 114 // This is quite rough, latency depends on the dividend.
 115 def : WriteRes<WriteIDiv, [HWPort0, HWDivider]> {
 116   let Latency = 25;
 117   let ResourceCycles = [1, 10];
 118 }
 119 def : WriteRes<WriteIDivLd, [HWPort23, HWPort0, HWDivider]> {
 120   let Latency = 29;
 121   let ResourceCycles = [1, 1, 10];
 122 }
 123
 124 // Scalar and vector floating point.
 125 defm : HWWriteResPair<WriteFAdd,   HWPort1, 3>;
 126 defm : HWWriteResPair<WriteFMul,   HWPort0, 5>;
 127 defm : HWWriteResPair<WriteFDiv,   HWPort0, 12>; // 10-14 cycles.
 128 defm : HWWriteResPair<WriteFRcp,   HWPort0, 5>;
 129 defm : HWWriteResPair<WriteFSqrt,  HWPort0, 15>;
 130 defm : HWWriteResPair<WriteCvtF2I, HWPort1, 3>;
 131 defm : HWWriteResPair<WriteCvtI2F, HWPort1, 4>;
 132 defm : HWWriteResPair<WriteCvtF2F, HWPort1, 3>;
 133 defm : HWWriteResPair<WriteFShuffle,  HWPort5,  1>;
 134 defm : HWWriteResPair<WriteFBlend,  HWPort015,  1>;
 135 defm : HWWriteResPair<WriteFShuffle256,  HWPort5,  3>;
 136
 137 def : WriteRes<WriteFVarBlend, [HWPort5]> {
 138   let Latency = 2;
 139   let ResourceCycles = [2];
 140 }
 141 def : WriteRes<WriteFVarBlendLd, [HWPort5, HWPort23]> {
 142   let Latency = 6;
 143   let ResourceCycles = [2, 1];
 144 }
 145
 146 // Vector integer operations.
 147 defm : HWWriteResPair<WriteVecShift, HWPort0,  1>;
 148 defm : HWWriteResPair<WriteVecLogic, HWPort015, 1>;
 149 defm : HWWriteResPair<WriteVecALU,   HWPort15,  1>;
 150 defm : HWWriteResPair<WriteVecIMul,  HWPort0,   5>;
 151 defm : HWWriteResPair<WriteShuffle,  HWPort5,  1>;
 152 defm : HWWriteResPair<WriteBlend,  HWPort15,  1>;
 153 defm : HWWriteResPair<WriteShuffle256,  HWPort5,  3>;
 154
 155 def : WriteRes<WriteVarBlend, [HWPort5]> {
 156   let Latency = 2;
 157   let ResourceCycles = [2];
 158 }
 159 def : WriteRes<WriteVarBlendLd, [HWPort5, HWPort23]> {
 160   let Latency = 6;
 161   let ResourceCycles = [2, 1];
 162 }
 163
 164 def : WriteRes<WriteVarVecShift, [HWPort0, HWPort5]> {
 165   let Latency = 2;
 166   let ResourceCycles = [2, 1];
 167 }
 168 def : WriteRes<WriteVarVecShiftLd, [HWPort0, HWPort5, HWPort23]> {
 169   let Latency = 6;
 170   let ResourceCycles = [2, 1, 1];
 171 }
 172
 173 def : WriteRes<WriteMPSAD, [HWPort0, HWPort5]> {
 174   let Latency = 6;
 175   let ResourceCycles = [1, 2];
 176 }
 177 def : WriteRes<WriteMPSADLd, [HWPort23, HWPort0, HWPort5]> {
 178   let Latency = 6;
 179   let ResourceCycles = [1, 1, 2];
 180 }
 181
 182 // String instructions.
 183 // Packed Compare Implicit Length Strings, Return Mask
 184 def : WriteRes<WritePCmpIStrM, [HWPort0]> {
 185   let Latency = 10;
 186   let ResourceCycles = [3];
 187 }
 188 def : WriteRes<WritePCmpIStrMLd, [HWPort0, HWPort23]> {
 189   let Latency = 10;
 190   let ResourceCycles = [3, 1];
 191 }
 192
 193 // Packed Compare Explicit Length Strings, Return Mask
 194 def : WriteRes<WritePCmpEStrM, [HWPort0, HWPort16, HWPort5]> {
 195   let Latency = 10;
 196   let ResourceCycles = [3, 2, 4];
 197 }
 198 def : WriteRes<WritePCmpEStrMLd, [HWPort05, HWPort16, HWPort23]> {
 199   let Latency = 10;
 200   let ResourceCycles = [6, 2, 1];
 201 }
 202
 203 // Packed Compare Implicit Length Strings, Return Index
 204 def : WriteRes<WritePCmpIStrI, [HWPort0]> {
 205   let Latency = 11;
 206   let ResourceCycles = [3];
 207 }
 208 def : WriteRes<WritePCmpIStrILd, [HWPort0, HWPort23]> {
 209   let Latency = 11;
 210   let ResourceCycles = [3, 1];
 211 }
 212
 213 // Packed Compare Explicit Length Strings, Return Index
 214 def : WriteRes<WritePCmpEStrI, [HWPort05, HWPort16]> {
 215   let Latency = 11;
 216   let ResourceCycles = [6, 2];
 217 }
 218 def : WriteRes<WritePCmpEStrILd, [HWPort0, HWPort16, HWPort5, HWPort23]> {
 219   let Latency = 11;
 220   let ResourceCycles = [3, 2, 2, 1];
 221 }
 222
 223 // AES Instructions.
 224 def : WriteRes<WriteAESDecEnc, [HWPort5]> {
 225   let Latency = 7;
 226   let ResourceCycles = [1];
 227 }
 228 def : WriteRes<WriteAESDecEncLd, [HWPort5, HWPort23]> {
 229   let Latency = 7;
 230   let ResourceCycles = [1, 1];
 231 }
 232
 233 def : WriteRes<WriteAESIMC, [HWPort5]> {
 234   let Latency = 14;
 235   let ResourceCycles = [2];
 236 }
 237 def : WriteRes<WriteAESIMCLd, [HWPort5, HWPort23]> {
 238   let Latency = 14;
 239   let ResourceCycles = [2, 1];
 240 }
 241
 242 def : WriteRes<WriteAESKeyGen, [HWPort0, HWPort5]> {
 243   let Latency = 10;
 244   let ResourceCycles = [2, 8];
 245 }
 246 def : WriteRes<WriteAESKeyGenLd, [HWPort0, HWPort5, HWPort23]> {
 247   let Latency = 10;
 248   let ResourceCycles = [2, 7, 1];
 249 }
 250
 251 // Carry-less multiplication instructions.
 252 def : WriteRes<WriteCLMul, [HWPort0, HWPort5]> {
 253   let Latency = 7;
 254   let ResourceCycles = [2, 1];
 255 }
 256 def : WriteRes<WriteCLMulLd, [HWPort0, HWPort5, HWPort23]> {
 257   let Latency = 7;
 258   let ResourceCycles = [2, 1, 1];
 259 }
 260
 261 def : WriteRes<WriteSystem,     [HWPort0156]> { let Latency = 100; }
 262 def : WriteRes<WriteMicrocoded, [HWPort0156]> { let Latency = 100; }
 263 def : WriteRes<WriteFence,  [HWPort23, HWPort4]>;
 264 def : WriteRes<WriteNop, []>;
 265
 266 //================ Exceptions ================//
 267
 268 //-- Specific Scheduling Models --//
 269 def WriteP1_Lat3 : SchedWriteRes<[HWPort1]> {
 270   let Latency = 3;
 271 }
 272 def WriteP1_Lat3Ld : SchedWriteRes<[HWPort1, HWPort23]> {
 273   let Latency = 7;
 274 }
 275
 276 def Write2P0156_Lat2 : SchedWriteRes<[HWPort0156]> {
 277   let Latency = 2;
 278   let ResourceCycles = [2];
 279 }
 280 def Write2P0156_Lat2Ld : SchedWriteRes<[HWPort0156, HWPort23]> {
 281   let Latency = 6;
 282   let ResourceCycles = [2, 1];
 283 }
 284
 285 def Write2P237_P4 : SchedWriteRes<[HWPort237, HWPort4]> {
 286   let Latency = 1;
 287   let ResourceCycles = [2, 1];
 288 }
 289
 290 def WriteP06 : SchedWriteRes<[HWPort06]>;
 291
 292 def Write2P06 : SchedWriteRes<[HWPort06]> {
 293   let Latency = 1;
 294   let NumMicroOps = 2;
 295   let ResourceCycles = [2];
 296 }
 297
 298 def WriteP15 : SchedWriteRes<[HWPort15]>;
 299 def WriteP15Ld : SchedWriteRes<[HWPort15, HWPort23]> {
 300   let Latency = 4;
 301 }
 302
 303 def Write3P06_Lat2 : SchedWriteRes<[HWPort06]> {
 304   let Latency = 2;
 305   let NumMicroOps = 3;
 306   let ResourceCycles = [3];
 307 }
 308
 309 def WriteP0156_P23 : SchedWriteRes<[HWPort0156, HWPort23]> {
 310   let NumMicroOps = 2;
 311 }
 312
 313 def WriteP0156_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 314   let Latency = 1;
 315   let ResourceCycles = [1, 2, 1];
 316 }
 317
 318 def Write2P0156_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 319   let Latency = 1;
 320   let ResourceCycles = [2, 2, 1];
 321 }
 322
 323 def Write2P0156_P23 : SchedWriteRes<[HWPort0156, HWPort23]> {
 324   let NumMicroOps = 3;
 325   let ResourceCycles = [2, 1];
 326 }
 327
 328 def Write3P0156_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 329   let Latency = 1;
 330   let ResourceCycles = [3, 2, 1];
 331 }
 332
 333 // Notation:
 334 // - r: register.
 335 // - mm: 64 bit mmx register.
 336 // - x = 128 bit xmm register.
 337 // - (x)mm = mmx or xmm register.
 338 // - y = 256 bit ymm register.
 339 // - v = any vector register.
 340 // - m = memory.
 341
 342 //=== Integer Instructions ===//
 343 //-- Move instructions --//
 344
 345 // MOV.
 346 // r16,m.
 347 def : InstRW<[WriteALULd], (instregex "MOV16rm")>;
 348
 349 // MOVSX, MOVZX.
 350 // r,m.
 351 def : InstRW<[WriteLoad], (instregex "MOV(S|Z)X32rm(8|16)")>;
 352
 353 // CMOVcc.
 354 // r,r.
 355 def : InstRW<[Write2P0156_Lat2],
 356       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rr")>;
 357 // r,m.
 358 def : InstRW<[Write2P0156_Lat2Ld, ReadAfterLd],
 359       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rm")>;
 360
 361 // XCHG.
 362 // r,r.
 363 def WriteXCHG : SchedWriteRes<[HWPort0156]> {
 364   let Latency = 2;
 365   let ResourceCycles = [3];
 366 }
 367
 368 def : InstRW<[WriteXCHG], (instregex "XCHG(8|16|32|64)rr", "XCHG(16|32|64)ar")>;
 369
 370 // r,m.
 371 def WriteXCHGrm : SchedWriteRes<[]> {
 372   let Latency = 21;
 373   let NumMicroOps = 8;
 374 }
 375 def : InstRW<[WriteXCHGrm], (instregex "XCHG(8|16|32|64)rm")>;
 376
 377 // XLAT.
 378 def WriteXLAT : SchedWriteRes<[]> {
 379   let Latency = 7;
 380   let NumMicroOps = 3;
 381 }
 382 def : InstRW<[WriteXLAT], (instregex "XLAT")>;
 383
 384 // PUSH.
 385 // m.
 386 def : InstRW<[Write2P237_P4], (instregex "PUSH(16|32)rmm")>;
 387
 388 // PUSHF.
 389 def WritePushF : SchedWriteRes<[HWPort1, HWPort4, HWPort237, HWPort06]> {
 390   let NumMicroOps = 4;
 391 }
 392 def : InstRW<[WritePushF], (instregex "PUSHF(16|32)")>;
 393
 394 // PUSHA.
 395 def WritePushA : SchedWriteRes<[]> {
 396   let NumMicroOps = 19;
 397 }
 398 def : InstRW<[WritePushA], (instregex "PUSHA(16|32)")>;
 399
 400 // POP.
 401 // m.
 402 def : InstRW<[Write2P237_P4], (instregex "POP(16|32)rmm")>;
 403
 404 // POPF.
 405 def WritePopF : SchedWriteRes<[]> {
 406   let NumMicroOps = 9;
 407 }
 408 def : InstRW<[WritePopF], (instregex "POPF(16|32)")>;
 409
 410 // POPA.
 411 def WritePopA : SchedWriteRes<[]> {
 412   let NumMicroOps = 18;
 413 }
 414 def : InstRW<[WritePopA], (instregex "POPA(16|32)")>;
 415
 416 // LAHF SAHF.
 417 def : InstRW<[WriteP06], (instregex "(S|L)AHF")>;
 418
 419 // BSWAP.
 420 // r32.
 421 def WriteBSwap32 : SchedWriteRes<[HWPort15]>;
 422 def : InstRW<[WriteBSwap32], (instregex "BSWAP32r")>;
 423
 424 // r64.
 425 def WriteBSwap64 : SchedWriteRes<[HWPort06, HWPort15]> {
 426   let NumMicroOps = 2;
 427 }
 428 def : InstRW<[WriteBSwap64], (instregex "BSWAP64r")>;
 429
 430 // MOVBE.
 431 // r16,m16 / r64,m64.
 432 def : InstRW<[Write2P0156_Lat2Ld], (instregex "MOVBE(16|64)rm")>;
 433
 434 // r32, m32.
 435 def WriteMoveBE32rm : SchedWriteRes<[HWPort15, HWPort23]> {
 436   let NumMicroOps = 2;
 437 }
 438 def : InstRW<[WriteMoveBE32rm], (instregex "MOVBE32rm")>;
 439
 440 // m16,r16.
 441 def WriteMoveBE16mr : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 442   let NumMicroOps = 3;
 443 }
 444 def : InstRW<[WriteMoveBE16mr], (instregex "MOVBE16mr")>;
 445
 446 // m32,r32.
 447 def WriteMoveBE32mr : SchedWriteRes<[HWPort15, HWPort237, HWPort4]> {
 448   let NumMicroOps = 3;
 449 }
 450 def : InstRW<[WriteMoveBE32mr], (instregex "MOVBE32mr")>;
 451
 452 // m64,r64.
 453 def WriteMoveBE64mr : SchedWriteRes<[HWPort06, HWPort15, HWPort237, HWPort4]> {
 454   let NumMicroOps = 4;
 455 }
 456 def : InstRW<[WriteMoveBE64mr], (instregex "MOVBE64mr")>;
 457
 458 //-- Arithmetic instructions --//
 459
 460 // ADD SUB.
 461 // m,r/i.
 462 def : InstRW<[Write2P0156_2P237_P4],
 463               (instregex "(ADD|SUB)(8|16|32|64)m(r|i)",
 464               "(ADD|SUB)(8|16|32|64)mi8", "(ADD|SUB)64mi32")>;
 465
 466 // ADC SBB.
 467 // r,r/i.
 468 def : InstRW<[Write2P0156_Lat2], (instregex "(ADC|SBB)(8|16|32|64)r(r|i)",
 469                            "(ADC|SBB)(16|32|64)ri8",
 470                            "(ADC|SBB)64ri32",
 471                            "(ADC|SBB)(8|16|32|64)rr_REV")>;
 472
 473 // r,m.
 474 def : InstRW<[Write2P0156_Lat2Ld, ReadAfterLd], (instregex "(ADC|SBB)(8|16|32|64)rm")>;
 475
 476 // m,r/i.
 477 def : InstRW<[Write3P0156_2P237_P4],
 478              (instregex "(ADC|SBB)(8|16|32|64)m(r|i)",
 479               "(ADC|SBB)(16|32|64)mi8",
 480               "(ADC|SBB)64mi32")>;
 481
 482 // INC DEC NOT NEG.
 483 // m.
 484 def : InstRW<[WriteP0156_2P237_P4],
 485              (instregex "(INC|DEC|NOT|NEG)(8|16|32|64)m",
 486               "(INC|DEC)64(16|32)m")>;
 487
 488 // MUL IMUL.
 489 // r16.
 490 def WriteMul16 : SchedWriteRes<[HWPort1, HWPort0156]> {
 491   let Latency = 4;
 492   let NumMicroOps = 4;
 493 }
 494 def : InstRW<[WriteMul16], (instregex "IMUL16r", "MUL16r")>;
 495
 496 // m16.
 497 def WriteMul16Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 498   let Latency = 8;
 499   let NumMicroOps = 5;
 500 }
 501 def : InstRW<[WriteMul16Ld], (instregex "IMUL16m", "MUL16m")>;
 502
 503 // r32.
 504 def WriteMul32 : SchedWriteRes<[HWPort1, HWPort0156]> {
 505   let Latency = 4;
 506   let NumMicroOps = 3;
 507 }
 508 def : InstRW<[WriteMul32], (instregex "IMUL32r", "MUL32r")>;
 509
 510 // m32.
 511 def WriteMul32Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 512   let Latency = 8;
 513   let NumMicroOps = 4;
 514 }
 515 def : InstRW<[WriteMul32Ld], (instregex "IMUL32m", "MUL32m")>;
 516
 517 // r64.
 518 def WriteMul64 : SchedWriteRes<[HWPort1, HWPort6]> {
 519   let Latency = 3;
 520   let NumMicroOps = 2;
 521 }
 522 def : InstRW<[WriteMul64], (instregex "IMUL64r", "MUL64r")>;
 523
 524 // m64.
 525 def WriteMul64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 526   let Latency = 7;
 527   let NumMicroOps = 3;
 528 }
 529 def : InstRW<[WriteMul64Ld], (instregex "IMUL64m", "MUL64m")>;
 530
 531 // r16,r16.
 532 def WriteMul16rri : SchedWriteRes<[HWPort1, HWPort0156]> {
 533   let Latency = 4;
 534   let NumMicroOps = 2;
 535 }
 536 def : InstRW<[WriteMul16rri], (instregex "IMUL16rri", "IMUL16rri8")>;
 537
 538 // r16,m16.
 539 def WriteMul16rmi : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 540   let Latency = 8;
 541   let NumMicroOps = 3;
 542 }
 543 def : InstRW<[WriteMul16rmi], (instregex "IMUL16rmi", "IMUL16rmi8")>;
 544
 545 // MULX.
 546 // r32,r32,r32.
 547 def WriteMulX32 : SchedWriteRes<[HWPort1, HWPort056]> {
 548   let Latency = 4;
 549   let NumMicroOps = 3;
 550   let ResourceCycles = [1, 2];
 551 }
 552 def : InstRW<[WriteMulX32], (instregex "MULX32rr")>;
 553
 554 // r32,r32,m32.
 555 def WriteMulX32Ld : SchedWriteRes<[HWPort1, HWPort056, HWPort23]> {
 556   let Latency = 8;
 557   let NumMicroOps = 4;
 558   let ResourceCycles = [1, 2, 1];
 559 }
 560 def : InstRW<[WriteMulX32Ld], (instregex "MULX32rm")>;
 561
 562 // r64,r64,r64.
 563 def WriteMulX64 : SchedWriteRes<[HWPort1, HWPort6]> {
 564   let Latency = 4;
 565   let NumMicroOps = 2;
 566 }
 567 def : InstRW<[WriteMulX64], (instregex "MULX64rr")>;
 568
 569 // r64,r64,m64.
 570 def WriteMulX64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 571   let Latency = 8;
 572   let NumMicroOps = 3;
 573 }
 574 def : InstRW<[WriteMulX64Ld], (instregex "MULX64rm")>;
 575
 576 // DIV.
 577 // r8.
 578 def WriteDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 579   let Latency = 22;
 580   let NumMicroOps = 9;
 581 }
 582 def : InstRW<[WriteDiv8], (instregex "DIV8r")>;
 583
 584 // r16.
 585 def WriteDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 586   let Latency = 23;
 587   let NumMicroOps = 10;
 588 }
 589 def : InstRW<[WriteDiv16], (instregex "DIV16r")>;
 590
 591 // r32.
 592 def WriteDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 593   let Latency = 22;
 594   let NumMicroOps = 10;
 595 }
 596 def : InstRW<[WriteDiv32], (instregex "DIV32r")>;
 597
 598 // r64.
 599 def WriteDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 600   let Latency = 32;
 601   let NumMicroOps = 36;
 602 }
 603 def : InstRW<[WriteDiv64], (instregex "DIV64r")>;
 604
 605 // IDIV.
 606 // r8.
 607 def WriteIDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 608   let Latency = 23;
 609   let NumMicroOps = 9;
 610 }
 611 def : InstRW<[WriteIDiv8], (instregex "IDIV8r")>;
 612
 613 // r16.
 614 def WriteIDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 615   let Latency = 23;
 616   let NumMicroOps = 10;
 617 }
 618 def : InstRW<[WriteIDiv16], (instregex "IDIV16r")>;
 619
 620 // r32.
 621 def WriteIDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 622   let Latency = 22;
 623   let NumMicroOps = 9;
 624 }
 625 def : InstRW<[WriteIDiv32], (instregex "IDIV32r")>;
 626
 627 // r64.
 628 def WriteIDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 629   let Latency = 39;
 630   let NumMicroOps = 59;
 631 }
 632 def : InstRW<[WriteIDiv64], (instregex "IDIV64r")>;
 633
 634 //-- Logic instructions --//
 635
 636 // AND OR XOR.
 637 // m,r/i.
 638 def : InstRW<[Write2P0156_2P237_P4],
 639              (instregex "(AND|OR|XOR)(8|16|32|64)m(r|i)",
 640               "(AND|OR|XOR)(8|16|32|64)mi8", "(AND|OR|XOR)64mi32")>;
 641
 642 // SHR SHL SAR.
 643 // m,i.
 644 def WriteShiftRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 645   let NumMicroOps = 4;
 646   let ResourceCycles = [2, 1, 1];
 647 }
 648 def : InstRW<[WriteShiftRMW], (instregex "S(A|H)(R|L)(8|16|32|64)m(i|1)")>;
 649
 650 // r,cl.
 651 def : InstRW<[Write3P06_Lat2], (instregex "S(A|H)(R|L)(8|16|32|64)rCL")>;
 652
 653 // m,cl.
 654 def WriteShiftClLdRMW : SchedWriteRes<[HWPort06, HWPort23, HWPort4]> {
 655   let NumMicroOps = 6;
 656   let ResourceCycles = [3, 2, 1];
 657 }
 658 def : InstRW<[WriteShiftClLdRMW], (instregex "S(A|H)(R|L)(8|16|32|64)mCL")>;
 659
 660 // ROR ROL.
 661 // r,1.
 662 def : InstRW<[Write2P06], (instregex "RO(R|L)(8|16|32|64)r1")>;
 663
 664 // m,i.
 665 def WriteRotateRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 666   let NumMicroOps = 5;
 667   let ResourceCycles = [2, 2, 1];
 668 }
 669 def : InstRW<[WriteRotateRMW], (instregex "RO(R|L)(8|16|32|64)mi")>;
 670
 671 // r,cl.
 672 def : InstRW<[Write3P06_Lat2], (instregex "RO(R|L)(8|16|32|64)rCL")>;
 673
 674 // m,cl.
 675 def WriteRotateRMWCL : SchedWriteRes<[]> {
 676   let NumMicroOps = 6;
 677 }
 678 def : InstRW<[WriteRotateRMWCL], (instregex "RO(R|L)(8|16|32|64)mCL")>;
 679
 680 // RCR RCL.
 681 // r,1.
 682 def WriteRCr1 : SchedWriteRes<[HWPort06, HWPort0156]> {
 683   let Latency = 2;
 684   let NumMicroOps = 3;
 685   let ResourceCycles = [2, 1];
 686 }
 687 def : InstRW<[WriteRCr1], (instregex "RC(R|L)(8|16|32|64)r1")>;
 688
 689 // m,1.
 690 def WriteRCm1 : SchedWriteRes<[]> {
 691   let NumMicroOps = 6;
 692 }
 693 def : InstRW<[WriteRCm1], (instregex "RC(R|L)(8|16|32|64)m1")>;
 694
 695 // r,i.
 696 def WriteRCri : SchedWriteRes<[HWPort0156]> {
 697   let Latency = 6;
 698   let NumMicroOps = 8;
 699 }
 700 def : InstRW<[WriteRCri], (instregex "RC(R|L)(8|16|32|64)r(i|CL)")>;
 701
 702 // m,i.
 703 def WriteRCmi : SchedWriteRes<[]> {
 704   let NumMicroOps = 11;
 705 }
 706 def : InstRW<[WriteRCmi], (instregex "RC(R|L)(8|16|32|64)m(i|CL)")>;
 707
 708 // SHRD SHLD.
 709 // r,r,i.
 710 def WriteShDrr : SchedWriteRes<[HWPort1]> {
 711   let Latency = 3;
 712 }
 713 def : InstRW<[WriteShDrr], (instregex "SH(R|L)D(16|32|64)rri8")>;
 714
 715 // m,r,i.
 716 def WriteShDmr : SchedWriteRes<[]> {
 717   let NumMicroOps = 5;
 718 }
 719 def : InstRW<[WriteShDmr], (instregex "SH(R|L)D(16|32|64)mri8")>;
 720
 721 // r,r,cl.
 722 def WriteShlDCL : SchedWriteRes<[HWPort0156]> {
 723   let Latency = 3;
 724   let NumMicroOps = 4;
 725 }
 726 def : InstRW<[WriteShlDCL], (instregex "SHLD(16|32|64)rrCL")>;
 727
 728 // r,r,cl.
 729 def WriteShrDCL : SchedWriteRes<[HWPort0156]> {
 730   let Latency = 4;
 731   let NumMicroOps = 4;
 732 }
 733 def : InstRW<[WriteShrDCL], (instregex "SHRD(16|32|64)rrCL")>;
 734
 735 // m,r,cl.
 736 def WriteShDmrCL : SchedWriteRes<[]> {
 737   let NumMicroOps = 7;
 738 }
 739 def : InstRW<[WriteShDmrCL], (instregex "SH(R|L)D(16|32|64)mrCL")>;
 740
 741 // BT.
 742 // r,r/i.
 743 def : InstRW<[WriteShift], (instregex "BT(16|32|64)r(r|i8)")>;
 744
 745 // m,r.
 746 def WriteBTmr : SchedWriteRes<[]> {
 747   let NumMicroOps = 10;
 748 }
 749 def : InstRW<[WriteBTmr], (instregex "BT(16|32|64)mr")>;
 750
 751 // m,i.
 752 def : InstRW<[WriteShiftLd], (instregex "BT(16|32|64)mi8")>;
 753
 754 // BTR BTS BTC.
 755 // r,r,i.
 756 def : InstRW<[WriteShift], (instregex "BT(R|S|C)(16|32|64)r(r|i8)")>;
 757
 758 // m,r.
 759 def WriteBTRSCmr : SchedWriteRes<[]> {
 760   let NumMicroOps = 11;
 761 }
 762 def : InstRW<[WriteBTRSCmr], (instregex "BT(R|S|C)(16|32|64)mr")>;
 763
 764 // m,i.
 765 def : InstRW<[WriteShiftLd], (instregex "BT(R|S|C)(16|32|64)mi8")>;
 766
 767 // BSF BSR.
 768 // r,r.
 769 def : InstRW<[WriteP1_Lat3], (instregex "BS(R|F)(16|32|64)rr")>;
 770 // r,m.
 771 def : InstRW<[WriteP1_Lat3Ld], (instregex "BS(R|F)(16|32|64)rm")>;
 772
 773 // SETcc.
 774 // r.
 775 def : InstRW<[WriteShift],
 776              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)r")>;
 777 // m.
 778 def WriteSetCCm : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 779   let NumMicroOps = 3;
 780 }
 781 def : InstRW<[WriteSetCCm],
 782              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)m")>;
 783
 784 // CLD STD.
 785 def WriteCldStd : SchedWriteRes<[HWPort15, HWPort6]> {
 786   let NumMicroOps = 3;
 787 }
 788 def : InstRW<[WriteCldStd], (instregex "STD", "CLD")>;
 789
 790 // LZCNT TZCNT.
 791 // r,r.
 792 def : InstRW<[WriteP1_Lat3], (instregex "(L|TZCNT)(16|32|64)rr")>;
 793 // r,m.
 794 def : InstRW<[WriteP1_Lat3Ld], (instregex "(L|TZCNT)(16|32|64)rm")>;
 795
 796 // ANDN.
 797 // r,r.
 798 def : InstRW<[WriteP15], (instregex "ANDN(32|64)rr")>;
 799 // r,m.
 800 def : InstRW<[WriteP15Ld], (instregex "ANDN(32|64)rm")>;
 801
 802 // BLSI BLSMSK BLSR.
 803 // r,r.
 804 def : InstRW<[WriteP15], (instregex "BLS(I|MSK|R)(32|64)rr")>;
 805 // r,m.
 806 def : InstRW<[WriteP15Ld], (instregex "BLS(I|MSK|R)(32|64)rm")>;
 807
 808 // BEXTR.
 809 // r,r,r.
 810 def : InstRW<[Write2P0156_Lat2], (instregex "BEXTR(32|64)rr")>;
 811 // r,m,r.
 812 def : InstRW<[Write2P0156_Lat2Ld], (instregex "BEXTR(32|64)rm")>;
 813
 814 // BZHI.
 815 // r,r,r.
 816 def : InstRW<[WriteP15], (instregex "BZHI(32|64)rr")>;
 817 // r,m,r.
 818 def : InstRW<[WriteP15Ld], (instregex "BZHI(32|64)rm")>;
 819
 820 // PDEP PEXT.
 821 // r,r,r.
 822 def : InstRW<[WriteP1_Lat3], (instregex "PDEP(32|64)rr", "PEXT(32|64)rr")>;
 823 // r,m,r.
 824 def : InstRW<[WriteP1_Lat3Ld], (instregex "PDEP(32|64)rm", "PEXT(32|64)rm")>;
 825
 826 //-- Control transfer instructions --//
 827
 828 // J(E|R)CXZ.
 829 def WriteJCXZ : SchedWriteRes<[HWPort0156, HWPort6]> {
 830   let NumMicroOps = 2;
 831 }
 832 def : InstRW<[WriteJCXZ], (instregex "JCXZ", "JECXZ_(32|64)", "JRCXZ")>;
 833
 834 // LOOP.
 835 def WriteLOOP : SchedWriteRes<[]> {
 836   let NumMicroOps = 7;
 837 }
 838 def : InstRW<[WriteLOOP], (instregex "LOOP")>;
 839
 840 // LOOP(N)E
 841 def WriteLOOPE : SchedWriteRes<[]> {
 842   let NumMicroOps = 11;
 843 }
 844 def : InstRW<[WriteLOOPE], (instregex "LOOPE", "LOOPNE")>;
 845
 846 // CALL.
 847 // r.
 848 def WriteCALLr : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 849   let NumMicroOps = 3;
 850 }
 851 def : InstRW<[WriteCALLr], (instregex "CALL(16|32)r")>;
 852
 853 // m.
 854 def WriteCALLm : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 855   let NumMicroOps = 4;
 856   let ResourceCycles = [2, 1, 1];
 857 }
 858 def : InstRW<[WriteCALLm], (instregex "CALL(16|32)m")>;
 859
 860 // RET.
 861 def WriteRET : SchedWriteRes<[HWPort237, HWPort6]> {
 862   let NumMicroOps = 2;
 863 }
 864 def : InstRW<[WriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)")>;
 865
 866 // i.
 867 def WriteRETI : SchedWriteRes<[HWPort23, HWPort6, HWPort015]> {
 868   let NumMicroOps = 4;
 869   let ResourceCycles = [1, 2, 1];
 870 }
 871 def : InstRW<[WriteRETI], (instregex "RETI(L|Q|W)", "LRETI(L|Q|W)")>;
 872
 873 // BOUND.
 874 // r,m.
 875 def WriteBOUND : SchedWriteRes<[]> {
 876   let NumMicroOps = 15;
 877 }
 878 def : InstRW<[WriteBOUND], (instregex "BOUNDS(16|32)rm")>;
 879
 880 // INTO.
 881 def WriteINTO : SchedWriteRes<[]> {
 882   let NumMicroOps = 4;
 883 }
 884 def : InstRW<[WriteINTO], (instregex "INTO")>;
 885
 886 //-- String instructions --//
 887
 888 // LODSB/W.
 889 def : InstRW<[Write2P0156_P23], (instregex "LODS(B|W)")>;
 890
 891 // LODSD/Q.
 892 def : InstRW<[WriteP0156_P23], (instregex "LODS(L|Q)")>;
 893
 894 // STOS.
 895 def WriteSTOS : SchedWriteRes<[HWPort23, HWPort0156, HWPort4]> {
 896   let NumMicroOps = 3;
 897 }
 898 def : InstRW<[WriteSTOS], (instregex "STOS(B|L|Q|W)")>;
 899
 900 // MOVS.
 901 def WriteMOVS : SchedWriteRes<[HWPort23, HWPort4, HWPort0156]> {
 902   let Latency = 4;
 903   let NumMicroOps = 5;
 904   let ResourceCycles = [2, 1, 2];
 905 }
 906 def : InstRW<[WriteMOVS], (instregex "MOVS(B|L|Q|W)")>;
 907
 908 // SCAS.
 909 def : InstRW<[Write2P0156_P23], (instregex "SCAS(B|W|L|Q)")>;
 910
 911 // CMPS.
 912 def WriteCMPS : SchedWriteRes<[HWPort23, HWPort0156]> {
 913   let Latency = 4;
 914   let NumMicroOps = 5;
 915   let ResourceCycles = [2, 3];
 916 }
 917 def : InstRW<[WriteCMPS], (instregex "CMPS(B|L|Q|W)")>;
 918
 919 //-- Synchronization instructions --//
 920
 921 // XADD.
 922 def WriteXADD : SchedWriteRes<[]> {
 923   let NumMicroOps = 5;
 924 }
 925 def : InstRW<[WriteXADD], (instregex "XADD(8|16|32|64)rm")>;
 926
 927 // CMPXCHG.
 928 def WriteCMPXCHG : SchedWriteRes<[]> {
 929   let NumMicroOps = 6;
 930 }
 931 def : InstRW<[WriteCMPXCHG], (instregex "CMPXCHG(8|16|32|64)rm")>;
 932
 933 // CMPXCHG8B.
 934 def WriteCMPXCHG8B : SchedWriteRes<[]> {
 935   let NumMicroOps = 15;
 936 }
 937 def : InstRW<[WriteCMPXCHG8B], (instregex "CMPXCHG8B")>;
 938
 939 // CMPXCHG16B.
 940 def WriteCMPXCHG16B : SchedWriteRes<[]> {
 941   let NumMicroOps = 22;
 942 }
 943 def : InstRW<[WriteCMPXCHG16B], (instregex "CMPXCHG16B")>;
 944
 945 } // SchedModel