contrib/llvm-project/llvm/lib/Target/PowerPC/P9InstrResources.td

   1 //===- P9InstrResources.td - P9 Instruction Resource Defs  -*- 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 resources required by P9 instructions. This is part of
  10 // the P9 processor model used for instruction scheduling. This file should
  11 // contain all the instructions that may be used on Power 9. This is not
  12 // just instructions that are new on Power 9 but also instructions that were
  13 // available on earlier architectures and are still used in Power 9.
  14 //
  15 // The makeup of the P9 CPU is modeled as follows:
  16 //   - Each CPU is made up of two superslices.
  17 //   - Each superslice is made up of two slices. Therefore, there are 4 slices
  18 //   for each CPU.
  19 //   - Up to 6 instructions can be dispatched to each CPU. Three per superslice.
  20 //   - Each CPU has:
  21 //     - One CY (Crypto) unit P9_CY_*
  22 //     - One DFU (Decimal Floating Point and Quad Precision) unit P9_DFU_*
  23 //     - Two PM (Permute) units. One on each superslice. P9_PM_*
  24 //     - Two DIV (Fixed Point Divide) units. One on each superslize. P9_DIV_*
  25 //     - Four ALU (Fixed Point Arithmetic) units. One on each slice. P9_ALU_*
  26 //     - Four DP (Floating Point) units. One on each slice. P9_DP_*
  27 //       This also includes fixed point multiply add.
  28 //     - Four AGEN (Address Generation) units. One for each slice. P9_AGEN_*
  29 //     - Four Load/Store Queues. P9_LS_*
  30 //   - Each set of instructions will require a number of these resources.
  31 //===----------------------------------------------------------------------===//
  32
  33 // Two cycle ALU vector operation that uses an entire superslice.
  34 // Uses both ALU units (the even ALUE and odd ALUO units), two pipelines
  35 // (EXECE, EXECO) and 1 dispatch (DISP) to the given superslice.
  36 def : InstRW<[P9_ALUE_2C, P9_ALUO_2C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
  37       (instrs
  38     (instregex "VADDU(B|H|W|D)M$"),
  39     (instregex "VAND(C)?$"),
  40     (instregex "VEXTS(B|H|W)2(D|W)(s)?$"),
  41     (instregex "V_SET0(B|H)?$"),
  42     (instregex "VS(R|L)(B|H|W|D)$"),
  43     (instregex "VSUBU(B|H|W|D)M$"),
  44     (instregex "VPOPCNT(B|H)$"),
  45     (instregex "VRL(B|H|W|D)$"),
  46     (instregex "VSRA(B|H|W|D)$"),
  47     (instregex "XV(N)?ABS(D|S)P$"),
  48     (instregex "XVCPSGN(D|S)P$"),
  49     (instregex "XV(I|X)EXP(D|S)P$"),
  50     (instregex "VRL(D|W)(MI|NM)$"),
  51     (instregex "VMRG(E|O)W$"),
  52     MTVSRDD,
  53     VEQV,
  54     VNAND,
  55     VNEGD,
  56     VNEGW,
  57     VNOR,
  58     VOR,
  59     VORC,
  60     VSEL,
  61     VXOR,
  62     XVNEGDP,
  63     XVNEGSP,
  64     XXLAND,
  65     XXLANDC,
  66     XXLEQV,
  67     XXLEQVOnes,
  68     XXLNAND,
  69     XXLNOR,
  70     XXLOR,
  71     XXLORf,
  72     XXLORC,
  73     XXLXOR,
  74     XXLXORdpz,
  75     XXLXORspz,
  76     XXLXORz,
  77     XXSEL,
  78     XSABSQP,
  79     XSCPSGNQP,
  80     XSIEXPQP,
  81     XSNABSQP,
  82     XSNEGQP,
  83     XSXEXPQP
  84 )>;
  85
  86 // Restricted Dispatch ALU operation for 3 cycles. The operation runs on a
  87 // single slice. However, since it is Restricted, it requires all 3 dispatches
  88 // (DISP) for that superslice.
  89 def : InstRW<[P9_ALU_3C, IP_EXEC_1C, DISP_3SLOTS_1C],
  90       (instrs
  91     (instregex "TABORT(D|W)C(I)?$"),
  92     (instregex "MTFSB(0|1)$"),
  93     (instregex "MFFSC(D)?RN(I)?$"),
  94     (instregex "CMPRB(8)?$"),
  95     (instregex "TD(I)?$"),
  96     (instregex "TW(I)?$"),
  97     (instregex "FCMPU(S|D)$"),
  98     (instregex "XSTSTDC(S|D)P$"),
  99     FTDIV,
 100     FTSQRT,
 101     CMPEQB
 102 )>;
 103
 104 // Standard Dispatch ALU operation for 3 cycles. Only one slice used.
 105 def : InstRW<[P9_ALU_3C, IP_EXEC_1C, DISP_1C],
 106       (instrs
 107     (instregex "XSMAX(C|J)?DP$"),
 108     (instregex "XSMIN(C|J)?DP$"),
 109     (instregex "XSCMP(EQ|EXP|GE|GT|O|U)DP$"),
 110     (instregex "CNT(L|T)Z(D|W)(8)?(_rec)?$"),
 111     (instregex "POPCNT(D|W)$"),
 112     (instregex "CMPB(8)?$"),
 113     (instregex "SETB(8)?$"),
 114     XSTDIVDP,
 115     XSTSQRTDP,
 116     XSXSIGDP,
 117     XSCVSPDPN,
 118     BPERMD
 119 )>;
 120
 121 // Standard Dispatch ALU operation for 2 cycles. Only one slice used.
 122 def : InstRW<[P9_ALU_2C, IP_EXEC_1C, DISP_1C],
 123       (instrs
 124     (instregex "S(L|R)D$"),
 125     (instregex "SRAD(I)?$"),
 126     (instregex "EXTSWSLI_32_64$"),
 127     (instregex "MFV(S)?RD$"),
 128     (instregex "MTV(S)?RD$"),
 129     (instregex "MTV(S)?RW(A|Z)$"),
 130     (instregex "CMP(WI|LWI|W|LW)(8)?$"),
 131     (instregex "CMP(L)?D(I)?$"),
 132     (instregex "SUBF(I)?C(8)?(O)?$"),
 133     (instregex "ANDI(S)?(8)?(_rec)?$"),
 134     (instregex "ADDC(8)?(O)?$"),
 135     (instregex "ADDIC(8)?(_rec)?$"),
 136     (instregex "ADD(8|4)(O)?(_rec)?$"),
 137     (instregex "ADD(E|ME|ZE)(8)?(O)?(_rec)?$"),
 138     (instregex "SUBF(E|ME|ZE)?(8)?(O)?(_rec)?$"),
 139     (instregex "NEG(8)?(O)?(_rec)?$"),
 140     (instregex "POPCNTB$"),
 141     (instregex "ADD(I|IS)?(8)?$"),
 142     (instregex "LI(S)?(8)?$"),
 143     (instregex "(X)?OR(I|IS)?(8)?(_rec)?$"),
 144     (instregex "NAND(8)?(_rec)?$"),
 145     (instregex "AND(C)?(8)?(_rec)?$"),
 146     (instregex "NOR(8)?(_rec)?$"),
 147     (instregex "OR(C)?(8)?(_rec)?$"),
 148     (instregex "EQV(8)?(_rec)?$"),
 149     (instregex "EXTS(B|H|W)(8)?(_32)?(_64)?(_rec)?$"),
 150     (instregex "ADD(4|8)(TLS)?(_)?$"),
 151     (instregex "NEG(8)?(O)?$"),
 152     (instregex "ADDI(S)?toc(HA|L)(8)?$"),
 153     COPY,
 154     MCRF,
 155     MCRXRX,
 156     XSNABSDP,
 157     XSXEXPDP,
 158     XSABSDP,
 159     XSNEGDP,
 160     XSCPSGNDP,
 161     MFVSRWZ,
 162     MFVRWZ,
 163     EXTSWSLI,
 164     SRADI_32,
 165     RLDIC,
 166     RFEBB,
 167     LA,
 168     TBEGIN,
 169     TRECHKPT,
 170     NOP,
 171     WAIT
 172 )>;
 173
 174 // Restricted Dispatch ALU operation for 2 cycles. The operation runs on a
 175 // single slice. However, since it is Restricted, it requires all 3 dispatches
 176 // (DISP) for that superslice.
 177 def : InstRW<[P9_ALU_2C, IP_EXEC_1C, DISP_3SLOTS_1C],
 178       (instrs
 179     (instregex "RLDC(L|R)$"),
 180     (instregex "RLWIMI(8)?$"),
 181     (instregex "RLDIC(L|R)(_32)?(_64)?$"),
 182     (instregex "M(F|T)OCRF(8)?$"),
 183     (instregex "CR(6)?(UN)?SET$"),
 184     (instregex "CR(N)?(OR|AND)(C)?$"),
 185     (instregex "S(L|R)W(8)?$"),
 186     (instregex "RLW(INM|NM)(8)?$"),
 187     (instregex "F(N)?ABS(D|S)$"),
 188     (instregex "FNEG(D|S)$"),
 189     (instregex "FCPSGN(D|S)$"),
 190     (instregex "SRAW(I)?$"),
 191     (instregex "ISEL(8)?$"),
 192     RLDIMI,
 193     XSIEXPDP,
 194     FMR,
 195     CREQV,
 196     CRXOR,
 197     TRECLAIM,
 198     TSR,
 199     TABORT
 200 )>;
 201
 202 // Three cycle ALU vector operation that uses an entire superslice.
 203 // Uses both ALU units (the even ALUE and odd ALUO units), two pipelines
 204 // (EXECE, EXECO) and 1 dispatch (DISP) to the given superslice.
 205 def : InstRW<[P9_ALUE_3C, P9_ALUO_3C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 206       (instrs
 207     (instregex "M(T|F)VSCR$"),
 208     (instregex "VCMPNEZ(B|H|W)$"),
 209     (instregex "VCMPEQU(B|H|W|D)$"),
 210     (instregex "VCMPNE(B|H|W)$"),
 211     (instregex "VABSDU(B|H|W)$"),
 212     (instregex "VADDU(B|H|W)S$"),
 213     (instregex "VAVG(S|U)(B|H|W)$"),
 214     (instregex "VCMP(EQ|GE|GT)FP(_rec)?$"),
 215     (instregex "VCMPBFP(_rec)?$"),
 216     (instregex "VC(L|T)Z(B|H|W|D)$"),
 217     (instregex "VADDS(B|H|W)S$"),
 218     (instregex "V(MIN|MAX)FP$"),
 219     (instregex "V(MIN|MAX)(S|U)(B|H|W|D)$"),
 220     VBPERMD,
 221     VADDCUW,
 222     VPOPCNTW,
 223     VPOPCNTD,
 224     VPRTYBD,
 225     VPRTYBW,
 226     VSHASIGMAD,
 227     VSHASIGMAW,
 228     VSUBSBS,
 229     VSUBSHS,
 230     VSUBSWS,
 231     VSUBUBS,
 232     VSUBUHS,
 233     VSUBUWS,
 234     VSUBCUW,
 235     VCMPGTSB,
 236     VCMPGTSB_rec,
 237     VCMPGTSD,
 238     VCMPGTSD_rec,
 239     VCMPGTSH,
 240     VCMPGTSH_rec,
 241     VCMPGTSW,
 242     VCMPGTSW_rec,
 243     VCMPGTUB,
 244     VCMPGTUB_rec,
 245     VCMPGTUD,
 246     VCMPGTUD_rec,
 247     VCMPGTUH,
 248     VCMPGTUH_rec,
 249     VCMPGTUW,
 250     VCMPGTUW_rec,
 251     VCMPNEB_rec,
 252     VCMPNEH_rec,
 253     VCMPNEW_rec,
 254     VCMPNEZB_rec,
 255     VCMPNEZH_rec,
 256     VCMPNEZW_rec,
 257     VCMPEQUB_rec,
 258     VCMPEQUD_rec,
 259     VCMPEQUH_rec,
 260     VCMPEQUW_rec,
 261     XVCMPEQDP,
 262     XVCMPEQDP_rec,
 263     XVCMPEQSP,
 264     XVCMPEQSP_rec,
 265     XVCMPGEDP,
 266     XVCMPGEDP_rec,
 267     XVCMPGESP,
 268     XVCMPGESP_rec,
 269     XVCMPGTDP,
 270     XVCMPGTDP_rec,
 271     XVCMPGTSP,
 272     XVCMPGTSP_rec,
 273     XVMAXDP,
 274     XVMAXSP,
 275     XVMINDP,
 276     XVMINSP,
 277     XVTDIVDP,
 278     XVTDIVSP,
 279     XVTSQRTDP,
 280     XVTSQRTSP,
 281     XVTSTDCDP,
 282     XVTSTDCSP,
 283     XVXSIGDP,
 284     XVXSIGSP
 285 )>;
 286
 287 // 7 cycle DP vector operation that uses an entire superslice.
 288 // Uses both DP units (the even DPE and odd DPO units), two pipelines (EXECE,
 289 // EXECO) and all three dispatches (DISP) to the given superslice.
 290 def : InstRW<[P9_DPE_7C, P9_DPO_7C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 291       (instrs
 292     VADDFP,
 293     VCTSXS,
 294     VCTSXS_0,
 295     VCTUXS,
 296     VCTUXS_0,
 297     VEXPTEFP,
 298     VLOGEFP,
 299     VMADDFP,
 300     VMHADDSHS,
 301     VNMSUBFP,
 302     VREFP,
 303     VRFIM,
 304     VRFIN,
 305     VRFIP,
 306     VRFIZ,
 307     VRSQRTEFP,
 308     VSUBFP,
 309     XVADDDP,
 310     XVADDSP,
 311     XVCVDPSP,
 312     XVCVDPSXDS,
 313     XVCVDPSXWS,
 314     XVCVDPUXDS,
 315     XVCVDPUXWS,
 316     XVCVHPSP,
 317     XVCVSPDP,
 318     XVCVSPHP,
 319     XVCVSPSXDS,
 320     XVCVSPSXWS,
 321     XVCVSPUXDS,
 322     XVCVSPUXWS,
 323     XVCVSXDDP,
 324     XVCVSXDSP,
 325     XVCVSXWDP,
 326     XVCVSXWSP,
 327     XVCVUXDDP,
 328     XVCVUXDSP,
 329     XVCVUXWDP,
 330     XVCVUXWSP,
 331     XVMADDADP,
 332     XVMADDASP,
 333     XVMADDMDP,
 334     XVMADDMSP,
 335     XVMSUBADP,
 336     XVMSUBASP,
 337     XVMSUBMDP,
 338     XVMSUBMSP,
 339     XVMULDP,
 340     XVMULSP,
 341     XVNMADDADP,
 342     XVNMADDASP,
 343     XVNMADDMDP,
 344     XVNMADDMSP,
 345     XVNMSUBADP,
 346     XVNMSUBASP,
 347     XVNMSUBMDP,
 348     XVNMSUBMSP,
 349     XVRDPI,
 350     XVRDPIC,
 351     XVRDPIM,
 352     XVRDPIP,
 353     XVRDPIZ,
 354     XVREDP,
 355     XVRESP,
 356     XVRSPI,
 357     XVRSPIC,
 358     XVRSPIM,
 359     XVRSPIP,
 360     XVRSPIZ,
 361     XVRSQRTEDP,
 362     XVRSQRTESP,
 363     XVSUBDP,
 364     XVSUBSP,
 365     VCFSX,
 366     VCFSX_0,
 367     VCFUX,
 368     VCFUX_0,
 369     VMHRADDSHS,
 370     VMLADDUHM,
 371     VMSUMMBM,
 372     VMSUMSHM,
 373     VMSUMSHS,
 374     VMSUMUBM,
 375     VMSUMUHM,
 376     VMSUMUDM,
 377     VMSUMUHS,
 378     VMULESB,
 379     VMULESH,
 380     VMULESW,
 381     VMULEUB,
 382     VMULEUH,
 383     VMULEUW,
 384     VMULOSB,
 385     VMULOSH,
 386     VMULOSW,
 387     VMULOUB,
 388     VMULOUH,
 389     VMULOUW,
 390     VMULUWM,
 391     VSUM2SWS,
 392     VSUM4SBS,
 393     VSUM4SHS,
 394     VSUM4UBS,
 395     VSUMSWS
 396 )>;
 397
 398 // 5 cycle Restricted DP operation. One DP unit, one EXEC pipeline and all three
 399 // dispatch units for the superslice.
 400 def : InstRW<[P9_DP_5C, IP_EXEC_1C, DISP_3SLOTS_1C],
 401       (instrs
 402     (instregex "MADD(HD|HDU|LD|LD8)$"),
 403     (instregex "MUL(HD|HW|LD|LI|LI8|LW)(U)?(O)?$")
 404 )>;
 405
 406 // 7 cycle Restricted DP operation. One DP unit, one EXEC pipeline and all three
 407 // dispatch units for the superslice.
 408 def : InstRW<[P9_DP_7C, IP_EXEC_1C, DISP_3SLOTS_1C],
 409       (instrs
 410     FRSP,
 411     (instregex "FRI(N|P|Z|M)(D|S)$"),
 412     (instregex "FRE(S)?$"),
 413     (instregex "FADD(S)?$"),
 414     (instregex "FMSUB(S)?$"),
 415     (instregex "FMADD(S)?$"),
 416     (instregex "FSUB(S)?$"),
 417     (instregex "FCFID(U)?(S)?$"),
 418     (instregex "FCTID(U)?(Z)?$"),
 419     (instregex "FCTIW(U)?(Z)?$"),
 420     (instregex "FRSQRTE(S)?$"),
 421     FNMADDS,
 422     FNMADD,
 423     FNMSUBS,
 424     FNMSUB,
 425     FSELD,
 426     FSELS,
 427     FMULS,
 428     FMUL,
 429     XSMADDADP,
 430     XSMADDASP,
 431     XSMADDMDP,
 432     XSMADDMSP,
 433     XSMSUBADP,
 434     XSMSUBASP,
 435     XSMSUBMDP,
 436     XSMSUBMSP,
 437     XSMULDP,
 438     XSMULSP,
 439     XSNMADDADP,
 440     XSNMADDASP,
 441     XSNMADDMDP,
 442     XSNMADDMSP,
 443     XSNMSUBADP,
 444     XSNMSUBASP,
 445     XSNMSUBMDP,
 446     XSNMSUBMSP
 447 )>;
 448
 449 // 7 cycle Restricted DP operation and one 3 cycle ALU operation.
 450 // These operations can be done in parallel. The DP is restricted so we need a
 451 // full 4 dispatches.
 452 def : InstRW<[P9_DP_7C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
 453               DISP_3SLOTS_1C, DISP_1C],
 454       (instrs
 455     (instregex "FSEL(D|S)_rec$")
 456 )>;
 457
 458 // 5 Cycle Restricted DP operation and one 2 cycle ALU operation.
 459 def : InstRW<[P9_DPOpAndALUOp_7C, IP_EXEC_1C, IP_EXEC_1C,
 460               DISP_3SLOTS_1C, DISP_1C],
 461       (instrs
 462     (instregex "MUL(H|L)(D|W)(U)?(O)?_rec$")
 463 )>;
 464
 465 // 7 cycle Restricted DP operation and one 3 cycle ALU operation.
 466 // These operations must be done sequentially.The DP is restricted so we need a
 467 // full 4 dispatches.
 468 def : InstRW<[P9_DPOpAndALU2Op_10C, IP_EXEC_1C, IP_EXEC_1C,
 469               DISP_3SLOTS_1C, DISP_1C],
 470       (instrs
 471     (instregex "FRI(N|P|Z|M)(D|S)_rec$"),
 472     (instregex "FRE(S)?_rec$"),
 473     (instregex "FADD(S)?_rec$"),
 474     (instregex "FSUB(S)?_rec$"),
 475     (instregex "F(N)?MSUB(S)?_rec$"),
 476     (instregex "F(N)?MADD(S)?_rec$"),
 477     (instregex "FCFID(U)?(S)?_rec$"),
 478     (instregex "FCTID(U)?(Z)?_rec$"),
 479     (instregex "FCTIW(U)?(Z)?_rec$"),
 480     (instregex "FMUL(S)?_rec$"),
 481     (instregex "FRSQRTE(S)?_rec$"),
 482     FRSP_rec
 483 )>;
 484
 485 // 7 cycle DP operation. One DP unit, one EXEC pipeline and 1 dispatch units.
 486 def : InstRW<[P9_DP_7C, IP_EXEC_1C, DISP_1C],
 487       (instrs
 488     XSADDDP,
 489     XSADDSP,
 490     XSCVDPHP,
 491     XSCVDPSP,
 492     XSCVDPSXDS,
 493     XSCVDPSXDSs,
 494     XSCVDPSXWS,
 495     XSCVDPUXDS,
 496     XSCVDPUXDSs,
 497     XSCVDPUXWS,
 498     XSCVDPSXWSs,
 499     XSCVDPUXWSs,
 500     XSCVHPDP,
 501     XSCVSPDP,
 502     XSCVSXDDP,
 503     XSCVSXDSP,
 504     XSCVUXDDP,
 505     XSCVUXDSP,
 506     XSRDPI,
 507     XSRDPIC,
 508     XSRDPIM,
 509     XSRDPIP,
 510     XSRDPIZ,
 511     XSREDP,
 512     XSRESP,
 513     XSRSQRTEDP,
 514     XSRSQRTESP,
 515     XSSUBDP,
 516     XSSUBSP,
 517     XSCVDPSPN,
 518     XSRSP
 519 )>;
 520
 521 // Three Cycle PM operation. Only one PM unit per superslice so we use the whole
 522 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 523 // dispatch.
 524 def : InstRW<[P9_PM_3C, IP_EXECO_1C, IP_EXECE_1C, DISP_1C],
 525       (instrs
 526     (instregex "LVS(L|R)$"),
 527     (instregex "VSPLTIS(W|H|B)$"),
 528     (instregex "VSPLT(W|H|B)(s)?$"),
 529     (instregex "V_SETALLONES(B|H)?$"),
 530     (instregex "VEXTRACTU(B|H|W)$"),
 531     (instregex "VINSERT(B|H|W|D)$"),
 532     MFVSRLD,
 533     MTVSRWS,
 534     VBPERMQ,
 535     VCLZLSBB,
 536     VCTZLSBB,
 537     VEXTRACTD,
 538     VEXTUBLX,
 539     VEXTUBRX,
 540     VEXTUHLX,
 541     VEXTUHRX,
 542     VEXTUWLX,
 543     VEXTUWRX,
 544     VGBBD,
 545     VMRGHB,
 546     VMRGHH,
 547     VMRGHW,
 548     VMRGLB,
 549     VMRGLH,
 550     VMRGLW,
 551     VPERM,
 552     VPERMR,
 553     VPERMXOR,
 554     VPKPX,
 555     VPKSDSS,
 556     VPKSDUS,
 557     VPKSHSS,
 558     VPKSHUS,
 559     VPKSWSS,
 560     VPKSWUS,
 561     VPKUDUM,
 562     VPKUDUS,
 563     VPKUHUM,
 564     VPKUHUS,
 565     VPKUWUM,
 566     VPKUWUS,
 567     VPRTYBQ,
 568     VSL,
 569     VSLDOI,
 570     VSLO,
 571     VSLV,
 572     VSR,
 573     VSRO,
 574     VSRV,
 575     VUPKHPX,
 576     VUPKHSB,
 577     VUPKHSH,
 578     VUPKHSW,
 579     VUPKLPX,
 580     VUPKLSB,
 581     VUPKLSH,
 582     VUPKLSW,
 583     XXBRD,
 584     XXBRH,
 585     XXBRQ,
 586     XXBRW,
 587     XXEXTRACTUW,
 588     XXINSERTW,
 589     XXMRGHW,
 590     XXMRGLW,
 591     XXPERM,
 592     XXPERMR,
 593     XXSLDWI,
 594     XXSLDWIs,
 595     XXSPLTIB,
 596     XXSPLTW,
 597     XXSPLTWs,
 598     XXPERMDI,
 599     XXPERMDIs,
 600     VADDCUQ,
 601     VADDECUQ,
 602     VADDEUQM,
 603     VADDUQM,
 604     VMUL10CUQ,
 605     VMUL10ECUQ,
 606     VMUL10EUQ,
 607     VMUL10UQ,
 608     VSUBCUQ,
 609     VSUBECUQ,
 610     VSUBEUQM,
 611     VSUBUQM,
 612     XSCMPEXPQP,
 613     XSCMPOQP,
 614     XSCMPUQP,
 615     XSTSTDCQP,
 616     XSXSIGQP,
 617     BCDCFN_rec,
 618     BCDCFZ_rec,
 619     BCDCPSGN_rec,
 620     BCDCTN_rec,
 621     BCDCTZ_rec,
 622     BCDSETSGN_rec,
 623     BCDS_rec,
 624     BCDTRUNC_rec,
 625     BCDUS_rec,
 626     BCDUTRUNC_rec
 627 )>;
 628
 629 // 12 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 630 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 631 // dispatch.
 632 def : InstRW<[P9_DFU_12C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 633       (instrs
 634     BCDSR_rec,
 635     XSADDQP,
 636     XSADDQPO,
 637     XSCVDPQP,
 638     XSCVQPDP,
 639     XSCVQPDPO,
 640     XSCVQPSDZ,
 641     XSCVQPSWZ,
 642     XSCVQPUDZ,
 643     XSCVQPUWZ,
 644     XSCVSDQP,
 645     XSCVUDQP,
 646     XSRQPI,
 647     XSRQPIX,
 648     XSRQPXP,
 649     XSSUBQP,
 650     XSSUBQPO
 651 )>;
 652
 653 // 23 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 654 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 655 // dispatch.
 656 def : InstRW<[P9_DFU_23C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 657       (instrs
 658     BCDCTSQ_rec
 659 )>;
 660
 661 // 24 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 662 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 663 // dispatch.
 664 def : InstRW<[P9_DFU_24C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 665       (instrs
 666     XSMADDQP,
 667     XSMADDQPO,
 668     XSMSUBQP,
 669     XSMSUBQPO,
 670     XSMULQP,
 671     XSMULQPO,
 672     XSNMADDQP,
 673     XSNMADDQPO,
 674     XSNMSUBQP,
 675     XSNMSUBQPO
 676 )>;
 677
 678 // 37 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 679 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 680 // dispatch.
 681 def : InstRW<[P9_DFU_37C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 682       (instrs
 683     BCDCFSQ_rec
 684 )>;
 685
 686 // 58 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 687 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 688 // dispatch.
 689 def : InstRW<[P9_DFU_58C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 690       (instrs
 691     XSDIVQP,
 692     XSDIVQPO
 693 )>;
 694
 695 // 76 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 696 // superslice. That includes both exec pipelines (EXECO, EXECE) and all three
 697 // dispatches.
 698 def : InstRW<[P9_DFU_76C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 699       (instrs
 700     XSSQRTQP,
 701     XSSQRTQPO
 702 )>;
 703
 704 // 6 Cycle Load uses a single slice.
 705 def : InstRW<[P9_LS_6C, IP_AGEN_1C, DISP_1C],
 706       (instrs
 707     (instregex "LXVL(L)?")
 708 )>;
 709
 710 // 5 Cycle Load uses a single slice.
 711 def : InstRW<[P9_LS_5C, IP_AGEN_1C, DISP_1C],
 712       (instrs
 713     (instregex "LVE(B|H|W)X$"),
 714     (instregex "LVX(L)?"),
 715     (instregex "LXSI(B|H)ZX$"),
 716     LXSDX,
 717     LXVB16X,
 718     LXVD2X,
 719     LXVWSX,
 720     LXSIWZX,
 721     LXV,
 722     LXVX,
 723     LXSD,
 724     DFLOADf64,
 725     XFLOADf64,
 726     LIWZX
 727 )>;
 728
 729 // 4 Cycle Load uses a single slice.
 730 def : InstRW<[P9_LS_4C, IP_AGEN_1C, DISP_1C],
 731       (instrs
 732     (instregex "DCB(F|T|ST)(EP)?$"),
 733     (instregex "DCBZ(L)?(EP)?$"),
 734     (instregex "DCBTST(EP)?$"),
 735     (instregex "CP_COPY(8)?$"),
 736     (instregex "CP_PASTE(8)?$"),
 737     (instregex "ICBI(EP)?$"),
 738     (instregex "ICBT(LS)?$"),
 739     (instregex "LBARX(L)?$"),
 740     (instregex "LBZ(CIX|8|X|X8|XTLS|XTLS_32)?(_)?$"),
 741     (instregex "LD(ARX|ARXL|BRX|CIX|X|XTLS)?(_)?$"),
 742     (instregex "LH(A|B)RX(L)?(8)?$"),
 743     (instregex "LHZ(8|CIX|X|X8|XTLS|XTLS_32)?(_)?$"),
 744     (instregex "LWARX(L)?$"),
 745     (instregex "LWBRX(8)?$"),
 746     (instregex "LWZ(8|CIX|X|X8|XTLS|XTLS_32)?(_)?$"),
 747     CP_ABORT,
 748     DARN,
 749     EnforceIEIO,
 750     ISYNC,
 751     MSGSYNC,
 752     TLBSYNC,
 753     SYNC,
 754     LMW,
 755     LSWI
 756 )>;
 757
 758 // 4 Cycle Restricted load uses a single slice but the dispatch for the whole
 759 // superslice.
 760 def : InstRW<[P9_LS_4C, IP_AGEN_1C, DISP_3SLOTS_1C],
 761       (instrs
 762     LFIWZX,
 763     LFDX,
 764     LFD
 765 )>;
 766
 767 // Cracked Load Instructions.
 768 // Load instructions that can be done in parallel.
 769 def : InstRW<[P9_LS_4C, P9_LS_4C, IP_AGEN_1C, IP_AGEN_1C,
 770               DISP_PAIR_1C],
 771       (instrs
 772     SLBIA,
 773     SLBIE,
 774     SLBMFEE,
 775     SLBMFEV,
 776     SLBMTE,
 777     TLBIEL
 778 )>;
 779
 780 // Cracked Load Instruction.
 781 // Requires Load and ALU pieces totaling 6 cycles. The Load and ALU
 782 // operations can be run in parallel.
 783 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_EXEC_1C, IP_AGEN_1C,
 784               DISP_PAIR_1C, DISP_PAIR_1C],
 785       (instrs
 786     (instregex "L(W|H)ZU(X)?(8)?$")
 787 )>;
 788
 789 // Cracked TEND Instruction.
 790 // Requires Load and ALU pieces totaling 6 cycles. The Load and ALU
 791 // operations can be run in parallel.
 792 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_EXEC_1C, IP_AGEN_1C,
 793               DISP_1C, DISP_1C],
 794       (instrs
 795     TEND
 796 )>;
 797
 798
 799 // Cracked Store Instruction
 800 // Consecutive Store and ALU instructions. The store is restricted and requires
 801 // three dispatches.
 802 def : InstRW<[P9_StoreAndALUOp_3C, IP_EXEC_1C, IP_EXEC_1C, IP_AGEN_1C,
 803               DISP_3SLOTS_1C, DISP_1C],
 804       (instrs
 805     (instregex "ST(B|H|W|D)CX$")
 806 )>;
 807
 808 // Cracked Load Instruction.
 809 // Two consecutive load operations for a total of 8 cycles.
 810 def : InstRW<[P9_LoadAndLoadOp_8C, IP_AGEN_1C, IP_AGEN_1C,
 811               DISP_1C, DISP_1C],
 812       (instrs
 813     LDMX
 814 )>;
 815
 816 // Cracked Load instruction.
 817 // Requires consecutive Load and ALU pieces totaling 6 cycles. The Load and ALU
 818 // operations cannot be done at the same time and so their latencies are added.
 819 def : InstRW<[P9_LoadAndALUOp_6C, IP_EXEC_1C, IP_AGEN_1C,
 820               DISP_1C, DISP_1C],
 821       (instrs
 822     (instregex "LHA(X)?(8)?$"),
 823     (instregex "CP_PASTE(8)?_rec$"),
 824     (instregex "LWA(X)?(_32)?$"),
 825     TCHECK
 826 )>;
 827
 828 // Cracked Restricted Load instruction.
 829 // Requires consecutive Load and ALU pieces totaling 6 cycles. The Load and ALU
 830 // operations cannot be done at the same time and so their latencies are added.
 831 // Full 6 dispatches are required as this is both cracked and restricted.
 832 def : InstRW<[P9_LoadAndALUOp_6C, IP_EXEC_1C, IP_AGEN_1C,
 833               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
 834       (instrs
 835     LFIWAX
 836 )>;
 837
 838 // Cracked Load instruction.
 839 // Requires consecutive Load and ALU pieces totaling 7 cycles. The Load and ALU
 840 // operations cannot be done at the same time and so their latencies are added.
 841 // Full 4 dispatches are required as this is a cracked instruction.
 842 def : InstRW<[P9_LoadAndALUOp_7C, IP_AGEN_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
 843       (instrs
 844     LXSIWAX,
 845     LIWAX
 846 )>;
 847
 848 // Cracked Load instruction.
 849 // Requires consecutive Load (4 cycles) and ALU (3 cycles) pieces totaling 7
 850 // cycles. The Load and ALU operations cannot be done at the same time and so
 851 // their latencies are added.
 852 // Full 6 dispatches are required as this is a restricted instruction.
 853 def : InstRW<[P9_LoadAndALU2Op_7C, IP_AGEN_1C, IP_EXEC_1C,
 854               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
 855       (instrs
 856     LFSX,
 857     LFS
 858 )>;
 859
 860 // Cracked Load instruction.
 861 // Requires consecutive Load and ALU pieces totaling 8 cycles. The Load and ALU
 862 // operations cannot be done at the same time and so their latencies are added.
 863 // Full 4 dispatches are required as this is a cracked instruction.
 864 def : InstRW<[P9_LoadAndALU2Op_8C, IP_AGEN_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
 865       (instrs
 866     LXSSP,
 867     LXSSPX,
 868     XFLOADf32,
 869     DFLOADf32
 870 )>;
 871
 872 // Cracked 3-Way Load Instruction
 873 // Load with two ALU operations that depend on each other
 874 def : InstRW<[P9_LoadAndALUOp_6C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
 875               DISP_PAIR_1C, DISP_PAIR_1C, DISP_1C],
 876       (instrs
 877     (instregex "LHAU(X)?(8)?$"),
 878     LWAUX
 879 )>;
 880
 881 // Cracked Load that requires the PM resource.
 882 // Since the Load and the PM cannot be done at the same time the latencies are
 883 // added. Requires 8 cycles. Since the PM requires the full superslice we need
 884 // both EXECE, EXECO pipelines as well as 1 dispatch for the PM. The Load
 885 // requires the remaining 1 dispatch.
 886 def : InstRW<[P9_LoadAndPMOp_8C, IP_AGEN_1C, IP_EXECE_1C, IP_EXECO_1C,
 887               DISP_1C, DISP_1C],
 888       (instrs
 889     LXVH8X,
 890     LXVDSX,
 891     LXVW4X
 892 )>;
 893
 894 // Single slice Restricted store operation. The restricted operation requires
 895 // all three dispatches for the superslice.
 896 def : InstRW<[P9_LS_1C, IP_EXEC_1C, IP_AGEN_1C, DISP_3SLOTS_1C],
 897       (instrs
 898     (instregex "STF(S|D|IWX|SX|DX)$"),
 899     (instregex "STXS(D|DX|SPX|IWX|IBX|IHX|SP)(v)?$"),
 900     (instregex "STW(8)?$"),
 901     (instregex "(D|X)FSTORE(f32|f64)$"),
 902     (instregex "ST(W|H|D)BRX$"),
 903     (instregex "ST(B|H|D)(8)?$"),
 904     (instregex "ST(B|W|H|D)(CI)?X(TLS|TLS_32)?(8)?(_)?$"),
 905     STIWX,
 906     SLBIEG,
 907     STMW,
 908     STSWI,
 909     TLBIE
 910 )>;
 911
 912 // Vector Store Instruction
 913 // Requires the whole superslice and therefore requires one dispatch
 914 // as well as both the Even and Odd exec pipelines.
 915 def : InstRW<[P9_LS_1C, IP_EXECE_1C, IP_EXECO_1C, IP_AGEN_1C, DISP_1C],
 916       (instrs
 917     (instregex "STVE(B|H|W)X$"),
 918     (instregex "STVX(L)?$"),
 919     (instregex "STXV(B16X|H8X|W4X|D2X|L|LL|X)?$")
 920 )>;
 921
 922 // 5 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 923 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 924 // dispatches.
 925 def : InstRW<[P9_DIV_5C, IP_EXECE_1C, IP_EXECO_1C, DISP_EVEN_1C],
 926       (instrs
 927     (instregex "MTCTR(8)?(loop)?$"),
 928     (instregex "MTLR(8)?$")
 929 )>;
 930
 931 // 12 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 932 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 933 // dispatches.
 934 def : InstRW<[P9_DIV_12C, IP_EXECE_1C, IP_EXECO_1C, DISP_EVEN_1C],
 935       (instrs
 936     (instregex "M(T|F)VRSAVE(v)?$"),
 937     (instregex "M(T|F)PMR$"),
 938     (instregex "M(T|F)TB(8)?$"),
 939     (instregex "MF(SPR|CTR|LR)(8)?$"),
 940     (instregex "M(T|F)MSR(D)?$"),
 941     (instregex "MTSPR(8)?$")
 942 )>;
 943
 944 // 16 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 945 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 946 // dispatches.
 947 def : InstRW<[P9_DIV_16C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 948       (instrs
 949     DIVW,
 950     DIVWO,
 951     DIVWU,
 952     DIVWUO,
 953     MODSW
 954 )>;
 955
 956 // 24 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 957 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 958 // dispatches.
 959 def : InstRW<[P9_DIV_24C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 960       (instrs
 961     DIVWE,
 962     DIVWEO,
 963     DIVD,
 964     DIVDO,
 965     DIVWEU,
 966     DIVWEUO,
 967     DIVDU,
 968     DIVDUO,
 969     MODSD,
 970     MODUD,
 971     MODUW
 972 )>;
 973
 974 // 40 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 975 // superslice. That includes both exec pipelines (EXECO, EXECE) and all three
 976 // dispatches.
 977 def : InstRW<[P9_DIV_40C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 978       (instrs
 979     DIVDE,
 980     DIVDEO,
 981     DIVDEU,
 982     DIVDEUO
 983 )>;
 984
 985 // Cracked DIV and ALU operation. Requires one full slice for the ALU operation
 986 // and one full superslice for the DIV operation since there is only one DIV per
 987 // superslice. Latency of DIV plus ALU is 26.
 988 def : InstRW<[P9_IntDivAndALUOp_18C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
 989               DISP_EVEN_1C, DISP_1C],
 990       (instrs
 991     (instregex "DIVW(U)?(O)?_rec$")
 992 )>;
 993
 994 // Cracked DIV and ALU operation. Requires one full slice for the ALU operation
 995 // and one full superslice for the DIV operation since there is only one DIV per
 996 // superslice. Latency of DIV plus ALU is 26.
 997 def : InstRW<[P9_IntDivAndALUOp_26C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
 998               DISP_EVEN_1C, DISP_1C],
 999       (instrs
1000     DIVD_rec,
1001     DIVDO_rec,
1002     DIVDU_rec,
1003     DIVDUO_rec,
1004     DIVWE_rec,
1005     DIVWEO_rec,
1006     DIVWEU_rec,
1007     DIVWEUO_rec
1008 )>;
1009
1010 // Cracked DIV and ALU operation. Requires one full slice for the ALU operation
1011 // and one full superslice for the DIV operation since there is only one DIV per
1012 // superslice. Latency of DIV plus ALU is 42.
1013 def : InstRW<[P9_IntDivAndALUOp_42C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
1014               DISP_EVEN_1C, DISP_1C],
1015       (instrs
1016     DIVDE_rec,
1017     DIVDEO_rec,
1018     DIVDEU_rec,
1019     DIVDEUO_rec
1020 )>;
1021
1022 // CR access instructions in _BrMCR, IIC_BrMCRX.
1023
1024 // Cracked, restricted, ALU operations.
1025 // Here the two ALU ops can actually be done in parallel and therefore the
1026 // latencies are not added together. Otherwise this is like having two
1027 // instructions running together on two pipelines and 6 dispatches. ALU ops are
1028 // 2 cycles each.
1029 def : InstRW<[P9_ALU_2C, P9_ALU_2C, IP_EXEC_1C, IP_EXEC_1C,
1030               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1031       (instrs
1032     MTCRF,
1033     MTCRF8
1034 )>;
1035
1036 // Cracked ALU operations.
1037 // Here the two ALU ops can actually be done in parallel and therefore the
1038 // latencies are not added together. Otherwise this is like having two
1039 // instructions running together on two pipelines and 2 dispatches. ALU ops are
1040 // 2 cycles each.
1041 def : InstRW<[P9_ALU_2C, P9_ALU_2C, IP_EXEC_1C, IP_EXEC_1C,
1042               DISP_1C, DISP_1C],
1043       (instrs
1044     (instregex "ADDC(8)?(O)?_rec$"),
1045     (instregex "SUBFC(8)?(O)?_rec$")
1046 )>;
1047
1048 // Cracked ALU operations.
1049 // Two ALU ops can be done in parallel.
1050 // One is three cycle ALU the ohter is a two cycle ALU.
1051 // One of the ALU ops is restricted the other is not so we have a total of
1052 // 5 dispatches.
1053 def : InstRW<[P9_ALU_2C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1054               DISP_3SLOTS_1C, DISP_1C],
1055       (instrs
1056     (instregex "F(N)?ABS(D|S)_rec$"),
1057     (instregex "FCPSGN(D|S)_rec$"),
1058     (instregex "FNEG(D|S)_rec$"),
1059     FMR_rec
1060 )>;
1061
1062 // Cracked ALU operations.
1063 // Here the two ALU ops can actually be done in parallel and therefore the
1064 // latencies are not added together. Otherwise this is like having two
1065 // instructions running together on two pipelines and 2 dispatches.
1066 // ALU ops are 3 cycles each.
1067 def : InstRW<[P9_ALU_3C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1068               DISP_1C, DISP_1C],
1069       (instrs
1070     MCRFS
1071 )>;
1072
1073 // Cracked Restricted ALU operations.
1074 // Here the two ALU ops can actually be done in parallel and therefore the
1075 // latencies are not added together. Otherwise this is like having two
1076 // instructions running together on two pipelines and 6 dispatches.
1077 // ALU ops are 3 cycles each.
1078 def : InstRW<[P9_ALU_3C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1079               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1080       (instrs
1081     (instregex "MTFSF(b|_rec)?$"),
1082     (instregex "MTFSFI(_rec)?$")
1083 )>;
1084
1085 // Cracked instruction made of two ALU ops.
1086 // The two ops cannot be done in parallel.
1087 // One of the ALU ops is restricted and takes 3 dispatches.
1088 def : InstRW<[P9_ALUOpAndALUOp_4C, IP_EXEC_1C, IP_EXEC_1C,
1089               DISP_3SLOTS_1C, DISP_1C],
1090       (instrs
1091     (instregex "RLD(I)?C(R|L)_rec$"),
1092     (instregex "RLW(IMI|INM|NM)(8)?_rec$"),
1093     (instregex "SLW(8)?_rec$"),
1094     (instregex "SRAW(I)?_rec$"),
1095     (instregex "SRW(8)?_rec$"),
1096     RLDICL_32_rec,
1097     RLDIMI_rec
1098 )>;
1099
1100 // Cracked instruction made of two ALU ops.
1101 // The two ops cannot be done in parallel.
1102 // Both of the ALU ops are restricted and take 3 dispatches.
1103 def : InstRW<[P9_ALU2OpAndALU2Op_6C, IP_EXEC_1C, IP_EXEC_1C,
1104               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1105       (instrs
1106     (instregex "MFFS(L|CE|_rec)?$")
1107 )>;
1108
1109 // Cracked ALU instruction composed of three consecutive 2 cycle loads for a
1110 // total of 6 cycles. All of the ALU operations are also restricted so each
1111 // takes 3 dispatches for a total of 9.
1112 def : InstRW<[P9_ALUOpAndALUOpAndALUOp_6C, IP_EXEC_1C, IP_EXEC_1C, IP_EXEC_1C,
1113               DISP_3SLOTS_1C, DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1114       (instrs
1115     (instregex "MFCR(8)?$")
1116 )>;
1117
1118 // Cracked instruction made of two ALU ops.
1119 // The two ops cannot be done in parallel.
1120 def : InstRW<[P9_ALUOpAndALUOp_4C, IP_EXEC_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
1121       (instrs
1122     (instregex "EXTSWSLI_32_64_rec$"),
1123     (instregex "SRAD(I)?_rec$"),
1124     EXTSWSLI_rec,
1125     SLD_rec,
1126     SRD_rec,
1127     RLDIC_rec
1128 )>;
1129
1130 // 33 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1131 def : InstRW<[P9_DP_33C_8, IP_EXEC_1C, DISP_3SLOTS_1C],
1132       (instrs
1133     FDIV
1134 )>;
1135
1136 // 33 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1137 def : InstRW<[P9_DPOpAndALU2Op_36C_8, IP_EXEC_1C, IP_EXEC_1C,
1138               DISP_3SLOTS_1C, DISP_1C],
1139       (instrs
1140     FDIV_rec
1141 )>;
1142
1143 // 36 Cycle DP Instruction.
1144 // Instruction can be done on a single slice.
1145 def : InstRW<[P9_DP_36C_10, IP_EXEC_1C, DISP_1C],
1146       (instrs
1147     XSSQRTDP
1148 )>;
1149
1150 // 36 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1151 def : InstRW<[P9_DP_36C_10, IP_EXEC_1C, DISP_3SLOTS_1C],
1152       (instrs
1153     FSQRT
1154 )>;
1155
1156 // 36 Cycle DP Vector Instruction.
1157 def : InstRW<[P9_DPE_36C_10, P9_DPO_36C_10, IP_EXECE_1C, IP_EXECO_1C,
1158               DISP_1C],
1159       (instrs
1160     XVSQRTDP
1161 )>;
1162
1163 // 27 Cycle DP Vector Instruction.
1164 def : InstRW<[P9_DPE_27C_10, P9_DPO_27C_10, IP_EXECE_1C, IP_EXECO_1C,
1165               DISP_1C],
1166       (instrs
1167     XVSQRTSP
1168 )>;
1169
1170 // 36 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1171 def : InstRW<[P9_DPOpAndALU2Op_39C_10, IP_EXEC_1C, IP_EXEC_1C,
1172               DISP_3SLOTS_1C, DISP_1C],
1173       (instrs
1174     FSQRT_rec
1175 )>;
1176
1177 // 26 Cycle DP Instruction.
1178 def : InstRW<[P9_DP_26C_5, IP_EXEC_1C, DISP_1C],
1179       (instrs
1180     XSSQRTSP
1181 )>;
1182
1183 // 26 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1184 def : InstRW<[P9_DP_26C_5, IP_EXEC_1C, DISP_3SLOTS_1C],
1185       (instrs
1186     FSQRTS
1187 )>;
1188
1189 // 26 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1190 def : InstRW<[P9_DPOpAndALU2Op_29C_5, IP_EXEC_1C, IP_EXEC_1C,
1191               DISP_3SLOTS_1C, DISP_1C],
1192       (instrs
1193     FSQRTS_rec
1194 )>;
1195
1196 // 33 Cycle DP Instruction. Takes one slice and 1 dispatch.
1197 def : InstRW<[P9_DP_33C_8, IP_EXEC_1C, DISP_1C],
1198       (instrs
1199     XSDIVDP
1200 )>;
1201
1202 // 22 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1203 def : InstRW<[P9_DP_22C_5, IP_EXEC_1C, DISP_3SLOTS_1C],
1204       (instrs
1205     FDIVS
1206 )>;
1207
1208 // 22 Cycle DP Instruction Restricted and Cracked with 2 Cycle ALU.
1209 def : InstRW<[P9_DPOpAndALU2Op_25C_5, IP_EXEC_1C, IP_EXEC_1C,
1210               DISP_3SLOTS_1C, DISP_1C],
1211       (instrs
1212     FDIVS_rec
1213 )>;
1214
1215 // 22 Cycle DP Instruction. Takes one slice and 1 dispatch.
1216 def : InstRW<[P9_DP_22C_5, IP_EXEC_1C, DISP_1C],
1217       (instrs
1218     XSDIVSP
1219 )>;
1220
1221 // 24 Cycle DP Vector Instruction. Takes one full superslice.
1222 // Includes both EXECE, EXECO pipelines and 1 dispatch for the given
1223 // superslice.
1224 def : InstRW<[P9_DPE_24C_8, P9_DPO_24C_8, IP_EXECE_1C, IP_EXECO_1C,
1225               DISP_1C],
1226       (instrs
1227     XVDIVSP
1228 )>;
1229
1230 // 33 Cycle DP Vector Instruction. Takes one full superslice.
1231 // Includes both EXECE, EXECO pipelines and 1 dispatch for the given
1232 // superslice.
1233 def : InstRW<[P9_DPE_33C_8, P9_DPO_33C_8, IP_EXECE_1C, IP_EXECO_1C,
1234               DISP_1C],
1235       (instrs
1236     XVDIVDP
1237 )>;
1238
1239 // Instruction cracked into three pieces. One Load and two ALU operations.
1240 // The Load and one of the ALU ops cannot be run at the same time and so the
1241 // latencies are added together for 6 cycles. The remainaing ALU is 2 cycles.
1242 // Both the load and the ALU that depends on it are restricted and so they take
1243 // a total of 7 dispatches. The final 2 dispatches come from the second ALU op.
1244 // The two EXEC pipelines are for the 2 ALUs while the AGEN is for the load.
1245 def : InstRW<[P9_LoadAndALU2Op_7C, P9_ALU_2C,
1246               IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
1247               DISP_3SLOTS_1C, DISP_3SLOTS_1C, DISP_1C],
1248       (instrs
1249     (instregex "LF(SU|SUX)$")
1250 )>;
1251
1252 // Cracked instruction made up of a Store and an ALU. The ALU does not depend on
1253 // the store and so it can be run at the same time as the store. The store is
1254 // also restricted.
1255 def : InstRW<[P9_LS_1C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
1256               DISP_3SLOTS_1C, DISP_1C],
1257       (instrs
1258     (instregex "STF(S|D)U(X)?$"),
1259     (instregex "ST(B|H|W|D)U(X)?(8)?$")
1260 )>;
1261
1262 // Cracked instruction made up of a Load and an ALU. The ALU does not depend on
1263 // the load and so it can be run at the same time as the load.
1264 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C,
1265               DISP_PAIR_1C, DISP_PAIR_1C],
1266       (instrs
1267     (instregex "LBZU(X)?(8)?$"),
1268     (instregex "LDU(X)?$")
1269 )>;
1270
1271 // Cracked instruction made up of a Load and an ALU. The ALU does not depend on
1272 // the load and so it can be run at the same time as the load. The load is also
1273 // restricted. 3 dispatches are from the restricted load while the other two
1274 // are from the ALU. The AGEN pipeline is from the load and the EXEC pipeline
1275 // is required for the ALU.
1276 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C,
1277               DISP_3SLOTS_1C, DISP_1C],
1278       (instrs
1279     (instregex "LF(DU|DUX)$")
1280 )>;
1281
1282 // Crypto Instructions
1283
1284 // 6 Cycle CY operation. Only one CY unit per CPU so we use a whole
1285 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
1286 // dispatch.
1287 def : InstRW<[P9_CY_6C, IP_EXECO_1C, IP_EXECE_1C, DISP_1C],
1288       (instrs
1289     (instregex "VPMSUM(B|H|W|D)$"),
1290     (instregex "V(N)?CIPHER(LAST)?$"),
1291     VSBOX
1292 )>;
1293
1294 // Branch Instructions
1295
1296 // Two Cycle Branch
1297 def : InstRW<[P9_BR_2C, DISP_BR_1C],
1298       (instrs
1299   (instregex "BCCCTR(L)?(8)?$"),
1300   (instregex "BCCL(A|R|RL)?$"),
1301   (instregex "BCCTR(L)?(8)?(n)?$"),
1302   (instregex "BD(N)?Z(8|A|Am|Ap|m|p)?$"),
1303   (instregex "BD(N)?ZL(A|Am|Ap|R|R8|RL|RLm|RLp|Rm|Rp|m|p)?$"),
1304   (instregex "BL(_TLS|_NOP)?$"),
1305   (instregex "BL8(_TLS|_NOP|_NOP_TLS|_TLS_)?$"),
1306   (instregex "BLA(8|8_NOP)?$"),
1307   (instregex "BLR(8|L)?$"),
1308   (instregex "TAILB(A)?(8)?$"),
1309   (instregex "TAILBCTR(8)?$"),
1310   (instregex "gBC(A|Aat|CTR|CTRL|L|LA|LAat|LR|LRL|Lat|at)?$"),
1311   (instregex "BCLR(L)?(n)?$"),
1312   (instregex "BCTR(L)?(8)?$"),
1313   B,
1314   BA,
1315   BC,
1316   BCC,
1317   BCCA,
1318   BCL,
1319   BCLalways,
1320   BCLn,
1321   BCTRL8_LDinto_toc,
1322   BCTRL_LWZinto_toc,
1323   BCn,
1324   CTRL_DEP
1325 )>;
1326
1327 // Five Cycle Branch with a 2 Cycle ALU Op
1328 // Operations must be done consecutively and not in parallel.
1329 def : InstRW<[P9_BROpAndALUOp_7C, IP_EXEC_1C, DISP_BR_1C, DISP_1C],
1330       (instrs
1331     ADDPCIS
1332 )>;
1333
1334 // Special Extracted Instructions For Atomics
1335
1336 // Atomic Load
1337 def : InstRW<[P9_LS_1C, P9_LS_1C, P9_LS_4C, P9_LS_4C, P9_LS_4C,
1338               IP_EXEC_1C, IP_EXEC_1C, IP_AGEN_1C, IP_AGEN_1C, IP_AGEN_1C,
1339               IP_AGEN_1C, IP_AGEN_1C, DISP_1C, DISP_3SLOTS_1C,
1340               DISP_3SLOTS_1C, DISP_1C, DISP_1C, DISP_1C],
1341       (instrs
1342     (instregex "L(D|W)AT$")
1343 )>;
1344
1345 // Atomic Store
1346 def : InstRW<[P9_LS_1C, P9_LS_4C, P9_LS_4C, IP_EXEC_1C, IP_AGEN_1C, IP_AGEN_1C,
1347               IP_AGEN_1C, DISP_1C, DISP_3SLOTS_1C, DISP_1C],
1348       (instrs
1349     (instregex "ST(D|W)AT$")
1350 )>;
1351
1352 // Signal Processing Engine (SPE) Instructions
1353 // These instructions are not supported on Power 9
1354 def : InstRW<[],
1355     (instrs
1356   BRINC,
1357   EVABS,
1358   EVEQV,
1359   EVMRA,
1360   EVNAND,
1361   EVNEG,
1362   (instregex "EVADD(I)?W$"),
1363   (instregex "EVADD(SM|SS|UM|US)IAAW$"),
1364   (instregex "EVAND(C)?$"),
1365   (instregex "EVCMP(EQ|GTS|GTU|LTS|LTU)$"),
1366   (instregex "EVCNTL(S|Z)W$"),
1367   (instregex "EVDIVW(S|U)$"),
1368   (instregex "EVEXTS(B|H)$"),
1369   (instregex "EVLD(H|W|D)(X)?$"),
1370   (instregex "EVLHH(E|OS|OU)SPLAT(X)?$"),
1371   (instregex "EVLWHE(X)?$"),
1372   (instregex "EVLWHO(S|U)(X)?$"),
1373   (instregex "EVLW(H|W)SPLAT(X)?$"),
1374   (instregex "EVMERGE(HI|LO|HILO|LOHI)$"),
1375   (instregex "EVMHEG(S|U)M(F|I)A(A|N)$"),
1376   (instregex "EVMHES(M|S)(F|I)(A|AA|AAW|ANW)?$"),
1377   (instregex "EVMHEU(M|S)I(A|AA|AAW|ANW)?$"),
1378   (instregex "EVMHOG(U|S)M(F|I)A(A|N)$"),
1379   (instregex "EVMHOS(M|S)(F|I)(A|AA|AAW|ANW)?$"),
1380   (instregex "EVMHOU(M|S)I(A|AA|ANW|AAW)?$"),
1381   (instregex "EVMWHS(M|S)(F|FA|I|IA)$"),
1382   (instregex "EVMWHUMI(A)?$"),
1383   (instregex "EVMWLS(M|S)IA(A|N)W$"),
1384   (instregex "EVMWLU(M|S)I(A|AA|AAW|ANW)?$"),
1385   (instregex "EVMWSM(F|I)(A|AA|AN)?$"),
1386   (instregex "EVMWSSF(A|AA|AN)?$"),
1387   (instregex "EVMWUMI(A|AA|AN)?$"),
1388   (instregex "EV(N|X)?OR(C)?$"),
1389   (instregex "EVR(LW|LWI|NDW)$"),
1390   (instregex "EVSLW(I)?$"),
1391   (instregex "EVSPLAT(F)?I$"),
1392   (instregex "EVSRW(I)?(S|U)$"),
1393   (instregex "EVST(DD|DH|DW|WHE|WHO|WWE|WWO)(X)?$"),
1394   (instregex "EVSUBF(S|U)(M|S)IAAW$"),
1395   (instregex "EVSUB(I)?FW$")
1396 )> { let Unsupported = 1; }
1397
1398 // General Instructions without scheduling support.
1399 def : InstRW<[],
1400     (instrs
1401   (instregex "(H)?RFI(D)?$"),
1402   (instregex "DSS(ALL)?$"),
1403   (instregex "DST(ST)?(T)?(64)?$"),
1404   (instregex "ICBL(C|Q)$"),
1405   (instregex "L(W|H|B)EPX$"),
1406   (instregex "ST(W|H|B)EPX$"),
1407   (instregex "(L|ST)FDEPX$"),
1408   (instregex "M(T|F)SR(IN)?$"),
1409   (instregex "M(T|F)DCR$"),
1410   (instregex "NOP_GT_PWR(6|7)$"),
1411   (instregex "TLB(IA|IVAX|SX|SX2|SX2D|LD|LI|RE|RE2|WE|WE2)$"),
1412   (instregex "WRTEE(I)?$"),
1413   ATTN,
1414   CLRBHRB,
1415   MFBHRBE,
1416   MBAR,
1417   MSYNC,
1418   SLBSYNC,
1419   SLBFEE_rec,
1420   NAP,
1421   STOP,
1422   TRAP,
1423   RFCI,
1424   RFDI,
1425   RFMCI,
1426   SC,
1427   DCBA,
1428   DCBI,
1429   DCCCI,
1430   ICCCI
1431 )> { let Unsupported = 1; }