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   // FIXME: SSE4 and AVX are unimplemented. This flag is set to allow
  24   // the scheduler to assign a default model to unrecognized opcodes.
  25   let CompleteModel = 0;
  26 }
  27
  28 let SchedModel = HaswellModel in {
  29
  30 // Haswell can issue micro-ops to 8 different ports in one cycle.
  31
  32 // Ports 0, 1, 5, and 6 handle all computation.
  33 // Port 4 gets the data half of stores. Store data can be available later than
  34 // the store address, but since we don't model the latency of stores, we can
  35 // ignore that.
  36 // Ports 2 and 3 are identical. They handle loads and the address half of
  37 // stores. Port 7 can handle address calculations.
  38 def HWPort0 : ProcResource<1>;
  39 def HWPort1 : ProcResource<1>;
  40 def HWPort2 : ProcResource<1>;
  41 def HWPort3 : ProcResource<1>;
  42 def HWPort4 : ProcResource<1>;
  43 def HWPort5 : ProcResource<1>;
  44 def HWPort6 : ProcResource<1>;
  45 def HWPort7 : ProcResource<1>;
  46
  47 // Many micro-ops are capable of issuing on multiple ports.
  48 def HWPort01  : ProcResGroup<[HWPort0, HWPort1]>;
  49 def HWPort23  : ProcResGroup<[HWPort2, HWPort3]>;
  50 def HWPort237 : ProcResGroup<[HWPort2, HWPort3, HWPort7]>;
  51 def HWPort05  : ProcResGroup<[HWPort0, HWPort5]>;
  52 def HWPort06 : ProcResGroup<[HWPort0, HWPort6]>;
  53 def HWPort15  : ProcResGroup<[HWPort1, HWPort5]>;
  54 def HWPort16  : ProcResGroup<[HWPort1, HWPort6]>;
  55 def HWPort015 : ProcResGroup<[HWPort0, HWPort1, HWPort5]>;
  56 def HWPort056: ProcResGroup<[HWPort0, HWPort5, HWPort6]>;
  57 def HWPort0156: ProcResGroup<[HWPort0, HWPort1, HWPort5, HWPort6]>;
  58
  59 // 60 Entry Unified Scheduler
  60 def HWPortAny : ProcResGroup<[HWPort0, HWPort1, HWPort2, HWPort3, HWPort4,
  61                               HWPort5, HWPort6, HWPort7]> {
  62   let BufferSize=60;
  63 }
  64
  65 // Integer division issued on port 0.
  66 def HWDivider : ProcResource<1>;
  67
  68 // Loads are 4 cycles, so ReadAfterLd registers needn't be available until 4
  69 // cycles after the memory operand.
  70 def : ReadAdvance<ReadAfterLd, 4>;
  71
  72 // Many SchedWrites are defined in pairs with and without a folded load.
  73 // Instructions with folded loads are usually micro-fused, so they only appear
  74 // as two micro-ops when queued in the reservation station.
  75 // This multiclass defines the resource usage for variants with and without
  76 // folded loads.
  77 multiclass HWWriteResPair<X86FoldableSchedWrite SchedRW,
  78                           ProcResourceKind ExePort,
  79                           int Lat> {
  80   // Register variant is using a single cycle on ExePort.
  81   def : WriteRes<SchedRW, [ExePort]> { let Latency = Lat; }
  82
  83   // Memory variant also uses a cycle on port 2/3 and adds 4 cycles to the
  84   // latency.
  85   def : WriteRes<SchedRW.Folded, [HWPort23, ExePort]> {
  86      let Latency = !add(Lat, 4);
  87   }
  88 }
  89
  90 // A folded store needs a cycle on port 4 for the store data, but it does not
  91 // need an extra port 2/3 cycle to recompute the address.
  92 def : WriteRes<WriteRMW, [HWPort4]>;
  93
  94 // Store_addr on 237.
  95 // Store_data on 4.
  96 def : WriteRes<WriteStore, [HWPort237, HWPort4]>;
  97 def : WriteRes<WriteLoad,  [HWPort23]> { let Latency = 4; }
  98 def : WriteRes<WriteMove,  [HWPort0156]>;
  99 def : WriteRes<WriteZero,  []>;
 100
 101 defm : HWWriteResPair<WriteALU,   HWPort0156, 1>;
 102 defm : HWWriteResPair<WriteIMul,  HWPort1,   3>;
 103 def  : WriteRes<WriteIMulH, []> { let Latency = 3; }
 104 defm : HWWriteResPair<WriteShift, HWPort06,  1>;
 105 defm : HWWriteResPair<WriteJump,  HWPort06,   1>;
 106
 107 // This is for simple LEAs with one or two input operands.
 108 // The complex ones can only execute on port 1, and they require two cycles on
 109 // the port to read all inputs. We don't model that.
 110 def : WriteRes<WriteLEA, [HWPort15]>;
 111
 112 // This is quite rough, latency depends on the dividend.
 113 def : WriteRes<WriteIDiv, [HWPort0, HWDivider]> {
 114   let Latency = 25;
 115   let ResourceCycles = [1, 10];
 116 }
 117 def : WriteRes<WriteIDivLd, [HWPort23, HWPort0, HWDivider]> {
 118   let Latency = 29;
 119   let ResourceCycles = [1, 1, 10];
 120 }
 121
 122 // Scalar and vector floating point.
 123 defm : HWWriteResPair<WriteFAdd,   HWPort1, 3>;
 124 defm : HWWriteResPair<WriteFMul,   HWPort0, 5>;
 125 defm : HWWriteResPair<WriteFDiv,   HWPort0, 12>; // 10-14 cycles.
 126 defm : HWWriteResPair<WriteFRcp,   HWPort0, 5>;
 127 defm : HWWriteResPair<WriteFSqrt,  HWPort0, 15>;
 128 defm : HWWriteResPair<WriteCvtF2I, HWPort1, 3>;
 129 defm : HWWriteResPair<WriteCvtI2F, HWPort1, 4>;
 130 defm : HWWriteResPair<WriteCvtF2F, HWPort1, 3>;
 131 defm : HWWriteResPair<WriteFShuffle,  HWPort5,  1>;
 132 defm : HWWriteResPair<WriteFBlend,  HWPort015,  1>;
 133 defm : HWWriteResPair<WriteFShuffle256,  HWPort5,  3>;
 134
 135 def : WriteRes<WriteFVarBlend, [HWPort5]> {
 136   let Latency = 2;
 137   let ResourceCycles = [2];
 138 }
 139 def : WriteRes<WriteFVarBlendLd, [HWPort5, HWPort23]> {
 140   let Latency = 6;
 141   let ResourceCycles = [2, 1];
 142 }
 143
 144 // Vector integer operations.
 145 defm : HWWriteResPair<WriteVecShift, HWPort0,  1>;
 146 defm : HWWriteResPair<WriteVecLogic, HWPort015, 1>;
 147 defm : HWWriteResPair<WriteVecALU,   HWPort15,  1>;
 148 defm : HWWriteResPair<WriteVecIMul,  HWPort0,   5>;
 149 defm : HWWriteResPair<WriteShuffle,  HWPort5,  1>;
 150 defm : HWWriteResPair<WriteBlend,  HWPort15,  1>;
 151 defm : HWWriteResPair<WriteShuffle256,  HWPort5,  3>;
 152
 153 def : WriteRes<WriteVarBlend, [HWPort5]> {
 154   let Latency = 2;
 155   let ResourceCycles = [2];
 156 }
 157 def : WriteRes<WriteVarBlendLd, [HWPort5, HWPort23]> {
 158   let Latency = 6;
 159   let ResourceCycles = [2, 1];
 160 }
 161
 162 def : WriteRes<WriteVarVecShift, [HWPort0, HWPort5]> {
 163   let Latency = 2;
 164   let ResourceCycles = [2, 1];
 165 }
 166 def : WriteRes<WriteVarVecShiftLd, [HWPort0, HWPort5, HWPort23]> {
 167   let Latency = 6;
 168   let ResourceCycles = [2, 1, 1];
 169 }
 170
 171 def : WriteRes<WriteMPSAD, [HWPort0, HWPort5]> {
 172   let Latency = 6;
 173   let ResourceCycles = [1, 2];
 174 }
 175 def : WriteRes<WriteMPSADLd, [HWPort23, HWPort0, HWPort5]> {
 176   let Latency = 6;
 177   let ResourceCycles = [1, 1, 2];
 178 }
 179
 180 // String instructions.
 181 // Packed Compare Implicit Length Strings, Return Mask
 182 def : WriteRes<WritePCmpIStrM, [HWPort0]> {
 183   let Latency = 10;
 184   let ResourceCycles = [3];
 185 }
 186 def : WriteRes<WritePCmpIStrMLd, [HWPort0, HWPort23]> {
 187   let Latency = 10;
 188   let ResourceCycles = [3, 1];
 189 }
 190
 191 // Packed Compare Explicit Length Strings, Return Mask
 192 def : WriteRes<WritePCmpEStrM, [HWPort0, HWPort16, HWPort5]> {
 193   let Latency = 10;
 194   let ResourceCycles = [3, 2, 4];
 195 }
 196 def : WriteRes<WritePCmpEStrMLd, [HWPort05, HWPort16, HWPort23]> {
 197   let Latency = 10;
 198   let ResourceCycles = [6, 2, 1];
 199 }
 200
 201 // Packed Compare Implicit Length Strings, Return Index
 202 def : WriteRes<WritePCmpIStrI, [HWPort0]> {
 203   let Latency = 11;
 204   let ResourceCycles = [3];
 205 }
 206 def : WriteRes<WritePCmpIStrILd, [HWPort0, HWPort23]> {
 207   let Latency = 11;
 208   let ResourceCycles = [3, 1];
 209 }
 210
 211 // Packed Compare Explicit Length Strings, Return Index
 212 def : WriteRes<WritePCmpEStrI, [HWPort05, HWPort16]> {
 213   let Latency = 11;
 214   let ResourceCycles = [6, 2];
 215 }
 216 def : WriteRes<WritePCmpEStrILd, [HWPort0, HWPort16, HWPort5, HWPort23]> {
 217   let Latency = 11;
 218   let ResourceCycles = [3, 2, 2, 1];
 219 }
 220
 221 // AES Instructions.
 222 def : WriteRes<WriteAESDecEnc, [HWPort5]> {
 223   let Latency = 7;
 224   let ResourceCycles = [1];
 225 }
 226 def : WriteRes<WriteAESDecEncLd, [HWPort5, HWPort23]> {
 227   let Latency = 7;
 228   let ResourceCycles = [1, 1];
 229 }
 230
 231 def : WriteRes<WriteAESIMC, [HWPort5]> {
 232   let Latency = 14;
 233   let ResourceCycles = [2];
 234 }
 235 def : WriteRes<WriteAESIMCLd, [HWPort5, HWPort23]> {
 236   let Latency = 14;
 237   let ResourceCycles = [2, 1];
 238 }
 239
 240 def : WriteRes<WriteAESKeyGen, [HWPort0, HWPort5]> {
 241   let Latency = 10;
 242   let ResourceCycles = [2, 8];
 243 }
 244 def : WriteRes<WriteAESKeyGenLd, [HWPort0, HWPort5, HWPort23]> {
 245   let Latency = 10;
 246   let ResourceCycles = [2, 7, 1];
 247 }
 248
 249 // Carry-less multiplication instructions.
 250 def : WriteRes<WriteCLMul, [HWPort0, HWPort5]> {
 251   let Latency = 7;
 252   let ResourceCycles = [2, 1];
 253 }
 254 def : WriteRes<WriteCLMulLd, [HWPort0, HWPort5, HWPort23]> {
 255   let Latency = 7;
 256   let ResourceCycles = [2, 1, 1];
 257 }
 258
 259 def : WriteRes<WriteSystem,     [HWPort0156]> { let Latency = 100; }
 260 def : WriteRes<WriteMicrocoded, [HWPort0156]> { let Latency = 100; }
 261 def : WriteRes<WriteFence,  [HWPort23, HWPort4]>;
 262 def : WriteRes<WriteNop, []>;
 263
 264 // Exceptions.
 265
 266 //-- Specific Scheduling Models --//
 267 def Write2ALU : SchedWriteRes<[HWPort0156]> {
 268   let Latency = 2;
 269   let ResourceCycles = [2];
 270 }
 271 def Write2ALULd : SchedWriteRes<[HWPort0156, HWPort23]> {
 272   let Latency = 6;
 273   let ResourceCycles = [2, 1];
 274 }
 275
 276 def Write3ALU : SchedWriteRes<[HWPort0156]> {
 277   let Latency = 3;
 278   let ResourceCycles = [3];
 279 }
 280
 281 def WriteStore2Addr1Data : SchedWriteRes<[HWPort237, HWPort4]> {
 282   let Latency = 1;
 283   let ResourceCycles = [2, 1];
 284 }
 285
 286 def WritePort06 : SchedWriteRes<[HWPort06]>;
 287
 288 def WriteALUStore2Addr1Data : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 289   let Latency = 1;
 290   let ResourceCycles = [1, 2, 1];
 291 }
 292
 293 def Write2ALUStore2Addr1Data : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 294   let Latency = 1;
 295   let ResourceCycles = [2, 2, 1];
 296 }
 297
 298 def Write3ALUStore2Addr1Data : SchedWriteRes<[HWPort0156, HWPort237, HWPort4]> {
 299   let Latency = 1;
 300   let ResourceCycles = [3, 2, 1];
 301 }
 302
 303 def Write2Shift : SchedWriteRes<[HWPort06]> {
 304   let Latency = 1;
 305   let NumMicroOps = 2;
 306   let ResourceCycles = [2];
 307 }
 308
 309 def Write3Shift : SchedWriteRes<[HWPort06]> {
 310   let Latency = 2;
 311   let NumMicroOps = 3;
 312   let ResourceCycles = [3];
 313 }
 314
 315 def WriteP1Lat3 : SchedWriteRes<[HWPort1]> {
 316   let Latency = 3;
 317 }
 318 def WriteP1Lat3Ld : SchedWriteRes<[HWPort1, HWPort23]> {
 319   let Latency = 7;
 320 }
 321 def WriteP15 : SchedWriteRes<[HWPort15]>;
 322 def WriteP15Ld : SchedWriteRes<[HWPort15, HWPort23]> {
 323   let Latency = 4;
 324 }
 325
 326 def WriteP01P5 : SchedWriteRes<[HWPort01, HWPort5]> {
 327   let NumMicroOps = 2;
 328 }
 329
 330 def WriteP0156_P23 : SchedWriteRes<[HWPort0156, HWPort23]> {
 331   let NumMicroOps = 2;
 332 }
 333 def Write2P0156_P23 : SchedWriteRes<[HWPort0156, HWPort23]> {
 334   let NumMicroOps = 3;
 335   let ResourceCycles = [2, 1];
 336 }
 337
 338 def Write5P0156 : SchedWriteRes<[HWPort0156]> {
 339   let NumMicroOps = 5;
 340   let ResourceCycles = [5];
 341 }
 342
 343 def WriteP01 : SchedWriteRes<[HWPort01]>;
 344
 345 def Write2P01 : SchedWriteRes<[HWPort01]> {
 346   let NumMicroOps = 2;
 347 }
 348
 349 def Write3P01 : SchedWriteRes<[HWPort01]> {
 350   let NumMicroOps = 3;
 351 }
 352
 353 def WriteP0 : SchedWriteRes<[HWPort0]>;
 354 def WriteP1 : SchedWriteRes<[HWPort1]>;
 355 def WriteP1_P23 : SchedWriteRes<[HWPort1, HWPort23]> {
 356   let NumMicroOps = 2;
 357 }
 358
 359 def Write2P1 : SchedWriteRes<[HWPort1]> {
 360   let NumMicroOps = 2;
 361   let ResourceCycles = [2];
 362 }
 363
 364 def Write2P1_P23 : SchedWriteRes<[HWPort1, HWPort23]> {
 365   let NumMicroOps = 3;
 366 }
 367
 368 def WriteP5 : SchedWriteRes<[HWPort5]>;
 369
 370 def WriteP015 : SchedWriteRes<[HWPort015]>;
 371
 372 //=== Integer Instructions ===//
 373 //-- Move instructions --//
 374
 375 // MOV.
 376 def : InstRW<[WriteALULd], (instregex "MOV16rm")>;
 377
 378 // MOV with
 379 def : InstRW<[WriteLoad], (instregex "MOV(S|Z)X32rm(8|16)")>;
 380
 381 // CMOVcc.
 382 def : InstRW<[Write2ALU],
 383       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rr")>;
 384 def : InstRW<[Write2ALULd, ReadAfterLd],
 385       (instregex "CMOV(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)(16|32|64)rm")>;
 386
 387 // XCHG.
 388 def WriteXCHG : SchedWriteRes<[HWPort0156]> {
 389   let Latency = 2;
 390   let ResourceCycles = [3];
 391 }
 392
 393 def : InstRW<[WriteXCHG], (instregex "XCHG(8|16|32|64)rr", "XCHG(16|32|64)ar")>;
 394
 395 def WriteXCHGrm : SchedWriteRes<[]> {
 396   let Latency = 21;
 397   let NumMicroOps = 8;
 398 }
 399 def : InstRW<[WriteXCHGrm], (instregex "XCHG(8|16|32|64)rm")>;
 400
 401 // XLAT.
 402 def WriteXLAT : SchedWriteRes<[]> {
 403   let Latency = 7;
 404   let NumMicroOps = 3;
 405 }
 406 def : InstRW<[WriteXLAT], (instregex "XLAT")>;
 407
 408
 409 // PUSH.
 410 def : InstRW<[WriteStore2Addr1Data], (instregex "PUSH(16|32)rmm")>;
 411
 412 def WritePushF : SchedWriteRes<[HWPort1, HWPort4, HWPort237, HWPort06]> {
 413   let NumMicroOps = 4;
 414 }
 415 def : InstRW<[WritePushF], (instregex "PUSHF(16|32)")>;
 416
 417 def WritePushA : SchedWriteRes<[]> {
 418   let NumMicroOps = 19;
 419 }
 420 def : InstRW<[WritePushA], (instregex "PUSHA(16|32)")>;
 421
 422 // POP.
 423 def : InstRW<[WriteStore2Addr1Data], (instregex "POP(16|32)rmm")>;
 424
 425 def WritePopF : SchedWriteRes<[]> {
 426   let NumMicroOps = 9;
 427 }
 428 def : InstRW<[WritePopF], (instregex "POPF(16|32)")>;
 429
 430 def WritePopA : SchedWriteRes<[]> {
 431   let NumMicroOps = 18;
 432 }
 433 def : InstRW<[WritePopA], (instregex "POPA(16|32)")>;
 434
 435 // LAHF SAHF.
 436 def : InstRW<[WritePort06], (instregex "(S|L)AHF")>;
 437
 438 // BSWAP.
 439 def WriteBSwap32 : SchedWriteRes<[HWPort15]>;
 440 def : InstRW<[WriteBSwap32], (instregex "BSWAP32r")>;
 441
 442 def WriteBSwap64 : SchedWriteRes<[HWPort06, HWPort15]> {
 443   let NumMicroOps = 2;
 444 }
 445 def : InstRW<[WriteBSwap64], (instregex "BSWAP64r")>;
 446
 447 // MOVBE.
 448 def : InstRW<[Write2ALULd], (instregex "MOVBE(16|64)rm")>;
 449
 450 def WriteMoveBE32rm : SchedWriteRes<[HWPort15, HWPort23]> {
 451   let NumMicroOps = 2;
 452 }
 453 def : InstRW<[WriteMoveBE32rm], (instregex "MOVBE32rm")>;
 454
 455 def WriteMoveBE16mr : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 456   let NumMicroOps = 3;
 457 }
 458 def : InstRW<[WriteMoveBE16mr], (instregex "MOVBE16mr")>;
 459
 460 def WriteMoveBE32mr : SchedWriteRes<[HWPort15, HWPort237, HWPort4]> {
 461   let NumMicroOps = 3;
 462 }
 463 def : InstRW<[WriteMoveBE32mr], (instregex "MOVBE32mr")>;
 464
 465 def WriteMoveBE64mr : SchedWriteRes<[HWPort06, HWPort15, HWPort237, HWPort4]> {
 466   let NumMicroOps = 4;
 467 }
 468 def : InstRW<[WriteMoveBE64mr], (instregex "MOVBE64mr")>;
 469
 470
 471 //-- Arithmetic instructions --//
 472 // ADD SUB.
 473 def : InstRW<[Write2ALUStore2Addr1Data],
 474               (instregex "(ADD|SUB)(8|16|32|64)m(r|i)",
 475               "(ADD|SUB)(8|16|32|64)mi8", "(ADD|SUB)64mi32")>;
 476
 477 // ADC SBB.
 478 def : InstRW<[Write2ALU], (instregex "(ADC|SBB)(8|16|32|64)r(r|i)",
 479                            "(ADC|SBB)(16|32|64)ri8",
 480                            "(ADC|SBB)64ri32",
 481                            "(ADC|SBB)(8|16|32|64)rr_REV")>;
 482
 483 def : InstRW<[Write2ALULd, ReadAfterLd], (instregex "(ADC|SBB)(8|16|32|64)rm")>;
 484
 485 def : InstRW<[Write3ALUStore2Addr1Data],
 486              (instregex "(ADC|SBB)(8|16|32|64)m(r|i)",
 487               "(ADC|SBB)(16|32|64)mi8",
 488               "(ADC|SBB)64mi32")>;
 489
 490 // INC DEC NOT NEG.
 491 def : InstRW<[WriteALUStore2Addr1Data],
 492              (instregex "(INC|DEC|NOT|NEG)(8|16|32|64)m",
 493               "(INC|DEC)64(16|32)m")>;
 494
 495 // MUL IMUL.
 496 def WriteMul16 : SchedWriteRes<[HWPort1, HWPort0156]> {
 497   let Latency = 4;
 498   let NumMicroOps = 4;
 499 }
 500 def WriteMul16Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 501   let Latency = 8;
 502   let NumMicroOps = 5;
 503 }
 504 def : InstRW<[WriteMul16], (instregex "IMUL16r", "MUL16r")>;
 505 def : InstRW<[WriteMul16Ld], (instregex "IMUL16m", "MUL16m")>;
 506
 507 def WriteMul32 : SchedWriteRes<[HWPort1, HWPort0156]> {
 508   let Latency = 4;
 509   let NumMicroOps = 3;
 510 }
 511 def WriteMul32Ld : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 512   let Latency = 8;
 513   let NumMicroOps = 4;
 514 }
 515 def : InstRW<[WriteMul32], (instregex "IMUL32r", "MUL32r")>;
 516 def : InstRW<[WriteMul32Ld], (instregex "IMUL32m", "MUL32m")>;
 517
 518 def WriteMul64 : SchedWriteRes<[HWPort1, HWPort6]> {
 519   let Latency = 3;
 520   let NumMicroOps = 2;
 521 }
 522 def WriteMul64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 523   let Latency = 7;
 524   let NumMicroOps = 3;
 525 }
 526 def : InstRW<[WriteMul64], (instregex "IMUL64r", "MUL64r")>;
 527 def : InstRW<[WriteMul64Ld], (instregex "IMUL64m", "MUL64m")>;
 528
 529 def WriteMul16rri : SchedWriteRes<[HWPort1, HWPort0156]> {
 530   let Latency = 4;
 531   let NumMicroOps = 2;
 532 }
 533 def WriteMul16rmi : SchedWriteRes<[HWPort1, HWPort0156, HWPort23]> {
 534   let Latency = 8;
 535   let NumMicroOps = 3;
 536 }
 537 def : InstRW<[WriteMul16rri], (instregex "IMUL16rri", "IMUL16rri8")>;
 538 def : InstRW<[WriteMul16rmi], (instregex "IMUL16rmi", "IMUL16rmi8")>;
 539
 540 // MULX.
 541 def WriteMulX32 : SchedWriteRes<[HWPort1, HWPort056]> {
 542   let Latency = 4;
 543   let NumMicroOps = 3;
 544   let ResourceCycles = [1, 2];
 545 }
 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<[WriteMulX32], (instregex "MULX32rr")>;
 552 def : InstRW<[WriteMulX32Ld], (instregex "MULX32rm")>;
 553
 554 def WriteMulX64 : SchedWriteRes<[HWPort1, HWPort6]> {
 555   let Latency = 4;
 556   let NumMicroOps = 2;
 557 }
 558 def WriteMulX64Ld : SchedWriteRes<[HWPort1, HWPort6, HWPort23]> {
 559   let Latency = 8;
 560   let NumMicroOps = 3;
 561 }
 562 def : InstRW<[WriteMulX64], (instregex "MULX64rr")>;
 563 def : InstRW<[WriteMulX64Ld], (instregex "MULX64rm")>;
 564
 565 // DIV.
 566 def WriteDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 567   let Latency = 22;
 568   let NumMicroOps = 9;
 569 }
 570 def : InstRW<[WriteDiv8], (instregex "DIV8r")>;
 571
 572 def WriteDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 573   let Latency = 23;
 574   let NumMicroOps = 10;
 575 }
 576 def : InstRW<[WriteDiv16], (instregex "DIV16r")>;
 577
 578 def WriteDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 579   let Latency = 22;
 580   let NumMicroOps = 10;
 581 }
 582 def : InstRW<[WriteDiv32], (instregex "DIV32r")>;
 583
 584 def WriteDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 585   let Latency = 32;
 586   let NumMicroOps = 36;
 587 }
 588 def : InstRW<[WriteDiv64], (instregex "DIV64r")>;
 589
 590 def WriteIDiv8 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 591   let Latency = 23;
 592   let NumMicroOps = 9;
 593 }
 594 def : InstRW<[WriteIDiv8], (instregex "IDIV8r")>;
 595
 596 def WriteIDiv16 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 597   let Latency = 23;
 598   let NumMicroOps = 10;
 599 }
 600 def : InstRW<[WriteIDiv16], (instregex "IDIV16r")>;
 601
 602 def WriteIDiv32 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 603   let Latency = 22;
 604   let NumMicroOps = 9;
 605 }
 606 def : InstRW<[WriteIDiv32], (instregex "IDIV32r")>;
 607
 608 def WriteIDiv64 : SchedWriteRes<[HWPort0, HWPort1, HWPort5, HWPort6]> {
 609   let Latency = 39;
 610   let NumMicroOps = 59;
 611 }
 612 def : InstRW<[WriteIDiv64], (instregex "IDIV64r")>;
 613
 614 //-- Logic instructions --//
 615 // AND OR XOR.
 616 def : InstRW<[Write2ALUStore2Addr1Data],
 617              (instregex "(AND|OR|XOR)(8|16|32|64)m(r|i)",
 618               "(AND|OR|XOR)(8|16|32|64)mi8", "(AND|OR|XOR)64mi32")>;
 619
 620
 621 // SHR SHL SAR.
 622 def WriteShiftRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 623   let NumMicroOps = 4;
 624   let ResourceCycles = [2, 1, 1];
 625 }
 626 def : InstRW<[WriteShiftRMW], (instregex "S(A|H)(R|L)(8|16|32|64)m(i|1)")>;
 627
 628 def : InstRW<[Write3Shift], (instregex "S(A|H)(R|L)(8|16|32|64)rCL")>;
 629
 630 def WriteShiftClLdRMW : SchedWriteRes<[HWPort06, HWPort23, HWPort4]> {
 631   let NumMicroOps = 6;
 632   let ResourceCycles = [3, 2, 1];
 633 }
 634 def : InstRW<[WriteShiftClLdRMW], (instregex "S(A|H)(R|L)(8|16|32|64)mCL")>;
 635
 636 // ROR ROL.
 637 def : InstRW<[Write2Shift], (instregex "RO(R|L)(8|16|32|64)r1")>;
 638
 639 def WriteRotateRMW : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 640   let NumMicroOps = 5;
 641   let ResourceCycles = [2, 2, 1];
 642 }
 643 def : InstRW<[WriteRotateRMW], (instregex "RO(R|L)(8|16|32|64)mi")>;
 644
 645 def : InstRW<[Write3Shift], (instregex "RO(R|L)(8|16|32|64)rCL")>;
 646
 647 def WriteRotateRMWCL : SchedWriteRes<[]> {
 648   let NumMicroOps = 6;
 649 }
 650 def : InstRW<[WriteRotateRMWCL], (instregex "RO(R|L)(8|16|32|64)mCL")>;
 651
 652 // RCR RCL.
 653 def WriteRCr1 : SchedWriteRes<[HWPort06, HWPort0156]> {
 654   let Latency = 2;
 655   let NumMicroOps = 3;
 656   let ResourceCycles = [2, 1];
 657 }
 658 def : InstRW<[WriteRCr1], (instregex "RC(R|L)(8|16|32|64)r1")>;
 659
 660 def WriteRCm1 : SchedWriteRes<[]> {
 661   let NumMicroOps = 6;
 662 }
 663 def : InstRW<[WriteRCm1], (instregex "RC(R|L)(8|16|32|64)m1")>;
 664
 665 def WriteRCri : SchedWriteRes<[HWPort0156]> {
 666   let Latency = 6;
 667   let NumMicroOps = 8;
 668 }
 669 def : InstRW<[WriteRCri], (instregex "RC(R|L)(8|16|32|64)r(i|CL)")>;
 670
 671 def WriteRCmi : SchedWriteRes<[]> {
 672   let NumMicroOps = 11;
 673 }
 674 def : InstRW<[WriteRCmi], (instregex "RC(R|L)(8|16|32|64)m(i|CL)")>;
 675
 676 // SHRD SHLD.
 677 def WriteShDrr : SchedWriteRes<[HWPort1]> {
 678   let Latency = 3;
 679 }
 680 def : InstRW<[WriteShDrr], (instregex "SH(R|L)D(16|32|64)rri8")>;
 681
 682 def WriteShDmr : SchedWriteRes<[]> {
 683   let NumMicroOps = 5;
 684 }
 685 def : InstRW<[WriteShDmr], (instregex "SH(R|L)D(16|32|64)mri8")>;
 686
 687 def WriteShlDCL : SchedWriteRes<[HWPort0156]> {
 688   let Latency = 3;
 689   let NumMicroOps = 4;
 690 }
 691 def : InstRW<[WriteShlDCL], (instregex "SHLD(16|32|64)rrCL")>;
 692
 693 def WriteShrDCL : SchedWriteRes<[HWPort0156]> {
 694   let Latency = 4;
 695   let NumMicroOps = 4;
 696 }
 697 def : InstRW<[WriteShrDCL], (instregex "SHRD(16|32|64)rrCL")>;
 698
 699 def WriteShDmrCL : SchedWriteRes<[]> {
 700   let NumMicroOps = 7;
 701 }
 702 def : InstRW<[WriteShDmrCL], (instregex "SH(R|L)D(16|32|64)mrCL")>;
 703
 704 // BT.
 705 def : InstRW<[WriteShift], (instregex "BT(16|32|64)r(r|i8)")>;
 706
 707 def WriteBTmr : SchedWriteRes<[]> {
 708   let NumMicroOps = 10;
 709 }
 710 def : InstRW<[WriteBTmr], (instregex "BT(16|32|64)mr")>;
 711
 712 def : InstRW<[WriteShiftLd], (instregex "BT(16|32|64)mi8")>;
 713
 714 // BTR BTS BTC.
 715 def : InstRW<[WriteShift], (instregex "BT(R|S|C)(16|32|64)r(r|i8)")>;
 716
 717 def WriteBTRSCmr : SchedWriteRes<[]> {
 718   let NumMicroOps = 11;
 719 }
 720 def : InstRW<[WriteBTRSCmr], (instregex "BT(R|S|C)(16|32|64)mr")>;
 721
 722 def : InstRW<[WriteShiftLd], (instregex "BT(R|S|C)(16|32|64)mi8")>;
 723
 724 // BSF BSR.
 725 def : InstRW<[WriteP1Lat3], (instregex "BS(R|F)(16|32|64)rr")>;
 726 def : InstRW<[WriteP1Lat3Ld], (instregex "BS(R|F)(16|32|64)rm")>;
 727
 728 // SETcc.
 729 def : InstRW<[WriteShift],
 730              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)r")>;
 731 def WriteSetCCm : SchedWriteRes<[HWPort06, HWPort237, HWPort4]> {
 732   let NumMicroOps = 3;
 733 }
 734 def : InstRW<[WriteSetCCm],
 735              (instregex "SET(O|NO|B|AE|E|NE|BE|A|S|NS|P|NP|L|GE|LE|G)m")>;
 736
 737 // CLD STD.
 738 def WriteCldStd : SchedWriteRes<[HWPort15, HWPort6]> {
 739   let NumMicroOps = 3;
 740 }
 741 def : InstRW<[WriteCldStd], (instregex "STD", "CLD")>;
 742
 743 //LZCNT TZCNT.
 744 def : InstRW<[WriteP1Lat3], (instregex "(L|TZCNT)(16|32|64)rr")>;
 745 def : InstRW<[WriteP1Lat3Ld], (instregex "(L|TZCNT)(16|32|64)rm")>;
 746
 747 // ANDN.
 748 def : InstRW<[WriteP15], (instregex "ANDN(32|64)rr")>;
 749 def : InstRW<[WriteP15Ld], (instregex "ANDN(32|64)rm")>;
 750
 751 // BLSI BLSMSK BLSR.
 752 def : InstRW<[WriteP15], (instregex "BLS(I|MSK|R)(32|64)rr")>;
 753 def : InstRW<[WriteP15Ld], (instregex "BLS(I|MSK|R)(32|64)rm")>;
 754
 755 // BEXTR.
 756 def : InstRW<[Write2ALU], (instregex "BEXTR(32|64)rr")>;
 757 def : InstRW<[Write2ALULd], (instregex "BEXTR(32|64)rm")>;
 758
 759 // BZHI.
 760 def : InstRW<[WriteP15], (instregex "BZHI(32|64)rr")>;
 761 def : InstRW<[WriteP15Ld], (instregex "BZHI(32|64)rm")>;
 762
 763 // PDEP PEXT.
 764 def : InstRW<[WriteP1Lat3], (instregex "PDEP(32|64)rr", "PEXT(32|64)rr")>;
 765 def : InstRW<[WriteP1Lat3Ld], (instregex "PDEP(32|64)rm", "PEXT(32|64)rm")>;
 766
 767 //-- Control transfer instructions --//
 768 // J(E|R)CXZ.
 769 def WriteJCXZ : SchedWriteRes<[HWPort0156, HWPort6]> {
 770   let NumMicroOps = 2;
 771 }
 772 def : InstRW<[WriteJCXZ], (instregex "JCXZ", "JECXZ_(32|64)", "JRCXZ")>;
 773
 774 // LOOP.
 775 def WriteLOOP : SchedWriteRes<[]> {
 776   let NumMicroOps = 7;
 777 }
 778 def : InstRW<[WriteLOOP], (instregex "LOOP")>;
 779
 780 // LOOP(N)E
 781 def WriteLOOPE : SchedWriteRes<[]> {
 782   let NumMicroOps = 11;
 783 }
 784 def : InstRW<[WriteLOOPE], (instregex "LOOPE", "LOOPNE")>;
 785
 786 // CALL.
 787 def WriteCALLr : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 788   let NumMicroOps = 3;
 789 }
 790 def : InstRW<[WriteCALLr], (instregex "CALL(16|32)r")>;
 791
 792 def WriteCALLm : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
 793   let NumMicroOps = 4;
 794   let ResourceCycles = [2, 1, 1];
 795 }
 796 def : InstRW<[WriteCALLm], (instregex "CALL(16|32)m")>;
 797
 798 // RET.
 799 def WriteRET : SchedWriteRes<[HWPort237, HWPort6]> {
 800   let NumMicroOps = 2;
 801 }
 802 def : InstRW<[WriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)")>;
 803
 804 def WriteRETI : SchedWriteRes<[HWPort23, HWPort6, HWPort015]> {
 805   let NumMicroOps = 4;
 806   let ResourceCycles = [1, 2, 1];
 807 }
 808 def : InstRW<[WriteRETI], (instregex "RETI(L|Q|W)", "LRETI(L|Q|W)")>;
 809
 810 // BOUND.
 811 def WriteBOUND : SchedWriteRes<[]> {
 812   let NumMicroOps = 15;
 813 }
 814 def : InstRW<[WriteBOUND], (instregex "BOUNDS(16|32)rm")>;
 815
 816 // INTO.
 817 def WriteINTO : SchedWriteRes<[]> {
 818   let NumMicroOps = 4;
 819 }
 820 def : InstRW<[WriteINTO], (instregex "INTO")>;
 821
 822
 823 //-- String instructions --//
 824 // LODSB/W.
 825 def : InstRW<[Write2P0156_P23], (instregex "LODS(B|W)")>;
 826
 827 // LODSD/Q.
 828 def : InstRW<[WriteP0156_P23], (instregex "LODS(L|Q)")>;
 829
 830 // STOS.
 831 def WriteSTOS : SchedWriteRes<[HWPort23, HWPort0156, HWPort4]> {
 832   let NumMicroOps = 3;
 833 }
 834 def : InstRW<[WriteSTOS], (instregex "STOS(B|L|Q|W)")>;
 835
 836 // MOVS.
 837 def WriteMOVS : SchedWriteRes<[HWPort23, HWPort4, HWPort0156]> {
 838   let Latency = 4;
 839   let NumMicroOps = 5;
 840   let ResourceCycles = [2, 1, 2];
 841 }
 842 def : InstRW<[WriteMOVS], (instregex "MOVS(B|L|Q|W)")>;
 843
 844 // SCAS.
 845 def : InstRW<[Write2P0156_P23], (instregex "SCAS(B|W|L|Q)")>;
 846
 847 // CMPS.
 848 def WriteCMPS : SchedWriteRes<[HWPort23, HWPort0156]> {
 849   let Latency = 4;
 850   let NumMicroOps = 5;
 851   let ResourceCycles = [2, 3];
 852 }
 853 def : InstRW<[WriteCMPS], (instregex "CMPS(B|L|Q|W)")>;
 854
 855 //-- Synchronization instructions --//
 856 // XADD.
 857 def WriteXADD : SchedWriteRes<[HWPort237, HWPort6, HWPort0156]> {
 858   let Latency = 7;
 859   let NumMicroOps = 5;
 860 }
 861 def : InstRW<[WriteXADD], (instregex "XADD(8|16|32|64)rm")>;
 862
 863 // CMPXCHG.
 864 def WriteCMPXCHG : SchedWriteRes<[HWPort237, HWPort6, HWPort0156]> {
 865   let Latency = 6;
 866   let NumMicroOps = 9;
 867 }
 868 def : InstRW<[WriteCMPXCHG], (instregex "CMPXCHG(8|16|32|64)rm")>;
 869
 870 // CMPXCHG8B.
 871 def WriteCMPXCHG8B : SchedWriteRes<[HWPort237, HWPort6, HWPort0156]> {
 872   let Latency = 9;
 873   let NumMicroOps = 16;
 874 }
 875 def : InstRW<[WriteCMPXCHG8B], (instregex "CMPXCHG8B")>;
 876
 877 // CMPXCHG16B.
 878 def WriteCMPXCHG16B : SchedWriteRes<[HWPort237, HWPort6, HWPort0156]> {
 879   let Latency = 15;
 880   let NumMicroOps = 22;
 881 }
 882 def : InstRW<[WriteCMPXCHG16B], (instregex "CMPXCHG16B")>;
 883
 884 //-- Other --//
 885 // PAUSE.
 886 def WritePAUSE : SchedWriteRes<[HWPort05, HWPort6]> {
 887   let NumMicroOps = 5;
 888   let ResourceCycles = [1, 3];
 889 }
 890 def : InstRW<[WritePAUSE], (instregex "PAUSE")>;
 891
 892 // LEAVE.
 893 def : InstRW<[Write2P0156_P23], (instregex "LEAVE")>;
 894
 895 // XGETBV.
 896 def WriteXGETBV : SchedWriteRes<[]> {
 897   let NumMicroOps = 8;
 898 }
 899 def : InstRW<[WriteXGETBV], (instregex "XGETBV")>;
 900
 901 // RDTSC.
 902 def WriteRDTSC : SchedWriteRes<[]> {
 903   let NumMicroOps = 15;
 904 }
 905 def : InstRW<[WriteRDTSC], (instregex "RDTSC")>;
 906
 907 // RDPMC.
 908 def WriteRDPMC : SchedWriteRes<[]> {
 909   let NumMicroOps = 34;
 910 }
 911 def : InstRW<[WriteRDPMC], (instregex "RDPMC")>;
 912
 913 // RDRAND.
 914 def WriteRDRAND : SchedWriteRes<[HWPort23, HWPort015]> {
 915   let NumMicroOps = 17;
 916   let ResourceCycles = [1, 16];
 917 }
 918 def : InstRW<[WriteRDRAND], (instregex "RDRAND(16|32|64)r")>;
 919
 920 //=== Floating Point x87 Instructions ===//
 921 //-- Move instructions --//
 922 // FLD.
 923 def : InstRW<[WriteP01], (instregex "LD_Frr")>;
 924
 925 def WriteLD_F80m : SchedWriteRes<[HWPort01, HWPort23]> {
 926   let Latency = 4;
 927   let NumMicroOps = 4;
 928   let ResourceCycles = [2, 2];
 929 }
 930 def : InstRW<[WriteLD_F80m], (instregex "LD_F80m")>;
 931
 932 // FBLD.
 933 def WriteFBLD : SchedWriteRes<[]> {
 934   let Latency = 47;
 935   let NumMicroOps = 43;
 936 }
 937 def : InstRW<[WriteFBLD], (instregex "FBLDm")>;
 938
 939 // FST(P).
 940 def : InstRW<[WriteP01], (instregex "ST_(F|FP)rr")>;
 941
 942 def WriteST_FP80m : SchedWriteRes<[HWPort0156, HWPort23, HWPort4]> {
 943   let NumMicroOps = 7;
 944   let ResourceCycles = [3, 2, 2];
 945 }
 946 def : InstRW<[WriteST_FP80m], (instregex "ST_FP80m")>;
 947
 948 // FBSTP.
 949 def WriteFBSTP : SchedWriteRes<[]> {
 950   let NumMicroOps = 226;
 951 }
 952 def : InstRW<[WriteFBSTP], (instregex "FBSTPm")>;
 953
 954 // FXCHG.
 955 def : InstRW<[WriteNop], (instregex "XCH_F")>;
 956
 957 // FILD.
 958 def WriteFILD : SchedWriteRes<[HWPort01, HWPort23]> {
 959   let Latency = 6;
 960   let NumMicroOps = 2;
 961 }
 962 def : InstRW<[WriteFILD], (instregex "ILD_F(16|32|64)m")>;
 963
 964 // FIST(P) FISTTP.
 965 def WriteFIST : SchedWriteRes<[HWPort1, HWPort23, HWPort4]> {
 966   let Latency = 7;
 967   let NumMicroOps = 3;
 968 }
 969 def : InstRW<[WriteFIST], (instregex "IST_(F|FP)(16|32)m")>;
 970
 971 // FLDZ.
 972 def : InstRW<[WriteP01], (instregex "LD_F0")>;
 973
 974 // FLD1.
 975 def : InstRW<[Write2P01], (instregex "LD_F1")>;
 976
 977 // FLDPI FLDL2E etc.
 978 def : InstRW<[Write2P01], (instregex "FLDPI", "FLDL2(T|E)" "FLDL(G|N)2")>;
 979
 980 // FCMOVcc.
 981 def WriteFCMOVcc : SchedWriteRes<[HWPort0, HWPort5]> {
 982   let Latency = 2;
 983   let NumMicroOps = 3;
 984   let ResourceCycles = [2, 1];
 985 }
 986 def : InstRW<[WriteFCMOVcc], (instregex "CMOV(B|BE|P|NB|NBE|NE|NP)_F")>;
 987
 988 // FNSTSW.
 989 def WriteFNSTSW : SchedWriteRes<[HWPort0, HWPort0156]> {
 990   let NumMicroOps = 2;
 991 }
 992 def : InstRW<[WriteFNSTSW], (instregex "FNSTSW16r")>;
 993
 994 def WriteFNSTSWm : SchedWriteRes<[HWPort0, HWPort4, HWPort237]> {
 995   let Latency = 6;
 996   let NumMicroOps = 3;
 997 }
 998 def : InstRW<[WriteFNSTSWm], (instregex "FNSTSWm")>;
 999
1000 // FLDCW.
1001 def WriteFLDCW : SchedWriteRes<[HWPort01, HWPort23, HWPort6]> {
1002   let Latency = 7;
1003   let NumMicroOps = 3;
1004 }
1005 def : InstRW<[WriteFLDCW], (instregex "FLDCW16m")>;
1006
1007 // FNSTCW.
1008 def WriteFNSTCW : SchedWriteRes<[HWPort237, HWPort4, HWPort6]> {
1009   let NumMicroOps = 3;
1010 }
1011 def : InstRW<[WriteFNSTCW], (instregex "FNSTCW16m")>;
1012
1013 // FINCSTP FDECSTP.
1014 def : InstRW<[WriteP01], (instregex "FINCSTP", "FDECSTP")>;
1015
1016 // FFREE.
1017 def : InstRW<[WriteP01], (instregex "FFREE")>;
1018
1019 // FNSAVE.
1020 def WriteFNSAVE : SchedWriteRes<[]> {
1021   let NumMicroOps = 147;
1022 }
1023 def : InstRW<[WriteFNSAVE], (instregex "FSAVEm")>;
1024
1025 // FRSTOR.
1026 def WriteFRSTOR : SchedWriteRes<[]> {
1027   let NumMicroOps = 90;
1028 }
1029 def : InstRW<[WriteFRSTOR], (instregex "FRSTORm")>;
1030
1031 //-- Arithmetic instructions --//
1032 // FABS.
1033 def : InstRW<[WriteP0], (instregex "ABS_F")>;
1034
1035 // FCHS.
1036 def : InstRW<[WriteP0], (instregex "CHS_F")>;
1037
1038 // FCOM(P) FUCOM(P).
1039 def : InstRW<[WriteP1], (instregex "COM_FST0r", "COMP_FST0r", "UCOM_Fr",
1040                          "UCOM_FPr")>;
1041 def : InstRW<[WriteP1_P23], (instregex "FCOM(32|64)m", "FCOMP(32|64)m")>;
1042
1043 // FCOMPP FUCOMPP.
1044 def : InstRW<[Write2P01], (instregex "FCOMPP", "UCOM_FPPr")>;
1045
1046 // FCOMI(P) FUCOMI(P).
1047 def : InstRW<[Write3P01], (instregex "COM_FIr", "COM_FIPr", "UCOM_FIr",
1048                            "UCOM_FIPr")>;
1049
1050 // FICOM(P).
1051 def : InstRW<[Write2P1_P23], (instregex "FICOM(16|32)m", "FICOMP(16|32)m")>;
1052
1053 // FTST.
1054 def : InstRW<[WriteP1], (instregex "TST_F")>;
1055
1056 // FXAM.
1057 def : InstRW<[Write2P1], (instregex "FXAM")>;
1058
1059 // FPREM.
1060 def WriteFPREM : SchedWriteRes<[]> {
1061   let Latency = 19;
1062   let NumMicroOps = 28;
1063 }
1064 def : InstRW<[WriteFPREM], (instregex "FPREM")>;
1065
1066 // FPREM1.
1067 def WriteFPREM1 : SchedWriteRes<[]> {
1068   let Latency = 27;
1069   let NumMicroOps = 41;
1070 }
1071 def : InstRW<[WriteFPREM1], (instregex "FPREM1")>;
1072
1073 // FRNDINT.
1074 def WriteFRNDINT : SchedWriteRes<[]> {
1075   let Latency = 11;
1076   let NumMicroOps = 17;
1077 }
1078 def : InstRW<[WriteFRNDINT], (instregex "FRNDINT")>;
1079
1080 //-- Math instructions --//
1081 // FSCALE.
1082 def WriteFSCALE : SchedWriteRes<[]> {
1083   let Latency = 75; // 49-125
1084   let NumMicroOps = 50; // 25-75
1085 }
1086 def : InstRW<[WriteFSCALE], (instregex "FSCALE")>;
1087
1088 // FXTRACT.
1089 def WriteFXTRACT : SchedWriteRes<[]> {
1090   let Latency = 15;
1091   let NumMicroOps = 17;
1092 }
1093 def : InstRW<[WriteFXTRACT], (instregex "FXTRACT")>;
1094
1095 //-- Other instructions --//
1096 // FNOP.
1097 def : InstRW<[WriteP01], (instregex "FNOP")>;
1098
1099 // WAIT.
1100 def : InstRW<[Write2P01], (instregex "WAIT")>;
1101
1102 // FNCLEX.
1103 def : InstRW<[Write5P0156], (instregex "FNCLEX")>;
1104
1105 // FNINIT.
1106 def WriteFNINIT : SchedWriteRes<[]> {
1107   let NumMicroOps = 26;
1108 }
1109 def : InstRW<[WriteFNINIT], (instregex "FNINIT")>;
1110
1111 //=== Integer MMX and XMM Instructions ===//
1112 //-- Move instructions --//
1113 // MOVD.
1114 // r32/64 <- (x)mm.
1115 def : InstRW<[WriteP0], (instregex "MMX_MOVD64grr", "MMX_MOVD64from64rr",
1116                          "VMOVPDI2DIrr", "MOVPDI2DIrr")>;
1117
1118 // (x)mm <- r32/64.
1119 def : InstRW<[WriteP5], (instregex "MMX_MOVD64rr", "MMX_MOVD64to64rr",
1120                          "VMOVDI2PDIrr", "MOVDI2PDIrr")>;
1121
1122 // MOVQ.
1123 // r64 <- (x)mm.
1124 def : InstRW<[WriteP0], (instregex "VMOVPQIto64rr")>;
1125
1126 // (x)mm <- r64.
1127 def : InstRW<[WriteP5], (instregex "VMOV64toPQIrr", "VMOVZQI2PQIrr")>;
1128
1129 // (x)mm <- (x)mm.
1130 def : InstRW<[WriteP015], (instregex "MMX_MOVQ64rr")>;
1131
1132 // (V)MOVDQA/U.
1133 // x <- x.
1134 def : InstRW<[WriteP015], (instregex "MOVDQ(A|U)rr", "VMOVDQ(A|U)rr",
1135                            "MOVDQ(A|U)rr_REV", "VMOVDQ(A|U)rr_REV",
1136                            "VMOVDQ(A|U)Yrr", "VMOVDQ(A|U)Yrr_REV")>;
1137
1138 // MOVDQ2Q.
1139 def : InstRW<[WriteP01P5], (instregex "MMX_MOVDQ2Qrr")>;
1140
1141 // MOVQ2DQ.
1142 def : InstRW<[WriteP015], (instregex "MMX_MOVQ2DQrr")>;
1143
1144
1145 // PACKSSWB/DW.
1146 // mm <- mm.
1147 def WriteMMXPACKSSrr : SchedWriteRes<[HWPort5]> {
1148   let Latency = 2;
1149   let NumMicroOps = 3;
1150   let ResourceCycles = [3];
1151 }
1152 def : InstRW<[WriteMMXPACKSSrr], (instregex "MMX_PACKSSDWirr",
1153                                   "MMX_PACKSSWBirr", "MMX_PACKUSWBirr")>;
1154
1155 // mm <- m64.
1156 def WriteMMXPACKSSrm : SchedWriteRes<[HWPort23, HWPort5]> {
1157   let Latency = 4;
1158   let NumMicroOps = 3;
1159   let ResourceCycles = [1, 3];
1160 }
1161 def : InstRW<[WriteMMXPACKSSrm], (instregex "MMX_PACKSSDWirm",
1162                                   "MMX_PACKSSWBirm", "MMX_PACKUSWBirm")>;
1163
1164 // VPMOVSX/ZX BW BD BQ DW DQ.
1165 // y <- x.
1166 def WriteVPMOVSX : SchedWriteRes<[HWPort5]> {
1167   let Latency = 3;
1168   let NumMicroOps = 1;
1169 }
1170 def : InstRW<[WriteVPMOVSX], (instregex "VPMOV(SX|ZX)(BW|BQ|DW|DQ)Yrr")>;
1171
1172
1173 } // SchedModel