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_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 310   let Latency = 1;
 311   let ResourceCycles = [1, 2, 1];
 312 }
 313
 314 def Write2P0156_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 315   let Latency = 1;
 316   let ResourceCycles = [2, 2, 1];
 317 }
 318
 319 def Write3P0156_2P237_P4 : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 320   let Latency = 1;
 321   let ResourceCycles = [3, 2, 1];
 322 }
 323
 324 // Notation:
 325 // - r: register.
 326 // - mm: 64 bit mmx register.
 327 // - x = 128 bit xmm register.
 328 // - (x)mm = mmx or xmm register.
 329 // - y = 256 bit ymm register.
 330 // - v = any vector register.
 331 // - m = memory.
 332
 333 //=== Integer Instructions ===//
 334 //-- Move instructions --//
 335
 336 // MOV.
 337 // r16,m.
 338 def : InstRW<[WriteALULd], (instregex "MOV16rm")>;
 339
 340 // MOVSX, MOVZX.
 341 // r,m.
 342 def : InstRW<[WriteLoad], (instregex "MOV(S|Z)X32rm(8|16)")>;
 343
 344 // CMOVcc.
 345 // r,r.
 346 def : InstRW<[Write2P0156_Lat2],
 347       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rr")>;
 348 // r,m.
 349 def : InstRW<[Write2P0156_Lat2Ld, ReadAfterLd],
 350       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rm")>;
 351
 352 // XCHG.
 353 // r,r.
 354 def WriteXCHG : SchedWriteRes<[HWPort0156]> {
 355   let Latency = 2;
 356   let ResourceCycles = [3];
 357 }
 358
 359 def : InstRW<[WriteXCHG], (instregex "XCHG(8|16|32|64)rr", "XCHG(16|32|64)ar")>;
 360
 361 // r,m.
 362 def WriteXCHGrm : SchedWriteRes<[]> {
 363   let Latency = 21;
 364   let NumMicroOps = 8;
 365 }
 366 def : InstRW<[WriteXCHGrm], (instregex "XCHG(8|16|32|64)rm")>;
 367
 368 // XLAT.
 369 def WriteXLAT : SchedWriteRes<[]> {
 370   let Latency = 7;
 371   let NumMicroOps = 3;
 372 }
 373 def : InstRW<[WriteXLAT], (instregex "XLAT")>;
 374
 375 // PUSH.
 376 // m.
 377 def : InstRW<[Write2P237_P4], (instregex "PUSH(16|32)rmm")>;
 378
 379 // PUSHF.
 380 def WritePushF : SchedWriteRes<[HWPort1, HWPort4, HWPort237, HWPort06]> {
 381   let NumMicroOps = 4;
 382 }
 383 def : InstRW<[WritePushF], (instregex "PUSHF(16|32)")>;
 384
 385 // PUSHA.
 386 def WritePushA : SchedWriteRes<[]> {
 387   let NumMicroOps = 19;
 388 }
 389 def : InstRW<[WritePushA], (instregex "PUSHA(16|32)")>;
 390
 391 // POP.
 392 // m.
 393 def : InstRW<[Write2P237_P4], (instregex "POP(16|32)rmm")>;
 394
 395 // POPF.
 396 def WritePopF : SchedWriteRes<[]> {
 397   let NumMicroOps = 9;
 398 }
 399 def : InstRW<[WritePopF], (instregex "POPF(16|32)")>;
 400
 401 // POPA.
 402 def WritePopA : SchedWriteRes<[]> {
 403   let NumMicroOps = 18;
 404 }
 405 def : InstRW<[WritePopA], (instregex "POPA(16|32)")>;
 406
 407 // LAHF SAHF.
 408 def : InstRW<[WriteP06], (instregex "(S|L)AHF")>;
 409
 410 // BSWAP.
 411 // r32.
 412 def WriteBSwap32 : SchedWriteRes<[HWPort15]>;
 413 def : InstRW<[WriteBSwap32], (instregex "BSWAP32r")>;
 414
 415 // r64.
 416 def WriteBSwap64 : SchedWriteRes<[HWPort06, HWPort15]> {
 417   let NumMicroOps = 2;
 418 }
 419 def : InstRW<[WriteBSwap64], (instregex "BSWAP64r")>;
 420
 421 // MOVBE.
 422 // r16,m16 / r64,m64.
 423 def : InstRW<[Write2P0156_Lat2Ld], (instregex "MOVBE(16|64)rm")>;
 424
 425 // r32, m32.
 426 def WriteMoveBE32rm : SchedWriteRes<[HWPort15, HWPort23]> {
 427   let NumMicroOps = 2;
 428 }
 429 def : InstRW<[WriteMoveBE32rm], (instregex "MOVBE32rm")>;
 430
 431 // m16,r16.
 432 def WriteMoveBE16mr : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 433   let NumMicroOps = 3;
 434 }
 435 def : InstRW<[WriteMoveBE16mr], (instregex "MOVBE16mr")>;
 436
 437 // m32,r32.
 438 def WriteMoveBE32mr : SchedWriteRes<[HWPort15, HWPort237, HWPort4]> {
 439   let NumMicroOps = 3;
 440 }
 441 def : InstRW<[WriteMoveBE32mr], (instregex "MOVBE32mr")>;
 442
 443 // m64,r64.
 444 def WriteMoveBE64mr : SchedWriteRes<[HWPort06, HWPort15, HWPort237, HWPort4]> {
 445   let NumMicroOps = 4;
 446 }
 447 def : InstRW<[WriteMoveBE64mr], (instregex "MOVBE64mr")>;
 448
 449 //-- Arithmetic instructions --//
 450
 451 // ADD SUB.
 452 // m,r/i.
 453 def : InstRW<[Write2P0156_2P237_P4],
 454               (instregex "(ADD|SUB)(8|16|32|64)m(r|i)",
 455               "(ADD|SUB)(8|16|32|64)mi8", "(ADD|SUB)64mi32")>;
 456
 457 // ADC SBB.
 458 // r,r/i.
 459 def : InstRW<[Write2P0156_Lat2], (instregex "(ADC|SBB)(8|16|32|64)r(r|i)",
 460                            "(ADC|SBB)(16|32|64)ri8",
 461                            "(ADC|SBB)64ri32",
 462                            "(ADC|SBB)(8|16|32|64)rr_REV")>;
 463
 464 // r,m.
 465 def : InstRW<[Write2P0156_Lat2Ld, ReadAfterLd], (instregex "(ADC|SBB)(8|16|32|64)rm")>;
 466
 467 // m,r/i.
 468 def : InstRW<[Write3P0156_2P237_P4],
 469              (instregex "(ADC|SBB)(8|16|32|64)m(r|i)",
 470               "(ADC|SBB)(16|32|64)mi8",
 471               "(ADC|SBB)64mi32")>;
 472
 473 // INC DEC NOT NEG.
 474 // m.
 475 def : InstRW<[WriteP0156_2P237_P4],
 476              (instregex "(INC|DEC|NOT|NEG)(8|16|32|64)m",
 477               "(INC|DEC)64(16|32)m")>;
 478
 479 // MUL IMUL.
 480 // r16.
 481 def WriteMul16 : SchedWriteRes<[HWPort1, HWPort0156]> {
 482   let Latency = 4;
 483   let NumMicroOps = 4;
 484 }
 485 def : InstRW<[WriteMul16], (instregex "IMUL16r", "MUL16r")>;
 486
 487 // m16.
 488 def WriteMul16Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 489   let Latency = 8;
 490   let NumMicroOps = 5;
 491 }
 492 def : InstRW<[WriteMul16Ld], (instregex "IMUL16m", "MUL16m")>;
 493
 494 // r32.
 495 def WriteMul32 : SchedWriteRes<[HWPort1, HWPort0156]> {
 496   let Latency = 4;
 497   let NumMicroOps = 3;
 498 }
 499 def : InstRW<[WriteMul32], (instregex "IMUL32r", "MUL32r")>;
 500
 501 // m32.
 502 def WriteMul32Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 503   let Latency = 8;
 504   let NumMicroOps = 4;
 505 }
 506 def : InstRW<[WriteMul32Ld], (instregex "IMUL32m", "MUL32m")>;
 507
 508 // r64.
 509 def WriteMul64 : SchedWriteRes<[HWPort1, HWPort6]> {
 510   let Latency = 3;
 511   let NumMicroOps = 2;
 512 }
 513 def : InstRW<[WriteMul64], (instregex "IMUL64r", "MUL64r")>;
 514
 515 // m64.
 516 def WriteMul64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 517   let Latency = 7;
 518   let NumMicroOps = 3;
 519 }
 520 def : InstRW<[WriteMul64Ld], (instregex "IMUL64m", "MUL64m")>;
 521
 522 // r16,r16.
 523 def WriteMul16rri : SchedWriteRes<[HWPort1, HWPort0156]> {
 524   let Latency = 4;
 525   let NumMicroOps = 2;
 526 }
 527 def : InstRW<[WriteMul16rri], (instregex "IMUL16rri", "IMUL16rri8")>;
 528
 529 // r16,m16.
 530 def WriteMul16rmi : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 531   let Latency = 8;
 532   let NumMicroOps = 3;
 533 }
 534 def : InstRW<[WriteMul16rmi], (instregex "IMUL16rmi", "IMUL16rmi8")>;
 535
 536 // MULX.
 537 // r32,r32,r32.
 538 def WriteMulX32 : SchedWriteRes<[HWPort1, HWPort056]> {
 539   let Latency = 4;
 540   let NumMicroOps = 3;
 541   let ResourceCycles = [1, 2];
 542 }
 543 def : InstRW<[WriteMulX32], (instregex "MULX32rr")>;
 544
 545 // r32,r32,m32.
 546 def WriteMulX32Ld : SchedWriteRes<[HWPort1, HWPort056, HWPort23]> {
 547   let Latency = 8;
 548   let NumMicroOps = 4;
 549   let ResourceCycles = [1, 2, 1];
 550 }
 551 def : InstRW<[WriteMulX32Ld], (instregex "MULX32rm")>;
 552
 553 // r64,r64,r64.
 554 def WriteMulX64 : SchedWriteRes<[HWPort1, HWPort6]> {
 555   let Latency = 4;
 556   let NumMicroOps = 2;
 557 }
 558 def : InstRW<[WriteMulX64], (instregex "MULX64rr")>;
 559
 560 // r64,r64,m64.
 561 def WriteMulX64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 562   let Latency = 8;
 563   let NumMicroOps = 3;
 564 }
 565 def : InstRW<[WriteMulX64Ld], (instregex "MULX64rm")>;
 566
 567 // DIV.
 568 // r8.
 569 def WriteDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 570   let Latency = 22;
 571   let NumMicroOps = 9;
 572 }
 573 def : InstRW<[WriteDiv8], (instregex "DIV8r")>;
 574
 575 // r16.
 576 def WriteDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 577   let Latency = 23;
 578   let NumMicroOps = 10;
 579 }
 580 def : InstRW<[WriteDiv16], (instregex "DIV16r")>;
 581
 582 // r32.
 583 def WriteDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 584   let Latency = 22;
 585   let NumMicroOps = 10;
 586 }
 587 def : InstRW<[WriteDiv32], (instregex "DIV32r")>;
 588
 589 // r64.
 590 def WriteDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 591   let Latency = 32;
 592   let NumMicroOps = 36;
 593 }
 594 def : InstRW<[WriteDiv64], (instregex "DIV64r")>;
 595
 596 // IDIV.
 597 // r8.
 598 def WriteIDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 599   let Latency = 23;
 600   let NumMicroOps = 9;
 601 }
 602 def : InstRW<[WriteIDiv8], (instregex "IDIV8r")>;
 603
 604 // r16.
 605 def WriteIDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 606   let Latency = 23;
 607   let NumMicroOps = 10;
 608 }
 609 def : InstRW<[WriteIDiv16], (instregex "IDIV16r")>;
 610
 611 // r32.
 612 def WriteIDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 613   let Latency = 22;
 614   let NumMicroOps = 9;
 615 }
 616 def : InstRW<[WriteIDiv32], (instregex "IDIV32r")>;
 617
 618 // r64.
 619 def WriteIDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 620   let Latency = 39;
 621   let NumMicroOps = 59;
 622 }
 623 def : InstRW<[WriteIDiv64], (instregex "IDIV64r")>;
 624
 625 //-- Logic instructions --//
 626
 627 // AND OR XOR.
 628 // m,r/i.
 629 def : InstRW<[Write2P0156_2P237_P4],
 630              (instregex "(AND|OR|XOR)(8|16|32|64)m(r|i)",
 631               "(AND|OR|XOR)(8|16|32|64)mi8", "(AND|OR|XOR)64mi32")>;
 632
 633 // SHR SHL SAR.
 634 // m,i.
 635 def WriteShiftRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 636   let NumMicroOps = 4;
 637   let ResourceCycles = [2, 1, 1];
 638 }
 639 def : InstRW<[WriteShiftRMW], (instregex "S(A|H)(R|L)(8|16|32|64)m(i|1)")>;
 640
 641 // r,cl.
 642 def : InstRW<[Write3P06_Lat2], (instregex "S(A|H)(R|L)(8|16|32|64)rCL")>;
 643
 644 // m,cl.
 645 def WriteShiftClLdRMW : SchedWriteRes<[HWPort06, HWPort23, HWPort4]> {
 646   let NumMicroOps = 6;
 647   let ResourceCycles = [3, 2, 1];
 648 }
 649 def : InstRW<[WriteShiftClLdRMW], (instregex "S(A|H)(R|L)(8|16|32|64)mCL")>;
 650
 651 // ROR ROL.
 652 // r,1.
 653 def : InstRW<[Write2P06], (instregex "RO(R|L)(8|16|32|64)r1")>;
 654
 655 // m,i.
 656 def WriteRotateRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 657   let NumMicroOps = 5;
 658   let ResourceCycles = [2, 2, 1];
 659 }
 660 def : InstRW<[WriteRotateRMW], (instregex "RO(R|L)(8|16|32|64)mi")>;
 661
 662 // r,cl.
 663 def : InstRW<[Write3P06_Lat2], (instregex "RO(R|L)(8|16|32|64)rCL")>;
 664
 665 // m,cl.
 666 def WriteRotateRMWCL : SchedWriteRes<[]> {
 667   let NumMicroOps = 6;
 668 }
 669 def : InstRW<[WriteRotateRMWCL], (instregex "RO(R|L)(8|16|32|64)mCL")>;
 670
 671 // RCR RCL.
 672 // r,1.
 673 def WriteRCr1 : SchedWriteRes<[HWPort06, HWPort0156]> {
 674   let Latency = 2;
 675   let NumMicroOps = 3;
 676   let ResourceCycles = [2, 1];
 677 }
 678 def : InstRW<[WriteRCr1], (instregex "RC(R|L)(8|16|32|64)r1")>;
 679
 680 // m,1.
 681 def WriteRCm1 : SchedWriteRes<[]> {
 682   let NumMicroOps = 6;
 683 }
 684 def : InstRW<[WriteRCm1], (instregex "RC(R|L)(8|16|32|64)m1")>;
 685
 686 // r,i.
 687 def WriteRCri : SchedWriteRes<[HWPort0156]> {
 688   let Latency = 6;
 689   let NumMicroOps = 8;
 690 }
 691 def : InstRW<[WriteRCri], (instregex "RC(R|L)(8|16|32|64)r(i|CL)")>;
 692
 693 // m,i.
 694 def WriteRCmi : SchedWriteRes<[]> {
 695   let NumMicroOps = 11;
 696 }
 697 def : InstRW<[WriteRCmi], (instregex "RC(R|L)(8|16|32|64)m(i|CL)")>;
 698
 699 // SHRD SHLD.
 700 // r,r,i.
 701 def WriteShDrr : SchedWriteRes<[HWPort1]> {
 702   let Latency = 3;
 703 }
 704 def : InstRW<[WriteShDrr], (instregex "SH(R|L)D(16|32|64)rri8")>;
 705
 706 // m,r,i.
 707 def WriteShDmr : SchedWriteRes<[]> {
 708   let NumMicroOps = 5;
 709 }
 710 def : InstRW<[WriteShDmr], (instregex "SH(R|L)D(16|32|64)mri8")>;
 711
 712 // r,r,cl.
 713 def WriteShlDCL : SchedWriteRes<[HWPort0156]> {
 714   let Latency = 3;
 715   let NumMicroOps = 4;
 716 }
 717 def : InstRW<[WriteShlDCL], (instregex "SHLD(16|32|64)rrCL")>;
 718
 719 // r,r,cl.
 720 def WriteShrDCL : SchedWriteRes<[HWPort0156]> {
 721   let Latency = 4;
 722   let NumMicroOps = 4;
 723 }
 724 def : InstRW<[WriteShrDCL], (instregex "SHRD(16|32|64)rrCL")>;
 725
 726 // m,r,cl.
 727 def WriteShDmrCL : SchedWriteRes<[]> {
 728   let NumMicroOps = 7;
 729 }
 730 def : InstRW<[WriteShDmrCL], (instregex "SH(R|L)D(16|32|64)mrCL")>;
 731
 732 // BT.
 733 // r,r/i.
 734 def : InstRW<[WriteShift], (instregex "BT(16|32|64)r(r|i8)")>;
 735
 736 // m,r.
 737 def WriteBTmr : SchedWriteRes<[]> {
 738   let NumMicroOps = 10;
 739 }
 740 def : InstRW<[WriteBTmr], (instregex "BT(16|32|64)mr")>;
 741
 742 // m,i.
 743 def : InstRW<[WriteShiftLd], (instregex "BT(16|32|64)mi8")>;
 744
 745 // BTR BTS BTC.
 746 // r,r,i.
 747 def : InstRW<[WriteShift], (instregex "BT(R|S|C)(16|32|64)r(r|i8)")>;
 748
 749 // m,r.
 750 def WriteBTRSCmr : SchedWriteRes<[]> {
 751   let NumMicroOps = 11;
 752 }
 753 def : InstRW<[WriteBTRSCmr], (instregex "BT(R|S|C)(16|32|64)mr")>;
 754
 755 // m,i.
 756 def : InstRW<[WriteShiftLd], (instregex "BT(R|S|C)(16|32|64)mi8")>;
 757
 758 // BSF BSR.
 759 // r,r.
 760 def : InstRW<[WriteP1_Lat3], (instregex "BS(R|F)(16|32|64)rr")>;
 761 // r,m.
 762 def : InstRW<[WriteP1_Lat3Ld], (instregex "BS(R|F)(16|32|64)rm")>;
 763
 764 // SETcc.
 765 // r.
 766 def : InstRW<[WriteShift],
 767              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)r")>;
 768 // m.
 769 def WriteSetCCm : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 770   let NumMicroOps = 3;
 771 }
 772 def : InstRW<[WriteSetCCm],
 773              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)m")>;
 774
 775 // CLD STD.
 776 def WriteCldStd : SchedWriteRes<[HWPort15, HWPort6]> {
 777   let NumMicroOps = 3;
 778 }
 779 def : InstRW<[WriteCldStd], (instregex "STD", "CLD")>;
 780
 781 // LZCNT TZCNT.
 782 // r,r.
 783 def : InstRW<[WriteP1_Lat3], (instregex "(L|TZCNT)(16|32|64)rr")>;
 784 // r,m.
 785 def : InstRW<[WriteP1_Lat3Ld], (instregex "(L|TZCNT)(16|32|64)rm")>;
 786
 787 // ANDN.
 788 // r,r.
 789 def : InstRW<[WriteP15], (instregex "ANDN(32|64)rr")>;
 790 // r,m.
 791 def : InstRW<[WriteP15Ld], (instregex "ANDN(32|64)rm")>;
 792
 793 // BLSI BLSMSK BLSR.
 794 // r,r.
 795 def : InstRW<[WriteP15], (instregex "BLS(I|MSK|R)(32|64)rr")>;
 796 // r,m.
 797 def : InstRW<[WriteP15Ld], (instregex "BLS(I|MSK|R)(32|64)rm")>;
 798
 799 // BEXTR.
 800 // r,r,r.
 801 def : InstRW<[Write2P0156_Lat2], (instregex "BEXTR(32|64)rr")>;
 802 // r,m,r.
 803 def : InstRW<[Write2P0156_Lat2Ld], (instregex "BEXTR(32|64)rm")>;
 804
 805 // BZHI.
 806 // r,r,r.
 807 def : InstRW<[WriteP15], (instregex "BZHI(32|64)rr")>;
 808 // r,m,r.
 809 def : InstRW<[WriteP15Ld], (instregex "BZHI(32|64)rm")>;
 810
 811 // PDEP PEXT.
 812 // r,r,r.
 813 def : InstRW<[WriteP1_Lat3], (instregex "PDEP(32|64)rr", "PEXT(32|64)rr")>;
 814 // r,m,r.
 815 def : InstRW<[WriteP1_Lat3Ld], (instregex "PDEP(32|64)rm", "PEXT(32|64)rm")>;
 816
 817 //-- Control transfer instructions --//
 818
 819 // J(E|R)CXZ.
 820 def WriteJCXZ : SchedWriteRes<[HWPort0156, HWPort6]> {
 821   let NumMicroOps = 2;
 822 }
 823 def : InstRW<[WriteJCXZ], (instregex "JCXZ", "JECXZ_(32|64)", "JRCXZ")>;
 824
 825 // LOOP.
 826 def WriteLOOP : SchedWriteRes<[]> {
 827   let NumMicroOps = 7;
 828 }
 829 def : InstRW<[WriteLOOP], (instregex "LOOP")>;
 830
 831 // LOOP(N)E
 832 def WriteLOOPE : SchedWriteRes<[]> {
 833   let NumMicroOps = 11;
 834 }
 835 def : InstRW<[WriteLOOPE], (instregex "LOOPE", "LOOPNE")>;
 836
 837 // CALL.
 838 // r.
 839 def WriteCALLr : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 840   let NumMicroOps = 3;
 841 }
 842 def : InstRW<[WriteCALLr], (instregex "CALL(16|32)r")>;
 843
 844 // m.
 845 def WriteCALLm : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 846   let NumMicroOps = 4;
 847   let ResourceCycles = [2, 1, 1];
 848 }
 849 def : InstRW<[WriteCALLm], (instregex "CALL(16|32)m")>;
 850
 851 // RET.
 852 def WriteRET : SchedWriteRes<[HWPort237, HWPort6]> {
 853   let NumMicroOps = 2;
 854 }
 855 def : InstRW<[WriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)")>;
 856
 857 // i.
 858 def WriteRETI : SchedWriteRes<[HWPort23, HWPort6, HWPort015]> {
 859   let NumMicroOps = 4;
 860   let ResourceCycles = [1, 2, 1];
 861 }
 862 def : InstRW<[WriteRETI], (instregex "RETI(L|Q|W)", "LRETI(L|Q|W)")>;
 863
 864 // BOUND.
 865 // r,m.
 866 def WriteBOUND : SchedWriteRes<[]> {
 867   let NumMicroOps = 15;
 868 }
 869 def : InstRW<[WriteBOUND], (instregex "BOUNDS(16|32)rm")>;
 870
 871 // INTO.
 872 def WriteINTO : SchedWriteRes<[]> {
 873   let NumMicroOps = 4;
 874 }
 875 def : InstRW<[WriteINTO], (instregex "INTO")>;
 876
 877 } // SchedModel