contrib/llvm/lib/Target/X86/X86Schedule.td

   1 //===-- X86Schedule.td - X86 Scheduling Definitions --------*- 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 //===----------------------------------------------------------------------===//
  11 // InstrSchedModel annotations for out-of-order CPUs.
  12
  13 // Instructions with folded loads need to read the memory operand immediately,
  14 // but other register operands don't have to be read until the load is ready.
  15 // These operands are marked with ReadAfterLd.
  16 def ReadAfterLd : SchedRead;
  17
  18 // Instructions with both a load and a store folded are modeled as a folded
  19 // load + WriteRMW.
  20 def WriteRMW : SchedWrite;
  21
  22 // Helper to set SchedWrite ExePorts/Latency/ResourceCycles/NumMicroOps.
  23 multiclass X86WriteRes<SchedWrite SchedRW,
  24                        list<ProcResourceKind> ExePorts,
  25                        int Lat, list<int> Res, int UOps> {
  26   def : WriteRes<SchedRW, ExePorts> {
  27     let Latency = Lat;
  28     let ResourceCycles = Res;
  29     let NumMicroOps = UOps;
  30   }
  31 }
  32
  33 // Most instructions can fold loads, so almost every SchedWrite comes in two
  34 // variants: With and without a folded load.
  35 // An X86FoldableSchedWrite holds a reference to the corresponding SchedWrite
  36 // with a folded load.
  37 class X86FoldableSchedWrite : SchedWrite {
  38   // The SchedWrite to use when a load is folded into the instruction.
  39   SchedWrite Folded;
  40 }
  41
  42 // Multiclass that produces a linked pair of SchedWrites.
  43 multiclass X86SchedWritePair {
  44   // Register-Memory operation.
  45   def Ld : SchedWrite;
  46   // Register-Register operation.
  47   def NAME : X86FoldableSchedWrite {
  48     let Folded = !cast<SchedWrite>(NAME#"Ld");
  49   }
  50 }
  51
  52 // Helpers to mark SchedWrites as unsupported.
  53 multiclass X86WriteResUnsupported<SchedWrite SchedRW> {
  54   let Unsupported = 1 in {
  55     def : WriteRes<SchedRW, []>;
  56   }
  57 }
  58 multiclass X86WriteResPairUnsupported<X86FoldableSchedWrite SchedRW> {
  59   let Unsupported = 1 in {
  60     def : WriteRes<SchedRW, []>;
  61     def : WriteRes<SchedRW.Folded, []>;
  62   }
  63 }
  64
  65 // Multiclass that wraps X86FoldableSchedWrite for each vector width.
  66 class X86SchedWriteWidths<X86FoldableSchedWrite sScl,
  67                           X86FoldableSchedWrite s128,
  68                           X86FoldableSchedWrite s256,
  69                           X86FoldableSchedWrite s512> {
  70   X86FoldableSchedWrite Scl = sScl; // Scalar float/double operations.
  71   X86FoldableSchedWrite MMX = sScl; // MMX operations.
  72   X86FoldableSchedWrite XMM = s128; // XMM operations.
  73   X86FoldableSchedWrite YMM = s256; // YMM operations.
  74   X86FoldableSchedWrite ZMM = s512; // ZMM operations.
  75 }
  76
  77 // Multiclass that wraps X86SchedWriteWidths for each fp vector type.
  78 class X86SchedWriteSizes<X86SchedWriteWidths sPS,
  79                          X86SchedWriteWidths sPD> {
  80   X86SchedWriteWidths PS = sPS;
  81   X86SchedWriteWidths PD = sPD;
  82 }
  83
  84 // Multiclass that wraps move/load/store triple for a vector width.
  85 class X86SchedWriteMoveLS<SchedWrite MoveRR,
  86                           SchedWrite LoadRM,
  87                           SchedWrite StoreMR> {
  88   SchedWrite RR = MoveRR;
  89   SchedWrite RM = LoadRM;
  90   SchedWrite MR = StoreMR;
  91 }
  92
  93 // Multiclass that wraps X86SchedWriteMoveLS for each vector width.
  94 class X86SchedWriteMoveLSWidths<X86SchedWriteMoveLS sScl,
  95                                 X86SchedWriteMoveLS s128,
  96                                 X86SchedWriteMoveLS s256,
  97                                 X86SchedWriteMoveLS s512> {
  98   X86SchedWriteMoveLS Scl = sScl; // Scalar float/double operations.
  99   X86SchedWriteMoveLS MMX = sScl; // MMX operations.
 100   X86SchedWriteMoveLS XMM = s128; // XMM operations.
 101   X86SchedWriteMoveLS YMM = s256; // YMM operations.
 102   X86SchedWriteMoveLS ZMM = s512; // ZMM operations.
 103 }
 104
 105 // Loads, stores, and moves, not folded with other operations.
 106 def WriteLoad    : SchedWrite;
 107 def WriteStore   : SchedWrite;
 108 def WriteStoreNT : SchedWrite;
 109 def WriteMove    : SchedWrite;
 110
 111 // Arithmetic.
 112 defm WriteALU    : X86SchedWritePair; // Simple integer ALU op.
 113 defm WriteADC    : X86SchedWritePair; // Integer ALU + flags op.
 114 def  WriteALURMW : WriteSequence<[WriteALULd, WriteStore]>;
 115 def  WriteADCRMW : WriteSequence<[WriteADCLd, WriteStore]>;
 116 defm WriteIMul   : X86SchedWritePair; // Integer multiplication.
 117 defm WriteIMul64 : X86SchedWritePair; // Integer 64-bit multiplication.
 118 def  WriteIMulH  : SchedWrite;        // Integer multiplication, high part.
 119 def  WriteLEA    : SchedWrite;        // LEA instructions can't fold loads.
 120
 121 def  WriteBSWAP32 : SchedWrite; // Byte Order (Endianness) 32-bit Swap.
 122 def  WriteBSWAP64 : SchedWrite; // Byte Order (Endianness) 64-bit Swap.
 123
 124 // Integer division.
 125 defm WriteDiv8   : X86SchedWritePair;
 126 defm WriteDiv16  : X86SchedWritePair;
 127 defm WriteDiv32  : X86SchedWritePair;
 128 defm WriteDiv64  : X86SchedWritePair;
 129 defm WriteIDiv8  : X86SchedWritePair;
 130 defm WriteIDiv16 : X86SchedWritePair;
 131 defm WriteIDiv32 : X86SchedWritePair;
 132 defm WriteIDiv64 : X86SchedWritePair;
 133
 134 defm WriteBSF : X86SchedWritePair; // Bit scan forward.
 135 defm WriteBSR : X86SchedWritePair; // Bit scan reverse.
 136 defm WritePOPCNT : X86SchedWritePair; // Bit population count.
 137 defm WriteLZCNT : X86SchedWritePair; // Leading zero count.
 138 defm WriteTZCNT : X86SchedWritePair; // Trailing zero count.
 139 defm WriteCMOV  : X86SchedWritePair; // Conditional move.
 140 defm WriteCMOV2 : X86SchedWritePair; // Conditional (CF + ZF flag) move.
 141 def  WriteFCMOV : SchedWrite; // X87 conditional move.
 142 def  WriteSETCC : SchedWrite; // Set register based on condition code.
 143 def  WriteSETCCStore : SchedWrite;
 144 def  WriteLAHFSAHF : SchedWrite; // Load/Store flags in AH.
 145 def  WriteBitTest  : SchedWrite; // Bit Test - TODO add memory folding support
 146
 147 // Integer shifts and rotates.
 148 defm WriteShift : X86SchedWritePair;
 149 // Double shift instructions.
 150 def  WriteSHDrri  : SchedWrite;
 151 def  WriteSHDrrcl : SchedWrite;
 152 def  WriteSHDmri  : SchedWrite;
 153 def  WriteSHDmrcl : SchedWrite;
 154
 155 // BMI1 BEXTR, BMI2 BZHI
 156 defm WriteBEXTR : X86SchedWritePair;
 157 defm WriteBZHI  : X86SchedWritePair;
 158
 159 // Idioms that clear a register, like xorps %xmm0, %xmm0.
 160 // These can often bypass execution ports completely.
 161 def WriteZero : SchedWrite;
 162
 163 // Branches don't produce values, so they have no latency, but they still
 164 // consume resources. Indirect branches can fold loads.
 165 defm WriteJump : X86SchedWritePair;
 166
 167 // Floating point. This covers both scalar and vector operations.
 168 def  WriteFLD0          : SchedWrite;
 169 def  WriteFLD1          : SchedWrite;
 170 def  WriteFLDC          : SchedWrite;
 171 def  WriteFLoad         : SchedWrite;
 172 def  WriteFLoadX        : SchedWrite;
 173 def  WriteFLoadY        : SchedWrite;
 174 def  WriteFMaskedLoad   : SchedWrite;
 175 def  WriteFMaskedLoadY  : SchedWrite;
 176 def  WriteFStore        : SchedWrite;
 177 def  WriteFStoreX       : SchedWrite;
 178 def  WriteFStoreY       : SchedWrite;
 179 def  WriteFStoreNT      : SchedWrite;
 180 def  WriteFStoreNTX     : SchedWrite;
 181 def  WriteFStoreNTY     : SchedWrite;
 182 def  WriteFMaskedStore  : SchedWrite;
 183 def  WriteFMaskedStoreY : SchedWrite;
 184 def  WriteFMove         : SchedWrite;
 185 def  WriteFMoveX        : SchedWrite;
 186 def  WriteFMoveY        : SchedWrite;
 187
 188 defm WriteFAdd    : X86SchedWritePair; // Floating point add/sub.
 189 defm WriteFAddX   : X86SchedWritePair; // Floating point add/sub (XMM).
 190 defm WriteFAddY   : X86SchedWritePair; // Floating point add/sub (YMM).
 191 defm WriteFAddZ   : X86SchedWritePair; // Floating point add/sub (ZMM).
 192 defm WriteFAdd64  : X86SchedWritePair; // Floating point double add/sub.
 193 defm WriteFAdd64X : X86SchedWritePair; // Floating point double add/sub (XMM).
 194 defm WriteFAdd64Y : X86SchedWritePair; // Floating point double add/sub (YMM).
 195 defm WriteFAdd64Z : X86SchedWritePair; // Floating point double add/sub (ZMM).
 196 defm WriteFCmp    : X86SchedWritePair; // Floating point compare.
 197 defm WriteFCmpX   : X86SchedWritePair; // Floating point compare (XMM).
 198 defm WriteFCmpY   : X86SchedWritePair; // Floating point compare (YMM).
 199 defm WriteFCmpZ   : X86SchedWritePair; // Floating point compare (ZMM).
 200 defm WriteFCmp64  : X86SchedWritePair; // Floating point double compare.
 201 defm WriteFCmp64X : X86SchedWritePair; // Floating point double compare (XMM).
 202 defm WriteFCmp64Y : X86SchedWritePair; // Floating point double compare (YMM).
 203 defm WriteFCmp64Z : X86SchedWritePair; // Floating point double compare (ZMM).
 204 defm WriteFCom    : X86SchedWritePair; // Floating point compare to flags.
 205 defm WriteFMul    : X86SchedWritePair; // Floating point multiplication.
 206 defm WriteFMulX   : X86SchedWritePair; // Floating point multiplication (XMM).
 207 defm WriteFMulY   : X86SchedWritePair; // Floating point multiplication (YMM).
 208 defm WriteFMulZ   : X86SchedWritePair; // Floating point multiplication (YMM).
 209 defm WriteFMul64  : X86SchedWritePair; // Floating point double multiplication.
 210 defm WriteFMul64X : X86SchedWritePair; // Floating point double multiplication (XMM).
 211 defm WriteFMul64Y : X86SchedWritePair; // Floating point double multiplication (YMM).
 212 defm WriteFMul64Z : X86SchedWritePair; // Floating point double multiplication (ZMM).
 213 defm WriteFDiv    : X86SchedWritePair; // Floating point division.
 214 defm WriteFDivX   : X86SchedWritePair; // Floating point division (XMM).
 215 defm WriteFDivY   : X86SchedWritePair; // Floating point division (YMM).
 216 defm WriteFDivZ   : X86SchedWritePair; // Floating point division (ZMM).
 217 defm WriteFDiv64  : X86SchedWritePair; // Floating point double division.
 218 defm WriteFDiv64X : X86SchedWritePair; // Floating point double division (XMM).
 219 defm WriteFDiv64Y : X86SchedWritePair; // Floating point double division (YMM).
 220 defm WriteFDiv64Z : X86SchedWritePair; // Floating point double division (ZMM).
 221 defm WriteFSqrt  : X86SchedWritePair; // Floating point square root.
 222 defm WriteFSqrtX : X86SchedWritePair; // Floating point square root (XMM).
 223 defm WriteFSqrtY : X86SchedWritePair; // Floating point square root (YMM).
 224 defm WriteFSqrtZ : X86SchedWritePair; // Floating point square root (ZMM).
 225 defm WriteFSqrt64  : X86SchedWritePair; // Floating point double square root.
 226 defm WriteFSqrt64X : X86SchedWritePair; // Floating point double square root (XMM).
 227 defm WriteFSqrt64Y : X86SchedWritePair; // Floating point double square root (YMM).
 228 defm WriteFSqrt64Z : X86SchedWritePair; // Floating point double square root (ZMM).
 229 defm WriteFSqrt80  : X86SchedWritePair; // Floating point long double square root.
 230 defm WriteFRcp   : X86SchedWritePair; // Floating point reciprocal estimate.
 231 defm WriteFRcpX  : X86SchedWritePair; // Floating point reciprocal estimate (XMM).
 232 defm WriteFRcpY  : X86SchedWritePair; // Floating point reciprocal estimate (YMM).
 233 defm WriteFRcpZ  : X86SchedWritePair; // Floating point reciprocal estimate (ZMM).
 234 defm WriteFRsqrt : X86SchedWritePair; // Floating point reciprocal square root estimate.
 235 defm WriteFRsqrtX: X86SchedWritePair; // Floating point reciprocal square root estimate (XMM).
 236 defm WriteFRsqrtY: X86SchedWritePair; // Floating point reciprocal square root estimate (YMM).
 237 defm WriteFRsqrtZ: X86SchedWritePair; // Floating point reciprocal square root estimate (ZMM).
 238 defm WriteFMA    : X86SchedWritePair; // Fused Multiply Add.
 239 defm WriteFMAX   : X86SchedWritePair; // Fused Multiply Add (XMM).
 240 defm WriteFMAY   : X86SchedWritePair; // Fused Multiply Add (YMM).
 241 defm WriteFMAZ   : X86SchedWritePair; // Fused Multiply Add (ZMM).
 242 defm WriteDPPD   : X86SchedWritePair; // Floating point double dot product.
 243 defm WriteDPPS   : X86SchedWritePair; // Floating point single dot product.
 244 defm WriteDPPSY  : X86SchedWritePair; // Floating point single dot product (YMM).
 245 defm WriteDPPSZ  : X86SchedWritePair; // Floating point single dot product (ZMM).
 246 defm WriteFSign  : X86SchedWritePair; // Floating point fabs/fchs.
 247 defm WriteFRnd   : X86SchedWritePair; // Floating point rounding.
 248 defm WriteFRndY  : X86SchedWritePair; // Floating point rounding (YMM).
 249 defm WriteFRndZ  : X86SchedWritePair; // Floating point rounding (ZMM).
 250 defm WriteFLogic  : X86SchedWritePair; // Floating point and/or/xor logicals.
 251 defm WriteFLogicY : X86SchedWritePair; // Floating point and/or/xor logicals (YMM).
 252 defm WriteFLogicZ : X86SchedWritePair; // Floating point and/or/xor logicals (ZMM).
 253 defm WriteFTest   : X86SchedWritePair; // Floating point TEST instructions.
 254 defm WriteFTestY  : X86SchedWritePair; // Floating point TEST instructions (YMM).
 255 defm WriteFTestZ  : X86SchedWritePair; // Floating point TEST instructions (ZMM).
 256 defm WriteFShuffle  : X86SchedWritePair; // Floating point vector shuffles.
 257 defm WriteFShuffleY : X86SchedWritePair; // Floating point vector shuffles (YMM).
 258 defm WriteFShuffleZ : X86SchedWritePair; // Floating point vector shuffles (ZMM).
 259 defm WriteFVarShuffle  : X86SchedWritePair; // Floating point vector variable shuffles.
 260 defm WriteFVarShuffleY : X86SchedWritePair; // Floating point vector variable shuffles (YMM).
 261 defm WriteFVarShuffleZ : X86SchedWritePair; // Floating point vector variable shuffles (ZMM).
 262 defm WriteFBlend  : X86SchedWritePair; // Floating point vector blends.
 263 defm WriteFBlendY : X86SchedWritePair; // Floating point vector blends (YMM).
 264 defm WriteFBlendZ : X86SchedWritePair; // Floating point vector blends (ZMM).
 265 defm WriteFVarBlend  : X86SchedWritePair; // Fp vector variable blends.
 266 defm WriteFVarBlendY : X86SchedWritePair; // Fp vector variable blends (YMM).
 267 defm WriteFVarBlendZ : X86SchedWritePair; // Fp vector variable blends (YMZMM).
 268
 269 // FMA Scheduling helper class.
 270 class FMASC { X86FoldableSchedWrite Sched = WriteFAdd; }
 271
 272 // Horizontal Add/Sub (float and integer)
 273 defm WriteFHAdd  : X86SchedWritePair;
 274 defm WriteFHAddY : X86SchedWritePair;
 275 defm WriteFHAddZ : X86SchedWritePair;
 276 defm WritePHAdd  : X86SchedWritePair;
 277 defm WritePHAddX : X86SchedWritePair;
 278 defm WritePHAddY : X86SchedWritePair;
 279 defm WritePHAddZ : X86SchedWritePair;
 280
 281 // Vector integer operations.
 282 def  WriteVecLoad         : SchedWrite;
 283 def  WriteVecLoadX        : SchedWrite;
 284 def  WriteVecLoadY        : SchedWrite;
 285 def  WriteVecLoadNT       : SchedWrite;
 286 def  WriteVecLoadNTY      : SchedWrite;
 287 def  WriteVecMaskedLoad   : SchedWrite;
 288 def  WriteVecMaskedLoadY  : SchedWrite;
 289 def  WriteVecStore        : SchedWrite;
 290 def  WriteVecStoreX       : SchedWrite;
 291 def  WriteVecStoreY       : SchedWrite;
 292 def  WriteVecStoreNT      : SchedWrite;
 293 def  WriteVecStoreNTY     : SchedWrite;
 294 def  WriteVecMaskedStore  : SchedWrite;
 295 def  WriteVecMaskedStoreY : SchedWrite;
 296 def  WriteVecMove         : SchedWrite;
 297 def  WriteVecMoveX        : SchedWrite;
 298 def  WriteVecMoveY        : SchedWrite;
 299 def  WriteVecMoveToGpr    : SchedWrite;
 300 def  WriteVecMoveFromGpr  : SchedWrite;
 301
 302 defm WriteVecALU    : X86SchedWritePair; // Vector integer ALU op, no logicals.
 303 defm WriteVecALUX   : X86SchedWritePair; // Vector integer ALU op, no logicals (XMM).
 304 defm WriteVecALUY   : X86SchedWritePair; // Vector integer ALU op, no logicals (YMM).
 305 defm WriteVecALUZ   : X86SchedWritePair; // Vector integer ALU op, no logicals (ZMM).
 306 defm WriteVecLogic  : X86SchedWritePair; // Vector integer and/or/xor logicals.
 307 defm WriteVecLogicX : X86SchedWritePair; // Vector integer and/or/xor logicals (XMM).
 308 defm WriteVecLogicY : X86SchedWritePair; // Vector integer and/or/xor logicals (YMM).
 309 defm WriteVecLogicZ : X86SchedWritePair; // Vector integer and/or/xor logicals (ZMM).
 310 defm WriteVecTest  : X86SchedWritePair; // Vector integer TEST instructions.
 311 defm WriteVecTestY : X86SchedWritePair; // Vector integer TEST instructions (YMM).
 312 defm WriteVecTestZ : X86SchedWritePair; // Vector integer TEST instructions (ZMM).
 313 defm WriteVecShift  : X86SchedWritePair; // Vector integer shifts (default).
 314 defm WriteVecShiftX : X86SchedWritePair; // Vector integer shifts (XMM).
 315 defm WriteVecShiftY : X86SchedWritePair; // Vector integer shifts (YMM).
 316 defm WriteVecShiftZ : X86SchedWritePair; // Vector integer shifts (ZMM).
 317 defm WriteVecShiftImm : X86SchedWritePair; // Vector integer immediate shifts (default).
 318 defm WriteVecShiftImmX: X86SchedWritePair; // Vector integer immediate shifts (XMM).
 319 defm WriteVecShiftImmY: X86SchedWritePair; // Vector integer immediate shifts (YMM).
 320 defm WriteVecShiftImmZ: X86SchedWritePair; // Vector integer immediate shifts (ZMM).
 321 defm WriteVecIMul  : X86SchedWritePair; // Vector integer multiply (default).
 322 defm WriteVecIMulX : X86SchedWritePair; // Vector integer multiply (XMM).
 323 defm WriteVecIMulY : X86SchedWritePair; // Vector integer multiply (YMM).
 324 defm WriteVecIMulZ : X86SchedWritePair; // Vector integer multiply (ZMM).
 325 defm WritePMULLD   : X86SchedWritePair; // Vector PMULLD.
 326 defm WritePMULLDY   : X86SchedWritePair; // Vector PMULLD (YMM).
 327 defm WritePMULLDZ   : X86SchedWritePair; // Vector PMULLD (ZMM).
 328 defm WriteShuffle  : X86SchedWritePair; // Vector shuffles.
 329 defm WriteShuffleX : X86SchedWritePair; // Vector shuffles (XMM).
 330 defm WriteShuffleY : X86SchedWritePair; // Vector shuffles (YMM).
 331 defm WriteShuffleZ : X86SchedWritePair; // Vector shuffles (ZMM).
 332 defm WriteVarShuffle  : X86SchedWritePair; // Vector variable shuffles.
 333 defm WriteVarShuffleX : X86SchedWritePair; // Vector variable shuffles (XMM).
 334 defm WriteVarShuffleY : X86SchedWritePair; // Vector variable shuffles (YMM).
 335 defm WriteVarShuffleZ : X86SchedWritePair; // Vector variable shuffles (ZMM).
 336 defm WriteBlend  : X86SchedWritePair; // Vector blends.
 337 defm WriteBlendY : X86SchedWritePair; // Vector blends (YMM).
 338 defm WriteBlendZ : X86SchedWritePair; // Vector blends (ZMM).
 339 defm WriteVarBlend  : X86SchedWritePair; // Vector variable blends.
 340 defm WriteVarBlendY : X86SchedWritePair; // Vector variable blends (YMM).
 341 defm WriteVarBlendZ : X86SchedWritePair; // Vector variable blends (ZMM).
 342 defm WritePSADBW  : X86SchedWritePair; // Vector PSADBW.
 343 defm WritePSADBWX : X86SchedWritePair; // Vector PSADBW (XMM).
 344 defm WritePSADBWY : X86SchedWritePair; // Vector PSADBW (YMM).
 345 defm WritePSADBWZ : X86SchedWritePair; // Vector PSADBW (ZMM).
 346 defm WriteMPSAD  : X86SchedWritePair; // Vector MPSAD.
 347 defm WriteMPSADY : X86SchedWritePair; // Vector MPSAD (YMM).
 348 defm WriteMPSADZ : X86SchedWritePair; // Vector MPSAD (ZMM).
 349 defm WritePHMINPOS : X86SchedWritePair; // Vector PHMINPOS.
 350
 351 // Vector insert/extract operations.
 352 defm WriteVecInsert : X86SchedWritePair; // Insert gpr to vector element.
 353 def  WriteVecExtract : SchedWrite; // Extract vector element to gpr.
 354 def  WriteVecExtractSt : SchedWrite; // Extract vector element and store.
 355
 356 // MOVMSK operations.
 357 def WriteFMOVMSK    : SchedWrite;
 358 def WriteVecMOVMSK  : SchedWrite;
 359 def WriteVecMOVMSKY : SchedWrite;
 360 def WriteMMXMOVMSK  : SchedWrite;
 361
 362 // Conversion between integer and float.
 363 defm WriteCvtSD2I  : X86SchedWritePair; // Double -> Integer.
 364 defm WriteCvtPD2I  : X86SchedWritePair; // Double -> Integer (XMM).
 365 defm WriteCvtPD2IY : X86SchedWritePair; // Double -> Integer (YMM).
 366 defm WriteCvtPD2IZ : X86SchedWritePair; // Double -> Integer (ZMM).
 367
 368 defm WriteCvtSS2I  : X86SchedWritePair; // Float -> Integer.
 369 defm WriteCvtPS2I  : X86SchedWritePair; // Float -> Integer (XMM).
 370 defm WriteCvtPS2IY : X86SchedWritePair; // Float -> Integer (YMM).
 371 defm WriteCvtPS2IZ : X86SchedWritePair; // Float -> Integer (ZMM).
 372
 373 defm WriteCvtI2SD  : X86SchedWritePair; // Integer -> Double.
 374 defm WriteCvtI2PD  : X86SchedWritePair; // Integer -> Double (XMM).
 375 defm WriteCvtI2PDY : X86SchedWritePair; // Integer -> Double (YMM).
 376 defm WriteCvtI2PDZ : X86SchedWritePair; // Integer -> Double (ZMM).
 377
 378 defm WriteCvtI2SS  : X86SchedWritePair; // Integer -> Float.
 379 defm WriteCvtI2PS  : X86SchedWritePair; // Integer -> Float (XMM).
 380 defm WriteCvtI2PSY : X86SchedWritePair; // Integer -> Float (YMM).
 381 defm WriteCvtI2PSZ : X86SchedWritePair; // Integer -> Float (ZMM).
 382
 383 defm WriteCvtSS2SD  : X86SchedWritePair; // Float -> Double size conversion.
 384 defm WriteCvtPS2PD  : X86SchedWritePair; // Float -> Double size conversion (XMM).
 385 defm WriteCvtPS2PDY : X86SchedWritePair; // Float -> Double size conversion (YMM).
 386 defm WriteCvtPS2PDZ : X86SchedWritePair; // Float -> Double size conversion (ZMM).
 387
 388 defm WriteCvtSD2SS  : X86SchedWritePair; // Double -> Float size conversion.
 389 defm WriteCvtPD2PS  : X86SchedWritePair; // Double -> Float size conversion (XMM).
 390 defm WriteCvtPD2PSY : X86SchedWritePair; // Double -> Float size conversion (YMM).
 391 defm WriteCvtPD2PSZ : X86SchedWritePair; // Double -> Float size conversion (ZMM).
 392
 393 defm WriteCvtPH2PS    : X86SchedWritePair; // Half -> Float size conversion.
 394 defm WriteCvtPH2PSY   : X86SchedWritePair; // Half -> Float size conversion (YMM).
 395 defm WriteCvtPH2PSZ   : X86SchedWritePair; // Half -> Float size conversion (ZMM).
 396
 397 def  WriteCvtPS2PH    : SchedWrite; // // Float -> Half size conversion.
 398 def  WriteCvtPS2PHY   : SchedWrite; // // Float -> Half size conversion (YMM).
 399 def  WriteCvtPS2PHZ   : SchedWrite; // // Float -> Half size conversion (ZMM).
 400 def  WriteCvtPS2PHSt  : SchedWrite; // // Float -> Half + store size conversion.
 401 def  WriteCvtPS2PHYSt : SchedWrite; // // Float -> Half + store size conversion (YMM).
 402 def  WriteCvtPS2PHZSt : SchedWrite; // // Float -> Half + store size conversion (ZMM).
 403
 404 // CRC32 instruction.
 405 defm WriteCRC32 : X86SchedWritePair;
 406
 407 // Strings instructions.
 408 // Packed Compare Implicit Length Strings, Return Mask
 409 defm WritePCmpIStrM : X86SchedWritePair;
 410 // Packed Compare Explicit Length Strings, Return Mask
 411 defm WritePCmpEStrM : X86SchedWritePair;
 412 // Packed Compare Implicit Length Strings, Return Index
 413 defm WritePCmpIStrI : X86SchedWritePair;
 414 // Packed Compare Explicit Length Strings, Return Index
 415 defm WritePCmpEStrI : X86SchedWritePair;
 416
 417 // AES instructions.
 418 defm WriteAESDecEnc : X86SchedWritePair; // Decryption, encryption.
 419 defm WriteAESIMC : X86SchedWritePair; // InvMixColumn.
 420 defm WriteAESKeyGen : X86SchedWritePair; // Key Generation.
 421
 422 // Carry-less multiplication instructions.
 423 defm WriteCLMul : X86SchedWritePair;
 424
 425 // EMMS/FEMMS
 426 def WriteEMMS : SchedWrite;
 427
 428 // Load/store MXCSR
 429 def WriteLDMXCSR : SchedWrite;
 430 def WriteSTMXCSR : SchedWrite;
 431
 432 // Catch-all for expensive system instructions.
 433 def WriteSystem : SchedWrite;
 434
 435 // AVX2.
 436 defm WriteFShuffle256 : X86SchedWritePair; // Fp 256-bit width vector shuffles.
 437 defm WriteFVarShuffle256 : X86SchedWritePair; // Fp 256-bit width variable shuffles.
 438 defm WriteShuffle256 : X86SchedWritePair; // 256-bit width vector shuffles.
 439 defm WriteVarShuffle256 : X86SchedWritePair; // 256-bit width vector variable shuffles.
 440 defm WriteVarVecShift  : X86SchedWritePair; // Variable vector shifts.
 441 defm WriteVarVecShiftY : X86SchedWritePair; // Variable vector shifts (YMM).
 442 defm WriteVarVecShiftZ : X86SchedWritePair; // Variable vector shifts (ZMM).
 443
 444 // Old microcoded instructions that nobody use.
 445 def WriteMicrocoded : SchedWrite;
 446
 447 // Fence instructions.
 448 def WriteFence : SchedWrite;
 449
 450 // Nop, not very useful expect it provides a model for nops!
 451 def WriteNop : SchedWrite;
 452
 453 // Move/Load/Store wrappers.
 454 def WriteFMoveLS
 455  : X86SchedWriteMoveLS<WriteFMove, WriteFLoad, WriteFStore>;
 456 def WriteFMoveLSX
 457  : X86SchedWriteMoveLS<WriteFMoveX, WriteFLoadX, WriteFStoreX>;
 458 def WriteFMoveLSY
 459  : X86SchedWriteMoveLS<WriteFMoveY, WriteFLoadY, WriteFStoreY>;
 460 def SchedWriteFMoveLS
 461   : X86SchedWriteMoveLSWidths<WriteFMoveLS, WriteFMoveLSX,
 462                               WriteFMoveLSY, WriteFMoveLSY>;
 463
 464 def WriteFMoveLSNT
 465  : X86SchedWriteMoveLS<WriteFMove, WriteFLoad, WriteFStoreNT>;
 466 def WriteFMoveLSNTX
 467  : X86SchedWriteMoveLS<WriteFMove, WriteFLoad, WriteFStoreNTX>;
 468 def WriteFMoveLSNTY
 469  : X86SchedWriteMoveLS<WriteFMoveY, WriteFLoadY, WriteFStoreNTY>;
 470 def SchedWriteFMoveLSNT
 471   : X86SchedWriteMoveLSWidths<WriteFMoveLSNT, WriteFMoveLSNTX,
 472                               WriteFMoveLSNTY, WriteFMoveLSNTY>;
 473
 474 def WriteVecMoveLS
 475  : X86SchedWriteMoveLS<WriteVecMove, WriteVecLoad, WriteVecStore>;
 476 def WriteVecMoveLSX
 477  : X86SchedWriteMoveLS<WriteVecMoveX, WriteVecLoadX, WriteVecStoreX>;
 478 def WriteVecMoveLSY
 479  : X86SchedWriteMoveLS<WriteVecMoveY, WriteVecLoadY, WriteVecStoreY>;
 480 def SchedWriteVecMoveLS
 481   : X86SchedWriteMoveLSWidths<WriteVecMoveLS, WriteVecMoveLSX,
 482                               WriteVecMoveLSY, WriteVecMoveLSY>;
 483
 484 def WriteVecMoveLSNT
 485  : X86SchedWriteMoveLS<WriteVecMove, WriteVecLoadNT, WriteVecStoreNT>;
 486 def WriteVecMoveLSNTX
 487  : X86SchedWriteMoveLS<WriteVecMoveX, WriteVecLoadNT, WriteVecStoreNT>;
 488 def WriteVecMoveLSNTY
 489  : X86SchedWriteMoveLS<WriteVecMoveY, WriteVecLoadNTY, WriteVecStoreNTY>;
 490 def SchedWriteVecMoveLSNT
 491   : X86SchedWriteMoveLSWidths<WriteVecMoveLSNT, WriteVecMoveLSNTX,
 492                               WriteVecMoveLSNTY, WriteVecMoveLSNTY>;
 493
 494 // Vector width wrappers.
 495 def SchedWriteFAdd
 496  : X86SchedWriteWidths<WriteFAdd, WriteFAddX, WriteFAddY, WriteFAddZ>;
 497 def SchedWriteFAdd64
 498  : X86SchedWriteWidths<WriteFAdd64, WriteFAdd64X, WriteFAdd64Y, WriteFAdd64Z>;
 499 def SchedWriteFHAdd
 500  : X86SchedWriteWidths<WriteFHAdd, WriteFHAdd, WriteFHAddY, WriteFHAddZ>;
 501 def SchedWriteFCmp
 502  : X86SchedWriteWidths<WriteFCmp, WriteFCmpX, WriteFCmpY, WriteFCmpZ>;
 503 def SchedWriteFCmp64
 504  : X86SchedWriteWidths<WriteFCmp64, WriteFCmp64X, WriteFCmp64Y, WriteFCmp64Z>;
 505 def SchedWriteFMul
 506  : X86SchedWriteWidths<WriteFMul, WriteFMulX, WriteFMulY, WriteFMulZ>;
 507 def SchedWriteFMul64
 508  : X86SchedWriteWidths<WriteFMul64, WriteFMul64X, WriteFMul64Y, WriteFMul64Z>;
 509 def SchedWriteFMA
 510  : X86SchedWriteWidths<WriteFMA, WriteFMAX, WriteFMAY, WriteFMAZ>;
 511 def SchedWriteDPPD
 512  : X86SchedWriteWidths<WriteDPPD, WriteDPPD, WriteDPPD, WriteDPPD>;
 513 def SchedWriteDPPS
 514  : X86SchedWriteWidths<WriteDPPS, WriteDPPS, WriteDPPSY, WriteDPPSZ>;
 515 def SchedWriteFDiv
 516  : X86SchedWriteWidths<WriteFDiv, WriteFDivX, WriteFDivY, WriteFDivZ>;
 517 def SchedWriteFDiv64
 518  : X86SchedWriteWidths<WriteFDiv64, WriteFDiv64X, WriteFDiv64Y, WriteFDiv64Z>;
 519 def SchedWriteFSqrt
 520  : X86SchedWriteWidths<WriteFSqrt, WriteFSqrtX,
 521                        WriteFSqrtY, WriteFSqrtZ>;
 522 def SchedWriteFSqrt64
 523  : X86SchedWriteWidths<WriteFSqrt64, WriteFSqrt64X,
 524                        WriteFSqrt64Y, WriteFSqrt64Z>;
 525 def SchedWriteFRcp
 526  : X86SchedWriteWidths<WriteFRcp, WriteFRcpX, WriteFRcpY, WriteFRcpZ>;
 527 def SchedWriteFRsqrt
 528  : X86SchedWriteWidths<WriteFRsqrt, WriteFRsqrtX, WriteFRsqrtY, WriteFRsqrtZ>;
 529 def SchedWriteFRnd
 530  : X86SchedWriteWidths<WriteFRnd, WriteFRnd, WriteFRndY, WriteFRndZ>;
 531 def SchedWriteFLogic
 532  : X86SchedWriteWidths<WriteFLogic, WriteFLogic, WriteFLogicY, WriteFLogicZ>;
 533 def SchedWriteFTest
 534  : X86SchedWriteWidths<WriteFTest, WriteFTest, WriteFTestY, WriteFTestZ>;
 535
 536 def SchedWriteFShuffle
 537  : X86SchedWriteWidths<WriteFShuffle, WriteFShuffle,
 538                        WriteFShuffleY, WriteFShuffleZ>;
 539 def SchedWriteFVarShuffle
 540  : X86SchedWriteWidths<WriteFVarShuffle, WriteFVarShuffle,
 541                        WriteFVarShuffleY, WriteFVarShuffleZ>;
 542 def SchedWriteFBlend
 543  : X86SchedWriteWidths<WriteFBlend, WriteFBlend, WriteFBlendY, WriteFBlendZ>;
 544 def SchedWriteFVarBlend
 545  : X86SchedWriteWidths<WriteFVarBlend, WriteFVarBlend,
 546                        WriteFVarBlendY, WriteFVarBlendZ>;
 547
 548 def SchedWriteCvtDQ2PD
 549  : X86SchedWriteWidths<WriteCvtI2SD, WriteCvtI2PD,
 550                        WriteCvtI2PDY, WriteCvtI2PDZ>;
 551 def SchedWriteCvtDQ2PS
 552  : X86SchedWriteWidths<WriteCvtI2SS, WriteCvtI2PS,
 553                        WriteCvtI2PSY, WriteCvtI2PSZ>;
 554 def SchedWriteCvtPD2DQ
 555  : X86SchedWriteWidths<WriteCvtSD2I, WriteCvtPD2I,
 556                        WriteCvtPD2IY, WriteCvtPD2IZ>;
 557 def SchedWriteCvtPS2DQ
 558  : X86SchedWriteWidths<WriteCvtSS2I, WriteCvtPS2I,
 559                        WriteCvtPS2IY, WriteCvtPS2IZ>;
 560 def SchedWriteCvtPS2PD
 561  : X86SchedWriteWidths<WriteCvtSS2SD, WriteCvtPS2PD,
 562                        WriteCvtPS2PDY, WriteCvtPS2PDZ>;
 563 def SchedWriteCvtPD2PS
 564  : X86SchedWriteWidths<WriteCvtSD2SS, WriteCvtPD2PS,
 565                        WriteCvtPD2PSY, WriteCvtPD2PSZ>;
 566
 567 def SchedWriteVecALU
 568  : X86SchedWriteWidths<WriteVecALU, WriteVecALUX, WriteVecALUY, WriteVecALUZ>;
 569 def SchedWritePHAdd
 570  : X86SchedWriteWidths<WritePHAdd, WritePHAddX, WritePHAddY, WritePHAddZ>;
 571 def SchedWriteVecLogic
 572  : X86SchedWriteWidths<WriteVecLogic, WriteVecLogicX,
 573                        WriteVecLogicY, WriteVecLogicZ>;
 574 def SchedWriteVecTest
 575  : X86SchedWriteWidths<WriteVecTest, WriteVecTest,
 576                        WriteVecTestY, WriteVecTestZ>;
 577 def SchedWriteVecShift
 578  : X86SchedWriteWidths<WriteVecShift, WriteVecShiftX,
 579                        WriteVecShiftY, WriteVecShiftZ>;
 580 def SchedWriteVecShiftImm
 581  : X86SchedWriteWidths<WriteVecShiftImm, WriteVecShiftImmX,
 582                        WriteVecShiftImmY, WriteVecShiftImmZ>;
 583 def SchedWriteVarVecShift
 584  : X86SchedWriteWidths<WriteVarVecShift, WriteVarVecShift,
 585                        WriteVarVecShiftY, WriteVarVecShiftZ>;
 586 def SchedWriteVecIMul
 587  : X86SchedWriteWidths<WriteVecIMul, WriteVecIMulX,
 588                        WriteVecIMulY, WriteVecIMulZ>;
 589 def SchedWritePMULLD
 590  : X86SchedWriteWidths<WritePMULLD, WritePMULLD,
 591                        WritePMULLDY, WritePMULLDZ>;
 592 def SchedWriteMPSAD
 593  : X86SchedWriteWidths<WriteMPSAD, WriteMPSAD,
 594                        WriteMPSADY, WriteMPSADZ>;
 595 def SchedWritePSADBW
 596  : X86SchedWriteWidths<WritePSADBW, WritePSADBWX,
 597                        WritePSADBWY, WritePSADBWZ>;
 598
 599 def SchedWriteShuffle
 600  : X86SchedWriteWidths<WriteShuffle, WriteShuffleX,
 601                        WriteShuffleY, WriteShuffleZ>;
 602 def SchedWriteVarShuffle
 603  : X86SchedWriteWidths<WriteVarShuffle, WriteVarShuffleX,
 604                        WriteVarShuffleY, WriteVarShuffleZ>;
 605 def SchedWriteBlend
 606  : X86SchedWriteWidths<WriteBlend, WriteBlend, WriteBlendY, WriteBlendZ>;
 607 def SchedWriteVarBlend
 608  : X86SchedWriteWidths<WriteVarBlend, WriteVarBlend,
 609                        WriteVarBlendY, WriteVarBlendZ>;
 610
 611 // Vector size wrappers.
 612 def SchedWriteFAddSizes
 613  : X86SchedWriteSizes<SchedWriteFAdd, SchedWriteFAdd64>;
 614 def SchedWriteFCmpSizes
 615  : X86SchedWriteSizes<SchedWriteFCmp, SchedWriteFCmp64>;
 616 def SchedWriteFMulSizes
 617  : X86SchedWriteSizes<SchedWriteFMul, SchedWriteFMul64>;
 618 def SchedWriteFDivSizes
 619  : X86SchedWriteSizes<SchedWriteFDiv, SchedWriteFDiv64>;
 620 def SchedWriteFSqrtSizes
 621  : X86SchedWriteSizes<SchedWriteFSqrt, SchedWriteFSqrt64>;
 622 def SchedWriteFLogicSizes
 623  : X86SchedWriteSizes<SchedWriteFLogic, SchedWriteFLogic>;
 624 def SchedWriteFShuffleSizes
 625  : X86SchedWriteSizes<SchedWriteFShuffle, SchedWriteFShuffle>;
 626
 627 //===----------------------------------------------------------------------===//
 628 // Generic Processor Scheduler Models.
 629
 630 // IssueWidth is analogous to the number of decode units. Core and its
 631 // descendents, including Nehalem and SandyBridge have 4 decoders.
 632 // Resources beyond the decoder operate on micro-ops and are bufferred
 633 // so adjacent micro-ops don't directly compete.
 634 //
 635 // MicroOpBufferSize > 1 indicates that RAW dependencies can be
 636 // decoded in the same cycle. The value 32 is a reasonably arbitrary
 637 // number of in-flight instructions.
 638 //
 639 // HighLatency=10 is optimistic. X86InstrInfo::isHighLatencyDef
 640 // indicates high latency opcodes. Alternatively, InstrItinData
 641 // entries may be included here to define specific operand
 642 // latencies. Since these latencies are not used for pipeline hazards,
 643 // they do not need to be exact.
 644 //
 645 // The GenericX86Model contains no instruction schedules
 646 // and disables PostRAScheduler.
 647 class GenericX86Model : SchedMachineModel {
 648   let IssueWidth = 4;
 649   let MicroOpBufferSize = 32;
 650   let LoadLatency = 4;
 651   let HighLatency = 10;
 652   let PostRAScheduler = 0;
 653   let CompleteModel = 0;
 654 }
 655
 656 def GenericModel : GenericX86Model;
 657
 658 // Define a model with the PostRAScheduler enabled.
 659 def GenericPostRAModel : GenericX86Model {
 660   let PostRAScheduler = 1;
 661 }