contrib/llvm-project/llvm/lib/Target/X86/X86ScheduleAtom.td

   1 //===- X86ScheduleAtom.td - X86 Atom Scheduling Definitions -*- tablegen -*-==//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file defines the schedule class data for the Intel Atom
  10 // in order (Saltwell-32nm/Bonnell-45nm) processors.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //
  15 // Scheduling information derived from the "Intel 64 and IA32 Architectures
  16 // Optimization Reference Manual", Chapter 13, Section 4.
  17
  18 // Atom machine model.
  19 def AtomModel : SchedMachineModel {
  20   let IssueWidth = 2;  // Allows 2 instructions per scheduling group.
  21   let MicroOpBufferSize = 0; // In-order execution, always hide latency.
  22   let LoadLatency = 3; // Expected cycles, may be overriden.
  23   let HighLatency = 30;// Expected, may be overriden.
  24
  25   // On the Atom, the throughput for taken branches is 2 cycles. For small
  26   // simple loops, expand by a small factor to hide the backedge cost.
  27   let LoopMicroOpBufferSize = 10;
  28   let PostRAScheduler = 1;
  29   let CompleteModel = 0;
  30 }
  31
  32 let SchedModel = AtomModel in {
  33
  34 // Functional Units
  35 def AtomPort0 : ProcResource<1>; // ALU: ALU0, shift/rotate, load/store
  36                                  // SIMD/FP: SIMD ALU, Shuffle,SIMD/FP multiply, divide
  37 def AtomPort1 : ProcResource<1>; // ALU: ALU1, bit processing, jump, and LEA
  38                                  // SIMD/FP: SIMD ALU, FP Adder
  39
  40 def AtomPort01 : ProcResGroup<[AtomPort0, AtomPort1]>;
  41
  42 // Loads are 3 cycles, so ReadAfterLd registers needn't be available until 3
  43 // cycles after the memory operand.
  44 def : ReadAdvance<ReadAfterLd, 3>;
  45 def : ReadAdvance<ReadAfterVecLd, 3>;
  46 def : ReadAdvance<ReadAfterVecXLd, 3>;
  47 def : ReadAdvance<ReadAfterVecYLd, 3>;
  48
  49 def : ReadAdvance<ReadInt2Fpu, 0>;
  50
  51 // Many SchedWrites are defined in pairs with and without a folded load.
  52 // Instructions with folded loads are usually micro-fused, so they only appear
  53 // as two micro-ops when dispatched by the schedulers.
  54 // This multiclass defines the resource usage for variants with and without
  55 // folded loads.
  56 multiclass AtomWriteResPair<X86FoldableSchedWrite SchedRW,
  57                             list<ProcResourceKind> RRPorts,
  58                             list<ProcResourceKind> RMPorts,
  59                             int RRLat = 1, int RMLat = 1,
  60                             list<int> RRRes = [1],
  61                             list<int> RMRes = [1]> {
  62   // Register variant is using a single cycle on ExePort.
  63   def : WriteRes<SchedRW, RRPorts> {
  64     let Latency = RRLat;
  65     let ResourceCycles = RRRes;
  66   }
  67
  68   // Memory variant also uses a cycle on JLAGU and adds 3 cycles to the
  69   // latency.
  70   def : WriteRes<SchedRW.Folded, RMPorts> {
  71     let Latency = RMLat;
  72     let ResourceCycles = RMRes;
  73   }
  74 }
  75
  76 // A folded store needs a cycle on Port0 for the store data.
  77 def : WriteRes<WriteRMW, [AtomPort0]>;
  78
  79 ////////////////////////////////////////////////////////////////////////////////
  80 // Arithmetic.
  81 ////////////////////////////////////////////////////////////////////////////////
  82
  83 defm : AtomWriteResPair<WriteALU,    [AtomPort01], [AtomPort0]>;
  84 defm : AtomWriteResPair<WriteADC,    [AtomPort01], [AtomPort0]>;
  85
  86 defm : AtomWriteResPair<WriteIMul8,     [AtomPort01], [AtomPort01],  7,  7,  [7],  [7]>;
  87 defm : AtomWriteResPair<WriteIMul16,    [AtomPort01], [AtomPort01],  7,  8,  [7],  [8]>;
  88 defm : AtomWriteResPair<WriteIMul16Imm, [AtomPort01], [AtomPort01],  6,  7,  [6],  [7]>;
  89 defm : AtomWriteResPair<WriteIMul16Reg, [AtomPort01], [AtomPort01],  6,  7,  [6],  [7]>;
  90 defm : AtomWriteResPair<WriteIMul32,    [AtomPort01], [AtomPort01],  6,  7,  [6],  [7]>;
  91 defm : AtomWriteResPair<WriteIMul32Imm, [AtomPort0],  [AtomPort0],   5,  5,  [5],  [5]>;
  92 defm : AtomWriteResPair<WriteIMul32Reg, [AtomPort0],  [AtomPort0],   5,  5,  [5],  [5]>;
  93 defm : AtomWriteResPair<WriteIMul64,    [AtomPort01], [AtomPort01], 12, 12, [12], [12]>;
  94 defm : AtomWriteResPair<WriteIMul64Imm, [AtomPort01], [AtomPort01], 14, 14, [14], [14]>;
  95 defm : AtomWriteResPair<WriteIMul64Reg, [AtomPort01], [AtomPort01], 12, 12, [12], [12]>;
  96 defm : X86WriteResUnsupported<WriteIMulH>;
  97
  98 defm : X86WriteRes<WriteXCHG,        [AtomPort01], 2, [2], 1>;
  99 defm : X86WriteRes<WriteBSWAP32,     [AtomPort0], 1, [1], 1>;
 100 defm : X86WriteRes<WriteBSWAP64,     [AtomPort0], 1, [1], 1>;
 101 defm : AtomWriteResPair<WriteCMPXCHG, [AtomPort01], [AtomPort01], 15, 15, [15]>;
 102 defm : X86WriteRes<WriteCMPXCHGRMW,   [AtomPort01, AtomPort0], 1, [1, 1], 1>;
 103
 104 defm : AtomWriteResPair<WriteDiv8,   [AtomPort01], [AtomPort01], 50, 68, [50], [68]>;
 105 defm : AtomWriteResPair<WriteDiv16,  [AtomPort01], [AtomPort01], 50, 50, [50], [50]>;
 106 defm : AtomWriteResPair<WriteDiv32,  [AtomPort01], [AtomPort01], 50, 50, [50], [50]>;
 107 defm : AtomWriteResPair<WriteDiv64,  [AtomPort01], [AtomPort01],130,130,[130],[130]>;
 108 defm : AtomWriteResPair<WriteIDiv8,  [AtomPort01], [AtomPort01], 62, 62, [62], [62]>;
 109 defm : AtomWriteResPair<WriteIDiv16, [AtomPort01], [AtomPort01], 62, 62, [62], [62]>;
 110 defm : AtomWriteResPair<WriteIDiv32, [AtomPort01], [AtomPort01], 62, 62, [62], [62]>;
 111 defm : AtomWriteResPair<WriteIDiv64, [AtomPort01], [AtomPort01],130,130,[130],[130]>;
 112
 113 defm : X86WriteResPairUnsupported<WriteCRC32>;
 114
 115 defm : AtomWriteResPair<WriteCMOV,  [AtomPort01], [AtomPort0]>;
 116 defm : X86WriteRes<WriteFCMOV, [AtomPort01], 9, [9], 1>; // x87 conditional move.
 117
 118 def  : WriteRes<WriteSETCC, [AtomPort01]>;
 119 def  : WriteRes<WriteSETCCStore, [AtomPort01]> {
 120   let Latency = 2;
 121   let ResourceCycles = [2];
 122 }
 123 def  : WriteRes<WriteLAHFSAHF, [AtomPort01]> {
 124   let Latency = 2;
 125   let ResourceCycles = [2];
 126 }
 127 defm : X86WriteRes<WriteBitTest,         [AtomPort1],  1, [1], 1>;
 128 defm : X86WriteRes<WriteBitTestImmLd,    [AtomPort0],  1, [1], 1>;
 129 defm : X86WriteRes<WriteBitTestRegLd,    [AtomPort01], 9, [9], 1>;
 130 defm : X86WriteRes<WriteBitTestSet,      [AtomPort1],  1, [1], 1>;
 131 //defm : X86WriteRes<WriteBitTestSetImmLd, [AtomPort1],  1, [1], 1>;
 132 //defm : X86WriteRes<WriteBitTestSetRegLd, [AtomPort1],  1, [1], 1>;
 133
 134 // This is for simple LEAs with one or two input operands.
 135 def : WriteRes<WriteLEA, [AtomPort1]>;
 136
 137 // Bit counts.
 138 defm : AtomWriteResPair<WriteBSF, [AtomPort01], [AtomPort01], 16, 16, [16], [16]>;
 139 defm : AtomWriteResPair<WriteBSR, [AtomPort01], [AtomPort01], 16, 16, [16], [16]>;
 140 defm : X86WriteResPairUnsupported<WritePOPCNT>;
 141 defm : X86WriteResPairUnsupported<WriteLZCNT>;
 142 defm : X86WriteResPairUnsupported<WriteTZCNT>;
 143
 144 // BMI1 BEXTR/BLS, BMI2 BZHI
 145 defm : X86WriteResPairUnsupported<WriteBEXTR>;
 146 defm : X86WriteResPairUnsupported<WriteBLS>;
 147 defm : X86WriteResPairUnsupported<WriteBZHI>;
 148
 149 ////////////////////////////////////////////////////////////////////////////////
 150 // Integer shifts and rotates.
 151 ////////////////////////////////////////////////////////////////////////////////
 152
 153 defm : AtomWriteResPair<WriteShift,    [AtomPort0], [AtomPort0]>;
 154 defm : AtomWriteResPair<WriteShiftCL,  [AtomPort0], [AtomPort0]>;
 155 defm : AtomWriteResPair<WriteRotate,   [AtomPort0], [AtomPort0]>;
 156 defm : AtomWriteResPair<WriteRotateCL, [AtomPort0], [AtomPort0]>;
 157
 158 defm : X86WriteRes<WriteSHDrri, [AtomPort01], 2, [2], 1>;
 159 defm : X86WriteRes<WriteSHDrrcl,[AtomPort01], 2, [2], 1>;
 160 defm : X86WriteRes<WriteSHDmri, [AtomPort01], 4, [4], 1>;
 161 defm : X86WriteRes<WriteSHDmrcl,[AtomPort01], 4, [4], 1>;
 162
 163 ////////////////////////////////////////////////////////////////////////////////
 164 // Loads, stores, and moves, not folded with other operations.
 165 ////////////////////////////////////////////////////////////////////////////////
 166
 167 def : WriteRes<WriteLoad,    [AtomPort0]>;
 168 def : WriteRes<WriteStore,   [AtomPort0]>;
 169 def : WriteRes<WriteStoreNT, [AtomPort0]>;
 170 def : WriteRes<WriteMove,    [AtomPort01]>;
 171
 172 // Treat misc copies as a move.
 173 def : InstRW<[WriteMove], (instrs COPY)>;
 174
 175 ////////////////////////////////////////////////////////////////////////////////
 176 // Idioms that clear a register, like xorps %xmm0, %xmm0.
 177 // These can often bypass execution ports completely.
 178 ////////////////////////////////////////////////////////////////////////////////
 179
 180 def : WriteRes<WriteZero,  []>;
 181
 182 ////////////////////////////////////////////////////////////////////////////////
 183 // Branches don't produce values, so they have no latency, but they still
 184 // consume resources. Indirect branches can fold loads.
 185 ////////////////////////////////////////////////////////////////////////////////
 186
 187 defm : AtomWriteResPair<WriteJump, [AtomPort1], [AtomPort1]>;
 188
 189 ////////////////////////////////////////////////////////////////////////////////
 190 // Special case scheduling classes.
 191 ////////////////////////////////////////////////////////////////////////////////
 192
 193 def : WriteRes<WriteSystem,     [AtomPort01]> { let Latency = 100; }
 194 def : WriteRes<WriteMicrocoded, [AtomPort01]> { let Latency = 100; }
 195 def : WriteRes<WriteFence,      [AtomPort0]>;
 196
 197 // Nops don't have dependencies, so there's no actual latency, but we set this
 198 // to '1' to tell the scheduler that the nop uses an ALU slot for a cycle.
 199 def : WriteRes<WriteNop, [AtomPort01]>;
 200
 201 ////////////////////////////////////////////////////////////////////////////////
 202 // Floating point. This covers both scalar and vector operations.
 203 ////////////////////////////////////////////////////////////////////////////////
 204
 205 defm : X86WriteRes<WriteFLD0,       [AtomPort01], 1, [1], 1>;
 206 defm : X86WriteRes<WriteFLD1,       [AtomPort01], 6, [6], 1>;
 207 def  : WriteRes<WriteFLoad,         [AtomPort0]>;
 208 def  : WriteRes<WriteFLoadX,        [AtomPort0]>;
 209 defm : X86WriteResUnsupported<WriteFLoadY>;
 210 defm : X86WriteResUnsupported<WriteFMaskedLoad>;
 211 defm : X86WriteResUnsupported<WriteFMaskedLoadY>;
 212
 213 def  : WriteRes<WriteFStore,        [AtomPort0]>;
 214 def  : WriteRes<WriteFStoreX,       [AtomPort0]>;
 215 defm : X86WriteResUnsupported<WriteFStoreY>;
 216 def  : WriteRes<WriteFStoreNT,      [AtomPort0]>;
 217 def  : WriteRes<WriteFStoreNTX,     [AtomPort0]>;
 218 defm : X86WriteResUnsupported<WriteFStoreNTY>;
 219 defm : X86WriteResUnsupported<WriteFMaskedStore32>;
 220 defm : X86WriteResUnsupported<WriteFMaskedStore32Y>;
 221 defm : X86WriteResUnsupported<WriteFMaskedStore64>;
 222 defm : X86WriteResUnsupported<WriteFMaskedStore64Y>;
 223
 224 def  : WriteRes<WriteFMove,         [AtomPort01]>;
 225 def  : WriteRes<WriteFMoveX,        [AtomPort01]>;
 226 defm : X86WriteResUnsupported<WriteFMoveY>;
 227
 228 defm : X86WriteRes<WriteEMMS,       [AtomPort01], 5, [5], 1>;
 229
 230 defm : AtomWriteResPair<WriteFAdd,           [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 231 defm : AtomWriteResPair<WriteFAddX,          [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 232 defm : X86WriteResPairUnsupported<WriteFAddY>;
 233 defm : X86WriteResPairUnsupported<WriteFAddZ>;
 234 defm : AtomWriteResPair<WriteFAdd64,         [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 235 defm : AtomWriteResPair<WriteFAdd64X,       [AtomPort01], [AtomPort01],  6,  7,  [6],  [7]>;
 236 defm : X86WriteResPairUnsupported<WriteFAdd64Y>;
 237 defm : X86WriteResPairUnsupported<WriteFAdd64Z>;
 238 defm : AtomWriteResPair<WriteFCmp,           [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 239 defm : AtomWriteResPair<WriteFCmpX,          [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 240 defm : X86WriteResPairUnsupported<WriteFCmpY>;
 241 defm : X86WriteResPairUnsupported<WriteFCmpZ>;
 242 defm : AtomWriteResPair<WriteFCmp64,         [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 243 defm : AtomWriteResPair<WriteFCmp64X,       [AtomPort01], [AtomPort01],  6,  7,  [6],  [7]>;
 244 defm : X86WriteResPairUnsupported<WriteFCmp64Y>;
 245 defm : X86WriteResPairUnsupported<WriteFCmp64Z>;
 246 defm : AtomWriteResPair<WriteFCom,           [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 247 defm : AtomWriteResPair<WriteFComX,          [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 248 defm : AtomWriteResPair<WriteFMul,           [AtomPort0],  [AtomPort0],  4,  4,  [4],  [4]>;
 249 defm : AtomWriteResPair<WriteFMulX,          [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 250 defm : X86WriteResPairUnsupported<WriteFMulY>;
 251 defm : X86WriteResPairUnsupported<WriteFMulZ>;
 252 defm : AtomWriteResPair<WriteFMul64,         [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 253 defm : AtomWriteResPair<WriteFMul64X,       [AtomPort01], [AtomPort01],  9, 10,  [9], [10]>;
 254 defm : X86WriteResPairUnsupported<WriteFMul64Y>;
 255 defm : X86WriteResPairUnsupported<WriteFMul64Z>;
 256 defm : AtomWriteResPair<WriteFRcp,           [AtomPort0],  [AtomPort0],  4,  4,  [4],  [4]>;
 257 defm : AtomWriteResPair<WriteFRcpX,         [AtomPort01], [AtomPort01],  9, 10,  [9], [10]>;
 258 defm : X86WriteResPairUnsupported<WriteFRcpY>;
 259 defm : X86WriteResPairUnsupported<WriteFRcpZ>;
 260 defm : AtomWriteResPair<WriteFRsqrt,         [AtomPort0],  [AtomPort0],  4,  4,  [4],  [4]>;
 261 defm : AtomWriteResPair<WriteFRsqrtX,       [AtomPort01], [AtomPort01],  9, 10,  [9], [10]>;
 262 defm : X86WriteResPairUnsupported<WriteFRsqrtY>;
 263 defm : X86WriteResPairUnsupported<WriteFRsqrtZ>;
 264 defm : AtomWriteResPair<WriteFDiv,          [AtomPort01], [AtomPort01], 34, 34, [34], [34]>;
 265 defm : AtomWriteResPair<WriteFDivX,         [AtomPort01], [AtomPort01], 70, 70, [70], [70]>;
 266 defm : X86WriteResPairUnsupported<WriteFDivY>;
 267 defm : X86WriteResPairUnsupported<WriteFDivZ>;
 268 defm : AtomWriteResPair<WriteFDiv64,        [AtomPort01], [AtomPort01], 62, 62, [62], [62]>;
 269 defm : AtomWriteResPair<WriteFDiv64X,       [AtomPort01], [AtomPort01],125,125,[125],[125]>;
 270 defm : X86WriteResPairUnsupported<WriteFDiv64Y>;
 271 defm : X86WriteResPairUnsupported<WriteFDiv64Z>;
 272 defm : AtomWriteResPair<WriteFSqrt,         [AtomPort01], [AtomPort01], 34, 34, [34], [34]>;
 273 defm : AtomWriteResPair<WriteFSqrtX,        [AtomPort01], [AtomPort01], 70, 70, [70], [70]>;
 274 defm : X86WriteResPairUnsupported<WriteFSqrtY>;
 275 defm : X86WriteResPairUnsupported<WriteFSqrtZ>;
 276 defm : AtomWriteResPair<WriteFSqrt64,       [AtomPort01], [AtomPort01], 62, 62, [62], [62]>;
 277 defm : AtomWriteResPair<WriteFSqrt64X,      [AtomPort01], [AtomPort01],125,125,[125],[125]>;
 278 defm : X86WriteResPairUnsupported<WriteFSqrt64Y>;
 279 defm : X86WriteResPairUnsupported<WriteFSqrt64Z>;
 280 defm : AtomWriteResPair<WriteFSqrt80,       [AtomPort01], [AtomPort01], 71, 71, [71], [71]>;
 281 defm : AtomWriteResPair<WriteFSign,          [AtomPort1],  [AtomPort1]>;
 282 defm : AtomWriteResPair<WriteFRnd,           [AtomPort0],  [AtomPort0],  5,  5,  [5],  [5]>;
 283 defm : X86WriteResPairUnsupported<WriteFRndY>;
 284 defm : X86WriteResPairUnsupported<WriteFRndZ>;
 285 defm : AtomWriteResPair<WriteFLogic,        [AtomPort01],  [AtomPort0]>;
 286 defm : X86WriteResPairUnsupported<WriteFLogicY>;
 287 defm : X86WriteResPairUnsupported<WriteFLogicZ>;
 288 defm : AtomWriteResPair<WriteFTest,         [AtomPort01],  [AtomPort0]>;
 289 defm : X86WriteResPairUnsupported<WriteFTestY>;
 290 defm : X86WriteResPairUnsupported<WriteFTestZ>;
 291 defm : AtomWriteResPair<WriteFShuffle,       [AtomPort0],  [AtomPort0]>;
 292 defm : X86WriteResPairUnsupported<WriteFShuffleY>;
 293 defm : X86WriteResPairUnsupported<WriteFShuffleZ>;
 294 defm : X86WriteResPairUnsupported<WriteFVarShuffle>;
 295 defm : X86WriteResPairUnsupported<WriteFVarShuffleY>;
 296 defm : X86WriteResPairUnsupported<WriteFVarShuffleZ>;
 297 defm : X86WriteResPairUnsupported<WriteFMA>;
 298 defm : X86WriteResPairUnsupported<WriteFMAX>;
 299 defm : X86WriteResPairUnsupported<WriteFMAY>;
 300 defm : X86WriteResPairUnsupported<WriteFMAZ>;
 301 defm : X86WriteResPairUnsupported<WriteDPPD>;
 302 defm : X86WriteResPairUnsupported<WriteDPPS>;
 303 defm : X86WriteResPairUnsupported<WriteDPPSY>;
 304 defm : X86WriteResPairUnsupported<WriteDPPSZ>;
 305 defm : X86WriteResPairUnsupported<WriteFBlend>;
 306 defm : X86WriteResPairUnsupported<WriteFBlendY>;
 307 defm : X86WriteResPairUnsupported<WriteFBlendZ>;
 308 defm : X86WriteResPairUnsupported<WriteFVarBlend>;
 309 defm : X86WriteResPairUnsupported<WriteFVarBlendY>;
 310 defm : X86WriteResPairUnsupported<WriteFVarBlendZ>;
 311 defm : X86WriteResPairUnsupported<WriteFShuffle256>;
 312 defm : X86WriteResPairUnsupported<WriteFVarShuffle256>;
 313
 314 ////////////////////////////////////////////////////////////////////////////////
 315 // Conversions.
 316 ////////////////////////////////////////////////////////////////////////////////
 317
 318 defm : AtomWriteResPair<WriteCvtSS2I,   [AtomPort01], [AtomPort01], 8, 9, [8], [9]>;
 319 defm : AtomWriteResPair<WriteCvtPS2I,   [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 320 defm : X86WriteResPairUnsupported<WriteCvtPS2IY>;
 321 defm : X86WriteResPairUnsupported<WriteCvtPS2IZ>;
 322 defm : AtomWriteResPair<WriteCvtSD2I,   [AtomPort01], [AtomPort01], 8, 9, [8], [9]>;
 323 defm : AtomWriteResPair<WriteCvtPD2I,   [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 324 defm : X86WriteResPairUnsupported<WriteCvtPD2IY>;
 325 defm : X86WriteResPairUnsupported<WriteCvtPD2IZ>;
 326
 327 defm : AtomWriteResPair<WriteCvtI2SS,   [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 328 defm : AtomWriteResPair<WriteCvtI2PS,   [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 329 defm : X86WriteResPairUnsupported<WriteCvtI2PSY>;
 330 defm : X86WriteResPairUnsupported<WriteCvtI2PSZ>;
 331 defm : AtomWriteResPair<WriteCvtI2SD,   [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 332 defm : AtomWriteResPair<WriteCvtI2PD,   [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 333 defm : X86WriteResPairUnsupported<WriteCvtI2PDY>;
 334 defm : X86WriteResPairUnsupported<WriteCvtI2PDZ>;
 335
 336 defm : AtomWriteResPair<WriteCvtSS2SD,  [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 337 defm : AtomWriteResPair<WriteCvtPS2PD,  [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 338 defm : X86WriteResPairUnsupported<WriteCvtPS2PDY>;
 339 defm : X86WriteResPairUnsupported<WriteCvtPS2PDZ>;
 340 defm : AtomWriteResPair<WriteCvtSD2SS,  [AtomPort01], [AtomPort01], 6, 7, [6], [7]>;
 341 defm : AtomWriteResPair<WriteCvtPD2PS,  [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 342 defm : X86WriteResPairUnsupported<WriteCvtPD2PSY>;
 343 defm : X86WriteResPairUnsupported<WriteCvtPD2PSZ>;
 344
 345 defm : X86WriteResPairUnsupported<WriteCvtPH2PS>;
 346 defm : X86WriteResPairUnsupported<WriteCvtPH2PSY>;
 347 defm : X86WriteResPairUnsupported<WriteCvtPH2PSZ>;
 348 defm : X86WriteResUnsupported<WriteCvtPS2PH>;
 349 defm : X86WriteResUnsupported<WriteCvtPS2PHSt>;
 350 defm : X86WriteResUnsupported<WriteCvtPS2PHY>;
 351 defm : X86WriteResUnsupported<WriteCvtPS2PHZ>;
 352 defm : X86WriteResUnsupported<WriteCvtPS2PHYSt>;
 353 defm : X86WriteResUnsupported<WriteCvtPS2PHZSt>;
 354
 355 ////////////////////////////////////////////////////////////////////////////////
 356 // Vector integer operations.
 357 ////////////////////////////////////////////////////////////////////////////////
 358
 359 def  : WriteRes<WriteVecLoad,         [AtomPort0]>;
 360 def  : WriteRes<WriteVecLoadX,        [AtomPort0]>;
 361 defm : X86WriteResUnsupported<WriteVecLoadY>;
 362 def  : WriteRes<WriteVecLoadNT,       [AtomPort0]>;
 363 defm : X86WriteResUnsupported<WriteVecLoadNTY>;
 364 defm : X86WriteResUnsupported<WriteVecMaskedLoad>;
 365 defm : X86WriteResUnsupported<WriteVecMaskedLoadY>;
 366
 367 def  : WriteRes<WriteVecStore,        [AtomPort0]>;
 368 def  : WriteRes<WriteVecStoreX,       [AtomPort0]>;
 369 defm : X86WriteResUnsupported<WriteVecStoreY>;
 370 def  : WriteRes<WriteVecStoreNT,      [AtomPort0]>;
 371 defm : X86WriteResUnsupported<WriteVecStoreNTY>;
 372 defm : X86WriteResUnsupported<WriteVecMaskedStore32>;
 373 defm : X86WriteResUnsupported<WriteVecMaskedStore64>;
 374 defm : X86WriteResUnsupported<WriteVecMaskedStore32Y>;
 375 defm : X86WriteResUnsupported<WriteVecMaskedStore64Y>;
 376
 377 def  : WriteRes<WriteVecMove,          [AtomPort0]>;
 378 def  : WriteRes<WriteVecMoveX,        [AtomPort01]>;
 379 defm : X86WriteResUnsupported<WriteVecMoveY>;
 380 defm : X86WriteRes<WriteVecMoveToGpr,   [AtomPort0], 3, [3], 1>;
 381 defm : X86WriteRes<WriteVecMoveFromGpr, [AtomPort0], 1, [1], 1>;
 382
 383 defm : AtomWriteResPair<WriteVecALU,       [AtomPort01],  [AtomPort0], 1, 1>;
 384 defm : AtomWriteResPair<WriteVecALUX,      [AtomPort01],  [AtomPort0], 1, 1>;
 385 defm : X86WriteResPairUnsupported<WriteVecALUY>;
 386 defm : X86WriteResPairUnsupported<WriteVecALUZ>;
 387 defm : AtomWriteResPair<WriteVecLogic,     [AtomPort01],  [AtomPort0], 1, 1>;
 388 defm : AtomWriteResPair<WriteVecLogicX,    [AtomPort01],  [AtomPort0], 1, 1>;
 389 defm : X86WriteResPairUnsupported<WriteVecLogicY>;
 390 defm : X86WriteResPairUnsupported<WriteVecLogicZ>;
 391 defm : AtomWriteResPair<WriteVecTest,      [AtomPort01],  [AtomPort0], 1, 1>;
 392 defm : X86WriteResPairUnsupported<WriteVecTestY>;
 393 defm : X86WriteResPairUnsupported<WriteVecTestZ>;
 394 defm : AtomWriteResPair<WriteVecShift,     [AtomPort01], [AtomPort01], 2, 3, [2], [3]>;
 395 defm : AtomWriteResPair<WriteVecShiftX,    [AtomPort01], [AtomPort01], 2, 3, [2], [3]>;
 396 defm : X86WriteResPairUnsupported<WriteVecShiftY>;
 397 defm : X86WriteResPairUnsupported<WriteVecShiftZ>;
 398 defm : AtomWriteResPair<WriteVecShiftImm,  [AtomPort01], [AtomPort01], 1, 1, [1], [1]>;
 399 defm : AtomWriteResPair<WriteVecShiftImmX, [AtomPort01], [AtomPort01], 1, 1, [1], [1]>;
 400 defm : X86WriteResPairUnsupported<WriteVecShiftImmY>;
 401 defm : X86WriteResPairUnsupported<WriteVecShiftImmZ>;
 402 defm : AtomWriteResPair<WriteVecIMul,       [AtomPort0],  [AtomPort0], 4, 4, [4], [4]>;
 403 defm : AtomWriteResPair<WriteVecIMulX,      [AtomPort0],  [AtomPort0], 5, 5, [5], [5]>;
 404 defm : X86WriteResPairUnsupported<WriteVecIMulY>;
 405 defm : X86WriteResPairUnsupported<WriteVecIMulZ>;
 406 defm : X86WriteResPairUnsupported<WritePMULLD>;
 407 defm : X86WriteResPairUnsupported<WritePMULLDY>;
 408 defm : X86WriteResPairUnsupported<WritePMULLDZ>;
 409 defm : X86WriteResPairUnsupported<WritePHMINPOS>;
 410 defm : X86WriteResPairUnsupported<WriteMPSAD>;
 411 defm : X86WriteResPairUnsupported<WriteMPSADY>;
 412 defm : X86WriteResPairUnsupported<WriteMPSADZ>;
 413 defm : AtomWriteResPair<WritePSADBW,       [AtomPort01], [AtomPort01], 4, 4, [4], [4]>;
 414 defm : AtomWriteResPair<WritePSADBWX,       [AtomPort0],  [AtomPort0], 5, 5, [5], [5]>;
 415 defm : X86WriteResPairUnsupported<WritePSADBWY>;
 416 defm : X86WriteResPairUnsupported<WritePSADBWZ>;
 417 defm : AtomWriteResPair<WriteShuffle,       [AtomPort0],  [AtomPort0], 1, 1>;
 418 defm : AtomWriteResPair<WriteShuffleX,      [AtomPort0],  [AtomPort0], 1, 1>;
 419 defm : X86WriteResPairUnsupported<WriteShuffleY>;
 420 defm : X86WriteResPairUnsupported<WriteShuffleZ>;
 421 defm : AtomWriteResPair<WriteVarShuffle,    [AtomPort0],  [AtomPort0], 1, 1>;
 422 defm : AtomWriteResPair<WriteVarShuffleX,  [AtomPort01], [AtomPort01], 4, 5, [4], [5]>;
 423 defm : X86WriteResPairUnsupported<WriteVarShuffleY>;
 424 defm : X86WriteResPairUnsupported<WriteVarShuffleZ>;
 425 defm : X86WriteResPairUnsupported<WriteBlend>;
 426 defm : X86WriteResPairUnsupported<WriteBlendY>;
 427 defm : X86WriteResPairUnsupported<WriteBlendZ>;
 428 defm : X86WriteResPairUnsupported<WriteVarBlend>;
 429 defm : X86WriteResPairUnsupported<WriteVarBlendY>;
 430 defm : X86WriteResPairUnsupported<WriteVarBlendZ>;
 431 defm : X86WriteResPairUnsupported<WriteShuffle256>;
 432 defm : X86WriteResPairUnsupported<WriteVarShuffle256>;
 433 defm : X86WriteResPairUnsupported<WriteVarVecShift>;
 434 defm : X86WriteResPairUnsupported<WriteVarVecShiftY>;
 435 defm : X86WriteResPairUnsupported<WriteVarVecShiftZ>;
 436
 437 ////////////////////////////////////////////////////////////////////////////////
 438 // Vector insert/extract operations.
 439 ////////////////////////////////////////////////////////////////////////////////
 440
 441 defm : AtomWriteResPair<WriteVecInsert,     [AtomPort0],  [AtomPort0], 1, 1>;
 442 def  : WriteRes<WriteVecExtract,   [AtomPort0]>;
 443 def  : WriteRes<WriteVecExtractSt, [AtomPort0]>;
 444
 445 ////////////////////////////////////////////////////////////////////////////////
 446 // SSE42 String instructions.
 447 ////////////////////////////////////////////////////////////////////////////////
 448
 449 defm : X86WriteResPairUnsupported<WritePCmpIStrI>;
 450 defm : X86WriteResPairUnsupported<WritePCmpIStrM>;
 451 defm : X86WriteResPairUnsupported<WritePCmpEStrI>;
 452 defm : X86WriteResPairUnsupported<WritePCmpEStrM>;
 453
 454 ////////////////////////////////////////////////////////////////////////////////
 455 // MOVMSK Instructions.
 456 ////////////////////////////////////////////////////////////////////////////////
 457
 458 def  : WriteRes<WriteFMOVMSK,    [AtomPort0]> { let Latency = 3; let ResourceCycles = [3]; }
 459 def  : WriteRes<WriteVecMOVMSK,  [AtomPort0]> { let Latency = 3; let ResourceCycles = [3]; }
 460 defm : X86WriteResUnsupported<WriteVecMOVMSKY>;
 461 def  : WriteRes<WriteMMXMOVMSK,  [AtomPort0]> { let Latency = 3; let ResourceCycles = [3]; }
 462
 463 ////////////////////////////////////////////////////////////////////////////////
 464 // AES instructions.
 465 ////////////////////////////////////////////////////////////////////////////////
 466
 467 defm : X86WriteResPairUnsupported<WriteAESIMC>;
 468 defm : X86WriteResPairUnsupported<WriteAESKeyGen>;
 469 defm : X86WriteResPairUnsupported<WriteAESDecEnc>;
 470
 471 ////////////////////////////////////////////////////////////////////////////////
 472 // Horizontal add/sub  instructions.
 473 ////////////////////////////////////////////////////////////////////////////////
 474
 475 defm : AtomWriteResPair<WriteFHAdd,  [AtomPort01], [AtomPort01], 8, 9, [8], [9]>;
 476 defm : AtomWriteResPair<WriteFHAddY, [AtomPort01], [AtomPort01], 8, 9, [8], [9]>;
 477 defm : AtomWriteResPair<WritePHAdd,  [AtomPort01], [AtomPort01], 3, 4, [3], [4]>;
 478 defm : AtomWriteResPair<WritePHAddX, [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 479 defm : AtomWriteResPair<WritePHAddY, [AtomPort01], [AtomPort01], 7, 8, [7], [8]>;
 480
 481 ////////////////////////////////////////////////////////////////////////////////
 482 // Carry-less multiplication instructions.
 483 ////////////////////////////////////////////////////////////////////////////////
 484
 485 defm : X86WriteResPairUnsupported<WriteCLMul>;
 486
 487 ////////////////////////////////////////////////////////////////////////////////
 488 // Load/store MXCSR.
 489 ////////////////////////////////////////////////////////////////////////////////
 490
 491 def : WriteRes<WriteLDMXCSR, [AtomPort01]> { let Latency = 5; let ResourceCycles = [5]; }
 492 def : WriteRes<WriteSTMXCSR, [AtomPort01]> { let Latency = 15; let ResourceCycles = [15]; }
 493
 494 ////////////////////////////////////////////////////////////////////////////////
 495 // Special Cases.
 496 ////////////////////////////////////////////////////////////////////////////////
 497
 498 // Port0
 499 def AtomWrite0_1 : SchedWriteRes<[AtomPort0]> {
 500   let Latency = 1;
 501   let ResourceCycles = [1];
 502 }
 503 def : InstRW<[AtomWrite0_1], (instrs FXAM, LD_Frr,
 504                                      MOVSX64rr32)>;
 505 def : SchedAlias<WriteALURMW, AtomWrite0_1>;
 506 def : SchedAlias<WriteADCRMW, AtomWrite0_1>;
 507 def : InstRW<[AtomWrite0_1], (instregex "(RCL|RCR|ROL|ROR|SAR|SHL|SHR)(8|16|32|64)m",
 508                                         "MOV(S|Z)X(32|64)rr(8|8_NOREX|16)")>;
 509
 510 // Port1
 511 def AtomWrite1_1 : SchedWriteRes<[AtomPort1]> {
 512   let Latency = 1;
 513   let ResourceCycles = [1];
 514 }
 515 def : InstRW<[AtomWrite1_1], (instrs FCOMPP)>;
 516 def : InstRW<[AtomWrite1_1], (instregex "UCOM_F(P|PP)?r")>;
 517
 518 def AtomWrite1_5 : SchedWriteRes<[AtomPort1]> {
 519   let Latency = 5;
 520   let ResourceCycles = [5];
 521 }
 522 def : InstRW<[AtomWrite1_5], (instrs MMX_CVTPI2PSirr, MMX_CVTPI2PSirm,
 523                                      MMX_CVTPS2PIirr, MMX_CVTTPS2PIirr)>;
 524
 525 // Port0 and Port1
 526 def AtomWrite0_1_1 : SchedWriteRes<[AtomPort0, AtomPort1]> {
 527   let Latency = 1;
 528   let ResourceCycles = [1, 1];
 529 }
 530 def : InstRW<[AtomWrite0_1_1], (instrs POP32r, POP64r,
 531                                        POP16rmr, POP32rmr, POP64rmr,
 532                                        PUSH16r, PUSH32r, PUSH64r,
 533                                        PUSHi16, PUSHi32,
 534                                        PUSH16rmr, PUSH32rmr, PUSH64rmr,
 535                                        PUSH16i8, PUSH32i8, PUSH64i8, PUSH64i32,
 536                                        XCH_F)>;
 537 def : InstRW<[AtomWrite0_1_1], (instregex "RETI(L|Q|W)$",
 538                                           "IRET(16|32|64)?")>;
 539
 540 def AtomWrite0_1_5 : SchedWriteRes<[AtomPort0, AtomPort1]> {
 541   let Latency = 5;
 542   let ResourceCycles = [5, 5];
 543 }
 544 def : InstRW<[AtomWrite0_1_5], (instrs MMX_CVTPS2PIirm, MMX_CVTTPS2PIirm)>;
 545 def : InstRW<[AtomWrite0_1_5], (instregex "ILD_F(16|32|64)")>;
 546
 547 // Port0 or Port1
 548 def AtomWrite01_1 : SchedWriteRes<[AtomPort01]> {
 549   let Latency = 1;
 550   let ResourceCycles = [1];
 551 }
 552 def : InstRW<[AtomWrite01_1], (instrs FDECSTP, FFREE, FFREEP, FINCSTP, WAIT,
 553                                       LFENCE,
 554                                       STOSB, STOSL, STOSQ, STOSW,
 555                                       MOVSSrr, MOVSSrr_REV,
 556                                       PSLLDQri, PSRLDQri)>;
 557 def : InstRW<[AtomWrite01_1], (instregex "MMX_PACK(SSDW|SSWB|USWB)irr",
 558                                          "MMX_PUNPCKH(BW|DQ|WD)irr")>;
 559
 560 def AtomWrite01_2 : SchedWriteRes<[AtomPort01]> {
 561   let Latency = 2;
 562   let ResourceCycles = [2];
 563 }
 564 def : InstRW<[AtomWrite01_2], (instrs LEAVE, LEAVE64, POP16r,
 565                                       PUSH16rmm, PUSH32rmm, PUSH64rmm,
 566                                       LODSB, LODSL, LODSQ, LODSW,
 567                                       SCASB, SCASL, SCASQ, SCASW)>;
 568 def : InstRW<[AtomWrite01_2], (instregex "PUSH(CS|DS|ES|FS|GS|SS)(16|32|64)",
 569                                          "(ST|ISTT)_F(P)?(16|32|64)?(m|rr)",
 570                                          "MMX_P(ADD|SUB)Qirr",
 571                                          "MOV(S|Z)X16rr8",
 572                                          "MOV(UPS|UPD|DQU)mr",
 573                                          "MASKMOVDQU(64)?",
 574                                          "P(ADD|SUB)Qrr")>;
 575 def : SchedAlias<WriteBitTestSetImmRMW, AtomWrite01_2>;
 576
 577 def AtomWrite01_3 : SchedWriteRes<[AtomPort01]> {
 578   let Latency = 3;
 579   let ResourceCycles = [3];
 580 }
 581 def : InstRW<[AtomWrite01_3], (instrs CLD, LDDQUrm,
 582                                       CMPSB, CMPSL, CMPSQ, CMPSW,
 583                                       MOVSB, MOVSL, MOVSQ, MOVSW,
 584                                       POP16rmm, POP32rmm, POP64rmm)>;
 585 def : InstRW<[AtomWrite01_3], (instregex "XADD(8|16|32|64)rm",
 586                                          "XCHG(8|16|32|64)rm",
 587                                          "PH(ADD|SUB)Drr",
 588                                          "MOV(S|Z)X16rm8",
 589                                          "MMX_P(ADD|SUB)Qirm",
 590                                          "MOV(UPS|UPD|DQU)rm",
 591                                          "P(ADD|SUB)Qrm")>;
 592
 593 def AtomWrite01_4 : SchedWriteRes<[AtomPort01]> {
 594   let Latency = 4;
 595   let ResourceCycles = [4];
 596 }
 597 def : InstRW<[AtomWrite01_4], (instrs CBW, CWD, CWDE, CDQ, CDQE, CQO,
 598                                       JCXZ, JECXZ, JRCXZ,
 599                                       LD_F80m)>;
 600 def : InstRW<[AtomWrite01_4], (instregex "PH(ADD|SUB)Drm",
 601                                          "(MMX_)?PEXTRWrr(_REV)?")>;
 602
 603 def AtomWrite01_5 : SchedWriteRes<[AtomPort01]> {
 604   let Latency = 5;
 605   let ResourceCycles = [5];
 606 }
 607 def : InstRW<[AtomWrite01_5], (instrs FLDCW16m, ST_FP80m)>;
 608 def : InstRW<[AtomWrite01_5], (instregex "MMX_PH(ADD|SUB)S?Wrr")>;
 609
 610 def AtomWrite01_6 : SchedWriteRes<[AtomPort01]> {
 611   let Latency = 6;
 612   let ResourceCycles = [6];
 613 }
 614 def : InstRW<[AtomWrite01_6], (instrs CMPXCHG8rm, INTO, XLAT,
 615                                       SHLD16rrCL, SHRD16rrCL,
 616                                       SHLD16rri8, SHRD16rri8,
 617                                       SHLD16mrCL, SHRD16mrCL,
 618                                       SHLD16mri8, SHRD16mri8)>;
 619 def : InstRW<[AtomWrite01_6], (instregex "IST_F(P)?(16|32|64)?m",
 620                                          "MMX_PH(ADD|SUB)S?Wrm")>;
 621
 622 def AtomWrite01_7 : SchedWriteRes<[AtomPort01]> {
 623   let Latency = 7;
 624   let ResourceCycles = [7];
 625 }
 626 def : InstRW<[AtomWrite01_7], (instrs AAD8i8)>;
 627
 628 def AtomWrite01_8 : SchedWriteRes<[AtomPort01]> {
 629   let Latency = 8;
 630   let ResourceCycles = [8];
 631 }
 632 def : InstRW<[AtomWrite01_8], (instrs LOOPE,
 633                                       PUSHA16, PUSHA32,
 634                                       SHLD64rrCL, SHRD64rrCL,
 635                                       FNSTCW16m)>;
 636
 637 def AtomWrite01_9 : SchedWriteRes<[AtomPort01]> {
 638   let Latency = 9;
 639   let ResourceCycles = [9];
 640 }
 641 def : InstRW<[AtomWrite01_9], (instrs POPA16, POPA32,
 642                                       PUSHF16, PUSHF32, PUSHF64,
 643                                       SHLD64mrCL, SHRD64mrCL,
 644                                       SHLD64mri8, SHRD64mri8,
 645                                       SHLD64rri8, SHRD64rri8,
 646                                       CMPXCHG8rr)>;
 647 def : InstRW<[AtomWrite01_9], (instregex "(U)?COM_FI", "TST_F",
 648                                          "(U)?COMIS(D|S)rr",
 649                                          "CVT(T)?SS2SI64rr(_Int)?")>;
 650
 651 def AtomWrite01_10 : SchedWriteRes<[AtomPort01]> {
 652   let Latency = 10;
 653   let ResourceCycles = [10];
 654 }
 655 def : SchedAlias<WriteFLDC, AtomWrite01_10>;
 656 def : InstRW<[AtomWrite01_10], (instregex "(U)?COMIS(D|S)rm",
 657                                           "CVT(T)?SS2SI64rm(_Int)?")>;
 658
 659 def AtomWrite01_11 : SchedWriteRes<[AtomPort01]> {
 660   let Latency = 11;
 661   let ResourceCycles = [11];
 662 }
 663 def : InstRW<[AtomWrite01_11], (instrs BOUNDS16rm, BOUNDS32rm)>;
 664 def : SchedAlias<WriteBitTestSetRegRMW, AtomWrite01_11>;
 665
 666 def AtomWrite01_13 : SchedWriteRes<[AtomPort01]> {
 667   let Latency = 13;
 668   let ResourceCycles = [13];
 669 }
 670 def : InstRW<[AtomWrite01_13], (instrs AAA, AAS)>;
 671
 672 def AtomWrite01_14 : SchedWriteRes<[AtomPort01]> {
 673   let Latency = 14;
 674   let ResourceCycles = [14];
 675 }
 676 def : InstRW<[AtomWrite01_14], (instrs CMPXCHG16rm, CMPXCHG32rm, CMPXCHG64rm)>;
 677
 678 def AtomWrite01_17 : SchedWriteRes<[AtomPort01]> {
 679   let Latency = 17;
 680   let ResourceCycles = [17];
 681 }
 682 def : InstRW<[AtomWrite01_17], (instrs LOOPNE, PAUSE)>;
 683
 684 def AtomWrite01_18 : SchedWriteRes<[AtomPort01]> {
 685   let Latency = 18;
 686   let ResourceCycles = [18];
 687 }
 688 def : InstRW<[AtomWrite01_18], (instrs CMPXCHG8B, DAA, LOOP)>;
 689
 690 def AtomWrite01_20 : SchedWriteRes<[AtomPort01]> {
 691   let Latency = 20;
 692   let ResourceCycles = [20];
 693 }
 694 def : InstRW<[AtomWrite01_20], (instrs DAS)>;
 695
 696 def AtomWrite01_21 : SchedWriteRes<[AtomPort01]> {
 697   let Latency = 21;
 698   let ResourceCycles = [21];
 699 }
 700 def : InstRW<[AtomWrite01_21], (instrs AAM8i8, STD)>;
 701
 702 def AtomWrite01_22 : SchedWriteRes<[AtomPort01]> {
 703   let Latency = 22;
 704   let ResourceCycles = [22];
 705 }
 706 def : InstRW<[AtomWrite01_22], (instrs CMPXCHG16B)>;
 707
 708 def AtomWrite01_23 : SchedWriteRes<[AtomPort01]> {
 709   let Latency = 23;
 710   let ResourceCycles = [23];
 711 }
 712 def : InstRW<[AtomWrite01_23], (instrs ARPL16mr, ARPL16rr)>;
 713
 714 def AtomWrite01_25 : SchedWriteRes<[AtomPort01]> {
 715   let Latency = 25;
 716   let ResourceCycles = [25];
 717 }
 718 def : InstRW<[AtomWrite01_25], (instrs FNCLEX, FXTRACT)>;
 719
 720 def AtomWrite01_26 : SchedWriteRes<[AtomPort01]> {
 721   let Latency = 26;
 722   let ResourceCycles = [26];
 723 }
 724 def : InstRW<[AtomWrite01_26], (instrs POPF32, POPF64)>;
 725
 726 def AtomWrite01_29 : SchedWriteRes<[AtomPort01]> {
 727   let Latency = 29;
 728   let ResourceCycles = [29];
 729 }
 730 def : InstRW<[AtomWrite01_29], (instregex "POP(DS|ES|FS|GS)(16|32|64)")>;
 731
 732 def AtomWrite01_30 : SchedWriteRes<[AtomPort01]> {
 733   let Latency = 30;
 734   let ResourceCycles = [30];
 735 }
 736 def : InstRW<[AtomWrite01_30], (instrs RDTSC, RDTSCP)>;
 737
 738 def AtomWrite01_32 : SchedWriteRes<[AtomPort01]> {
 739   let Latency = 32;
 740   let ResourceCycles = [32];
 741 }
 742 def : InstRW<[AtomWrite01_32], (instrs ENTER, POPF16)>;
 743
 744 def AtomWrite01_45 : SchedWriteRes<[AtomPort01]> {
 745   let Latency = 45;
 746   let ResourceCycles = [45];
 747 }
 748 def : InstRW<[AtomWrite01_45], (instrs MONITOR32rrr, MONITOR64rrr)>;
 749
 750 def AtomWrite01_46 : SchedWriteRes<[AtomPort01]> {
 751   let Latency = 46;
 752   let ResourceCycles = [46];
 753 }
 754 def : InstRW<[AtomWrite01_46], (instrs FRNDINT, MWAITrr, RDPMC)>;
 755
 756 def AtomWrite01_48 : SchedWriteRes<[AtomPort01]> {
 757   let Latency = 48;
 758   let ResourceCycles = [48];
 759 }
 760 def : InstRW<[AtomWrite01_48], (instrs POPSS16, POPSS32)>;
 761
 762 def AtomWrite01_55 : SchedWriteRes<[AtomPort01]> {
 763   let Latency = 55;
 764   let ResourceCycles = [55];
 765 }
 766 def : InstRW<[AtomWrite01_55], (instrs FPREM)>;
 767
 768 def AtomWrite01_59 : SchedWriteRes<[AtomPort01]> {
 769   let Latency = 59;
 770   let ResourceCycles = [59];
 771 }
 772 def : InstRW<[AtomWrite01_59], (instrs INSB, INSL, INSW)>;
 773
 774 def AtomWrite01_63 : SchedWriteRes<[AtomPort01]> {
 775   let Latency = 63;
 776   let ResourceCycles = [63];
 777 }
 778 def : InstRW<[AtomWrite01_63], (instrs FNINIT)>;
 779
 780 def AtomWrite01_68 : SchedWriteRes<[AtomPort01]> {
 781   let Latency = 68;
 782   let ResourceCycles = [68];
 783 }
 784 def : InstRW<[AtomWrite01_68], (instrs OUT8rr, OUT16rr, OUT32rr)>;
 785
 786 def AtomWrite01_71 : SchedWriteRes<[AtomPort01]> {
 787   let Latency = 71;
 788   let ResourceCycles = [71];
 789 }
 790 def : InstRW<[AtomWrite01_71], (instrs FPREM1,
 791                                        INVLPG, INVLPGA32, INVLPGA64)>;
 792
 793 def AtomWrite01_72 : SchedWriteRes<[AtomPort01]> {
 794   let Latency = 72;
 795   let ResourceCycles = [72];
 796 }
 797 def : InstRW<[AtomWrite01_72], (instrs OUT8ir, OUT16ir, OUT32ir)>;
 798
 799 def AtomWrite01_74 : SchedWriteRes<[AtomPort01]> {
 800   let Latency = 74;
 801   let ResourceCycles = [74];
 802 }
 803 def : InstRW<[AtomWrite01_74], (instrs OUTSB, OUTSL, OUTSW)>;
 804
 805 def AtomWrite01_77 : SchedWriteRes<[AtomPort01]> {
 806   let Latency = 77;
 807   let ResourceCycles = [77];
 808 }
 809 def : InstRW<[AtomWrite01_77], (instrs FSCALE)>;
 810
 811 def AtomWrite01_78 : SchedWriteRes<[AtomPort01]> {
 812   let Latency = 78;
 813   let ResourceCycles = [78];
 814 }
 815 def : InstRW<[AtomWrite01_78], (instrs RDMSR)>;
 816
 817 def AtomWrite01_79 : SchedWriteRes<[AtomPort01]> {
 818   let Latency = 79;
 819   let ResourceCycles = [79];
 820 }
 821 def : InstRW<[AtomWrite01_79], (instregex "RET(L|Q|W)?$",
 822                                           "LRETI?(L|Q|W)")>;
 823
 824 def AtomWrite01_92 : SchedWriteRes<[AtomPort01]> {
 825   let Latency = 92;
 826   let ResourceCycles = [92];
 827 }
 828 def : InstRW<[AtomWrite01_92], (instrs IN8ri, IN16ri, IN32ri)>;
 829
 830 def AtomWrite01_94 : SchedWriteRes<[AtomPort01]> {
 831   let Latency = 94;
 832   let ResourceCycles = [94];
 833 }
 834 def : InstRW<[AtomWrite01_94], (instrs IN8rr, IN16rr, IN32rr)>;
 835
 836 def AtomWrite01_99 : SchedWriteRes<[AtomPort01]> {
 837   let Latency = 99;
 838   let ResourceCycles = [99];
 839 }
 840 def : InstRW<[AtomWrite01_99], (instrs F2XM1)>;
 841
 842 def AtomWrite01_121 : SchedWriteRes<[AtomPort01]> {
 843   let Latency = 121;
 844   let ResourceCycles = [121];
 845 }
 846 def : InstRW<[AtomWrite01_121], (instrs CPUID)>;
 847
 848 def AtomWrite01_127 : SchedWriteRes<[AtomPort01]> {
 849   let Latency = 127;
 850   let ResourceCycles = [127];
 851 }
 852 def : InstRW<[AtomWrite01_127], (instrs INT)>;
 853
 854 def AtomWrite01_130 : SchedWriteRes<[AtomPort01]> {
 855   let Latency = 130;
 856   let ResourceCycles = [130];
 857 }
 858 def : InstRW<[AtomWrite01_130], (instrs INT3)>;
 859
 860 def AtomWrite01_140 : SchedWriteRes<[AtomPort01]> {
 861   let Latency = 140;
 862   let ResourceCycles = [140];
 863 }
 864 def : InstRW<[AtomWrite01_140], (instrs FXSAVE, FXSAVE64)>;
 865
 866 def AtomWrite01_141 : SchedWriteRes<[AtomPort01]> {
 867   let Latency = 141;
 868   let ResourceCycles = [141];
 869 }
 870 def : InstRW<[AtomWrite01_141], (instrs FXRSTOR, FXRSTOR64)>;
 871
 872 def AtomWrite01_146 : SchedWriteRes<[AtomPort01]> {
 873   let Latency = 146;
 874   let ResourceCycles = [146];
 875 }
 876 def : InstRW<[AtomWrite01_146], (instrs FYL2X)>;
 877
 878 def AtomWrite01_147 : SchedWriteRes<[AtomPort01]> {
 879   let Latency = 147;
 880   let ResourceCycles = [147];
 881 }
 882 def : InstRW<[AtomWrite01_147], (instrs FYL2XP1)>;
 883
 884 def AtomWrite01_168 : SchedWriteRes<[AtomPort01]> {
 885   let Latency = 168;
 886   let ResourceCycles = [168];
 887 }
 888 def : InstRW<[AtomWrite01_168], (instrs FPTAN)>;
 889
 890 def AtomWrite01_174 : SchedWriteRes<[AtomPort01]> {
 891   let Latency = 174;
 892   let ResourceCycles = [174];
 893 }
 894 def : InstRW<[AtomWrite01_174], (instrs FSINCOS, FSIN, FCOS)>;
 895
 896 def AtomWrite01_183 : SchedWriteRes<[AtomPort01]> {
 897   let Latency = 183;
 898   let ResourceCycles = [183];
 899 }
 900 def : InstRW<[AtomWrite01_183], (instrs FPATAN)>;
 901
 902 def AtomWrite01_202 : SchedWriteRes<[AtomPort01]> {
 903   let Latency = 202;
 904   let ResourceCycles = [202];
 905 }
 906 def : InstRW<[AtomWrite01_202], (instrs WRMSR)>;
 907
 908 } // SchedModel