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)?(o)?$"),
 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)?$"),
 133     (instregex "ANDI(S)?o(8)?$"),
 134     (instregex "ADDC(8)?$"),
 135     (instregex "ADDIC(8)?(o)?$"),
 136     (instregex "ADD(8|4)(o)?$"),
 137     (instregex "ADD(E|ME|ZE)(8)?(o)?$"),
 138     (instregex "SUBF(E|ME|ZE)?(8)?(o)?$"),
 139     (instregex "NEG(8)?(o)?$"),
 140     (instregex "POPCNTB$"),
 141     (instregex "ADD(I|IS)?(8)?$"),
 142     (instregex "LI(S)?(8)?$"),
 143     (instregex "(X)?OR(I|IS)?(8)?(o)?$"),
 144     (instregex "NAND(8)?(o)?$"),
 145     (instregex "AND(C)?(8)?(o)?$"),
 146     (instregex "NOR(8)?(o)?$"),
 147     (instregex "OR(C)?(8)?(o)?$"),
 148     (instregex "EQV(8)?(o)?$"),
 149     (instregex "EXTS(B|H|W)(8)?(_32)?(_64)?(o)?$"),
 150     (instregex "ADD(4|8)(TLS)?(_)?$"),
 151     (instregex "NEG(8)?$"),
 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(o)?$"),
 215     (instregex "VCMPBFP(o)?$"),
 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     VCMPGTSBo,
 237     VCMPGTSD,
 238     VCMPGTSDo,
 239     VCMPGTSH,
 240     VCMPGTSHo,
 241     VCMPGTSW,
 242     VCMPGTSWo,
 243     VCMPGTUB,
 244     VCMPGTUBo,
 245     VCMPGTUD,
 246     VCMPGTUDo,
 247     VCMPGTUH,
 248     VCMPGTUHo,
 249     VCMPGTUW,
 250     VCMPGTUWo,
 251     VCMPNEBo,
 252     VCMPNEHo,
 253     VCMPNEWo,
 254     VCMPNEZBo,
 255     VCMPNEZHo,
 256     VCMPNEZWo,
 257     VCMPEQUBo,
 258     VCMPEQUDo,
 259     VCMPEQUHo,
 260     VCMPEQUWo,
 261     XVCMPEQDP,
 262     XVCMPEQDPo,
 263     XVCMPEQSP,
 264     XVCMPEQSPo,
 265     XVCMPGEDP,
 266     XVCMPGEDPo,
 267     XVCMPGESP,
 268     XVCMPGESPo,
 269     XVCMPGTDP,
 270     XVCMPGTDPo,
 271     XVCMPGTSP,
 272     XVCMPGTSPo,
 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     VMSUMUHS,
 377     VMULESB,
 378     VMULESH,
 379     VMULESW,
 380     VMULEUB,
 381     VMULEUH,
 382     VMULEUW,
 383     VMULOSB,
 384     VMULOSH,
 385     VMULOSW,
 386     VMULOUB,
 387     VMULOUH,
 388     VMULOUW,
 389     VMULUWM,
 390     VSUM2SWS,
 391     VSUM4SBS,
 392     VSUM4SHS,
 393     VSUM4UBS,
 394     VSUMSWS
 395 )>;
 396
 397 // 5 cycle Restricted DP operation. One DP unit, one EXEC pipeline and all three
 398 // dispatch units for the superslice.
 399 def : InstRW<[P9_DP_5C, IP_EXEC_1C, DISP_3SLOTS_1C],
 400       (instrs
 401     (instregex "MADD(HD|HDU|LD|LD8)$"),
 402     (instregex "MUL(HD|HW|LD|LI|LI8|LW)(U)?$")
 403 )>;
 404
 405 // 7 cycle Restricted DP operation. One DP unit, one EXEC pipeline and all three
 406 // dispatch units for the superslice.
 407 def : InstRW<[P9_DP_7C, IP_EXEC_1C, DISP_3SLOTS_1C],
 408       (instrs
 409     FRSP,
 410     (instregex "FRI(N|P|Z|M)(D|S)$"),
 411     (instregex "FRE(S)?$"),
 412     (instregex "FADD(S)?$"),
 413     (instregex "FMSUB(S)?$"),
 414     (instregex "FMADD(S)?$"),
 415     (instregex "FSUB(S)?$"),
 416     (instregex "FCFID(U)?(S)?$"),
 417     (instregex "FCTID(U)?(Z)?$"),
 418     (instregex "FCTIW(U)?(Z)?$"),
 419     (instregex "FRSQRTE(S)?$"),
 420     FNMADDS,
 421     FNMADD,
 422     FNMSUBS,
 423     FNMSUB,
 424     FSELD,
 425     FSELS,
 426     FMULS,
 427     FMUL,
 428     XSMADDADP,
 429     XSMADDASP,
 430     XSMADDMDP,
 431     XSMADDMSP,
 432     XSMSUBADP,
 433     XSMSUBASP,
 434     XSMSUBMDP,
 435     XSMSUBMSP,
 436     XSMULDP,
 437     XSMULSP,
 438     XSNMADDADP,
 439     XSNMADDASP,
 440     XSNMADDMDP,
 441     XSNMADDMSP,
 442     XSNMSUBADP,
 443     XSNMSUBASP,
 444     XSNMSUBMDP,
 445     XSNMSUBMSP
 446 )>;
 447
 448 // 7 cycle Restricted DP operation and one 3 cycle ALU operation.
 449 // These operations can be done in parallel. The DP is restricted so we need a
 450 // full 4 dispatches.
 451 def : InstRW<[P9_DP_7C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
 452               DISP_3SLOTS_1C, DISP_1C],
 453       (instrs
 454     (instregex "FSEL(D|S)o$")
 455 )>;
 456
 457 // 5 Cycle Restricted DP operation and one 2 cycle ALU operation.
 458 def : InstRW<[P9_DPOpAndALUOp_7C, IP_EXEC_1C, IP_EXEC_1C,
 459               DISP_3SLOTS_1C, DISP_1C],
 460       (instrs
 461     (instregex "MUL(H|L)(D|W)(U)?o$")
 462 )>;
 463
 464 // 7 cycle Restricted DP operation and one 3 cycle ALU operation.
 465 // These operations must be done sequentially.The DP is restricted so we need a
 466 // full 4 dispatches.
 467 def : InstRW<[P9_DPOpAndALU2Op_10C, IP_EXEC_1C, IP_EXEC_1C,
 468               DISP_3SLOTS_1C, DISP_1C],
 469       (instrs
 470     (instregex "FRI(N|P|Z|M)(D|S)o$"),
 471     (instregex "FRE(S)?o$"),
 472     (instregex "FADD(S)?o$"),
 473     (instregex "FSUB(S)?o$"),
 474     (instregex "F(N)?MSUB(S)?o$"),
 475     (instregex "F(N)?MADD(S)?o$"),
 476     (instregex "FCFID(U)?(S)?o$"),
 477     (instregex "FCTID(U)?(Z)?o$"),
 478     (instregex "FCTIW(U)?(Z)?o$"),
 479     (instregex "FMUL(S)?o$"),
 480     (instregex "FRSQRTE(S)?o$"),
 481     FRSPo
 482 )>;
 483
 484 // 7 cycle DP operation. One DP unit, one EXEC pipeline and 1 dispatch units.
 485 def : InstRW<[P9_DP_7C, IP_EXEC_1C, DISP_1C],
 486       (instrs
 487     XSADDDP,
 488     XSADDSP,
 489     XSCVDPHP,
 490     XSCVDPSP,
 491     XSCVDPSXDS,
 492     XSCVDPSXDSs,
 493     XSCVDPSXWS,
 494     XSCVDPUXDS,
 495     XSCVDPUXDSs,
 496     XSCVDPUXWS,
 497     XSCVDPSXWSs,
 498     XSCVDPUXWSs,
 499     XSCVHPDP,
 500     XSCVSPDP,
 501     XSCVSXDDP,
 502     XSCVSXDSP,
 503     XSCVUXDDP,
 504     XSCVUXDSP,
 505     XSRDPI,
 506     XSRDPIC,
 507     XSRDPIM,
 508     XSRDPIP,
 509     XSRDPIZ,
 510     XSREDP,
 511     XSRESP,
 512     XSRSQRTEDP,
 513     XSRSQRTESP,
 514     XSSUBDP,
 515     XSSUBSP,
 516     XSCVDPSPN,
 517     XSRSP
 518 )>;
 519
 520 // Three Cycle PM operation. Only one PM unit per superslice so we use the whole
 521 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 522 // dispatch.
 523 def : InstRW<[P9_PM_3C, IP_EXECO_1C, IP_EXECE_1C, DISP_1C],
 524       (instrs
 525     (instregex "LVS(L|R)$"),
 526     (instregex "VSPLTIS(W|H|B)$"),
 527     (instregex "VSPLT(W|H|B)(s)?$"),
 528     (instregex "V_SETALLONES(B|H)?$"),
 529     (instregex "VEXTRACTU(B|H|W)$"),
 530     (instregex "VINSERT(B|H|W|D)$"),
 531     MFVSRLD,
 532     MTVSRWS,
 533     VBPERMQ,
 534     VCLZLSBB,
 535     VCTZLSBB,
 536     VEXTRACTD,
 537     VEXTUBLX,
 538     VEXTUBRX,
 539     VEXTUHLX,
 540     VEXTUHRX,
 541     VEXTUWLX,
 542     VEXTUWRX,
 543     VGBBD,
 544     VMRGHB,
 545     VMRGHH,
 546     VMRGHW,
 547     VMRGLB,
 548     VMRGLH,
 549     VMRGLW,
 550     VPERM,
 551     VPERMR,
 552     VPERMXOR,
 553     VPKPX,
 554     VPKSDSS,
 555     VPKSDUS,
 556     VPKSHSS,
 557     VPKSHUS,
 558     VPKSWSS,
 559     VPKSWUS,
 560     VPKUDUM,
 561     VPKUDUS,
 562     VPKUHUM,
 563     VPKUHUS,
 564     VPKUWUM,
 565     VPKUWUS,
 566     VPRTYBQ,
 567     VSL,
 568     VSLDOI,
 569     VSLO,
 570     VSLV,
 571     VSR,
 572     VSRO,
 573     VSRV,
 574     VUPKHPX,
 575     VUPKHSB,
 576     VUPKHSH,
 577     VUPKHSW,
 578     VUPKLPX,
 579     VUPKLSB,
 580     VUPKLSH,
 581     VUPKLSW,
 582     XXBRD,
 583     XXBRH,
 584     XXBRQ,
 585     XXBRW,
 586     XXEXTRACTUW,
 587     XXINSERTW,
 588     XXMRGHW,
 589     XXMRGLW,
 590     XXPERM,
 591     XXPERMR,
 592     XXSLDWI,
 593     XXSLDWIs,
 594     XXSPLTIB,
 595     XXSPLTW,
 596     XXSPLTWs,
 597     XXPERMDI,
 598     XXPERMDIs,
 599     VADDCUQ,
 600     VADDECUQ,
 601     VADDEUQM,
 602     VADDUQM,
 603     VMUL10CUQ,
 604     VMUL10ECUQ,
 605     VMUL10EUQ,
 606     VMUL10UQ,
 607     VSUBCUQ,
 608     VSUBECUQ,
 609     VSUBEUQM,
 610     VSUBUQM,
 611     XSCMPEXPQP,
 612     XSCMPOQP,
 613     XSCMPUQP,
 614     XSTSTDCQP,
 615     XSXSIGQP,
 616     BCDCFNo,
 617     BCDCFZo,
 618     BCDCPSGNo,
 619     BCDCTNo,
 620     BCDCTZo,
 621     BCDSETSGNo,
 622     BCDSo,
 623     BCDTRUNCo,
 624     BCDUSo,
 625     BCDUTRUNCo
 626 )>;
 627
 628 // 12 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 629 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 630 // dispatch.
 631 def : InstRW<[P9_DFU_12C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 632       (instrs
 633     BCDSRo,
 634     XSADDQP,
 635     XSADDQPO,
 636     XSCVDPQP,
 637     XSCVQPDP,
 638     XSCVQPDPO,
 639     XSCVQPSDZ,
 640     XSCVQPSWZ,
 641     XSCVQPUDZ,
 642     XSCVQPUWZ,
 643     XSCVSDQP,
 644     XSCVUDQP,
 645     XSRQPI,
 646     XSRQPIX,
 647     XSRQPXP,
 648     XSSUBQP,
 649     XSSUBQPO
 650 )>;
 651
 652 // 23 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 653 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 654 // dispatch.
 655 def : InstRW<[P9_DFU_23C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 656       (instrs
 657     BCDCTSQo
 658 )>;
 659
 660 // 24 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 661 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 662 // dispatch.
 663 def : InstRW<[P9_DFU_24C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 664       (instrs
 665     XSMADDQP,
 666     XSMADDQPO,
 667     XSMSUBQP,
 668     XSMSUBQPO,
 669     XSMULQP,
 670     XSMULQPO,
 671     XSNMADDQP,
 672     XSNMADDQPO,
 673     XSNMSUBQP,
 674     XSNMSUBQPO
 675 )>;
 676
 677 // 37 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 678 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 679 // dispatch.
 680 def : InstRW<[P9_DFU_37C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 681       (instrs
 682     BCDCFSQo
 683 )>;
 684
 685 // 58 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 686 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
 687 // dispatch.
 688 def : InstRW<[P9_DFU_58C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 689       (instrs
 690     XSDIVQP,
 691     XSDIVQPO
 692 )>;
 693
 694 // 76 Cycle DFU operation. Only one DFU unit per CPU so we use a whole
 695 // superslice. That includes both exec pipelines (EXECO, EXECE) and all three
 696 // dispatches.
 697 def : InstRW<[P9_DFU_76C, IP_EXECE_1C, IP_EXECO_1C, DISP_1C],
 698       (instrs
 699     XSSQRTQP,
 700     XSSQRTQPO
 701 )>;
 702
 703 // 6 Cycle Load uses a single slice.
 704 def : InstRW<[P9_LS_6C, IP_AGEN_1C, DISP_1C],
 705       (instrs
 706     (instregex "LXVL(L)?")
 707 )>;
 708
 709 // 5 Cycle Load uses a single slice.
 710 def : InstRW<[P9_LS_5C, IP_AGEN_1C, DISP_1C],
 711       (instrs
 712     (instregex "LVE(B|H|W)X$"),
 713     (instregex "LVX(L)?"),
 714     (instregex "LXSI(B|H)ZX$"),
 715     LXSDX,
 716     LXVB16X,
 717     LXVD2X,
 718     LXVWSX,
 719     LXSIWZX,
 720     LXV,
 721     LXVX,
 722     LXSD,
 723     DFLOADf64,
 724     XFLOADf64,
 725     LIWZX
 726 )>;
 727
 728 // 4 Cycle Load uses a single slice.
 729 def : InstRW<[P9_LS_4C, IP_AGEN_1C, DISP_1C],
 730       (instrs
 731     (instregex "DCB(F|T|ST)(EP)?$"),
 732     (instregex "DCBZ(L)?(EP)?$"),
 733     (instregex "DCBTST(EP)?$"),
 734     (instregex "CP_COPY(8)?$"),
 735     (instregex "CP_PASTE(8)?$"),
 736     (instregex "ICBI(EP)?$"),
 737     (instregex "ICBT(LS)?$"),
 738     (instregex "LBARX(L)?$"),
 739     (instregex "LBZ(CIX|8|X|X8|XTLS|XTLS_32)?(_)?$"),
 740     (instregex "LD(ARX|ARXL|BRX|CIX|X|XTLS)?(_)?$"),
 741     (instregex "LH(A|B)RX(L)?(8)?$"),
 742     (instregex "LHZ(8|CIX|X|X8|XTLS|XTLS_32)?(_)?$"),
 743     (instregex "LWARX(L)?$"),
 744     (instregex "LWBRX(8)?$"),
 745     (instregex "LWZ(8|CIX|X|X8|XTLS|XTLS_32)?(_)?$"),
 746     CP_ABORT,
 747     DARN,
 748     EnforceIEIO,
 749     ISYNC,
 750     MSGSYNC,
 751     TLBSYNC,
 752     SYNC,
 753     LMW,
 754     LSWI
 755 )>;
 756
 757 // 4 Cycle Restricted load uses a single slice but the dispatch for the whole
 758 // superslice.
 759 def : InstRW<[P9_LS_4C, IP_AGEN_1C, DISP_3SLOTS_1C],
 760       (instrs
 761     LFIWZX,
 762     LFDX,
 763     LFD
 764 )>;
 765
 766 // Cracked Load Instructions.
 767 // Load instructions that can be done in parallel.
 768 def : InstRW<[P9_LS_4C, P9_LS_4C, IP_AGEN_1C, IP_AGEN_1C,
 769               DISP_PAIR_1C],
 770       (instrs
 771     SLBIA,
 772     SLBIE,
 773     SLBMFEE,
 774     SLBMFEV,
 775     SLBMTE,
 776     TLBIEL
 777 )>;
 778
 779 // Cracked Load Instruction.
 780 // Requires Load and ALU pieces totaling 6 cycles. The Load and ALU
 781 // operations can be run in parallel.
 782 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_EXEC_1C, IP_AGEN_1C,
 783               DISP_PAIR_1C, DISP_PAIR_1C],
 784       (instrs
 785     (instregex "L(W|H)ZU(X)?(8)?$")
 786 )>;
 787
 788 // Cracked TEND Instruction.
 789 // Requires Load and ALU pieces totaling 6 cycles. The Load and ALU
 790 // operations can be run in parallel.
 791 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_EXEC_1C, IP_AGEN_1C,
 792               DISP_1C, DISP_1C],
 793       (instrs
 794     TEND
 795 )>;
 796
 797
 798 // Cracked Store Instruction
 799 // Consecutive Store and ALU instructions. The store is restricted and requires
 800 // three dispatches.
 801 def : InstRW<[P9_StoreAndALUOp_3C, IP_EXEC_1C, IP_EXEC_1C, IP_AGEN_1C,
 802               DISP_3SLOTS_1C, DISP_1C],
 803       (instrs
 804     (instregex "ST(B|H|W|D)CX$")
 805 )>;
 806
 807 // Cracked Load Instruction.
 808 // Two consecutive load operations for a total of 8 cycles.
 809 def : InstRW<[P9_LoadAndLoadOp_8C, IP_AGEN_1C, IP_AGEN_1C,
 810               DISP_1C, DISP_1C],
 811       (instrs
 812     LDMX
 813 )>;
 814
 815 // Cracked Load instruction.
 816 // Requires consecutive Load and ALU pieces totaling 6 cycles. The Load and ALU
 817 // operations cannot be done at the same time and so their latencies are added.
 818 def : InstRW<[P9_LoadAndALUOp_6C, IP_EXEC_1C, IP_AGEN_1C,
 819               DISP_1C, DISP_1C],
 820       (instrs
 821     (instregex "LHA(X)?(8)?$"),
 822     (instregex "CP_PASTE(8)?o$"),
 823     (instregex "LWA(X)?(_32)?$"),
 824     TCHECK
 825 )>;
 826
 827 // Cracked Restricted Load instruction.
 828 // Requires consecutive Load and ALU pieces totaling 6 cycles. The Load and ALU
 829 // operations cannot be done at the same time and so their latencies are added.
 830 // Full 6 dispatches are required as this is both cracked and restricted.
 831 def : InstRW<[P9_LoadAndALUOp_6C, IP_EXEC_1C, IP_AGEN_1C,
 832               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
 833       (instrs
 834     LFIWAX
 835 )>;
 836
 837 // Cracked Load instruction.
 838 // Requires consecutive Load and ALU pieces totaling 7 cycles. The Load and ALU
 839 // operations cannot be done at the same time and so their latencies are added.
 840 // Full 4 dispatches are required as this is a cracked instruction.
 841 def : InstRW<[P9_LoadAndALUOp_7C, IP_AGEN_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
 842       (instrs
 843     LXSIWAX,
 844     LIWAX
 845 )>;
 846
 847 // Cracked Load instruction.
 848 // Requires consecutive Load (4 cycles) and ALU (3 cycles) pieces totaling 7
 849 // cycles. The Load and ALU operations cannot be done at the same time and so
 850 // their latencies are added.
 851 // Full 6 dispatches are required as this is a restricted instruction.
 852 def : InstRW<[P9_LoadAndALU2Op_7C, IP_AGEN_1C, IP_EXEC_1C,
 853               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
 854       (instrs
 855     LFSX,
 856     LFS
 857 )>;
 858
 859 // Cracked Load instruction.
 860 // Requires consecutive Load and ALU pieces totaling 8 cycles. The Load and ALU
 861 // operations cannot be done at the same time and so their latencies are added.
 862 // Full 4 dispatches are required as this is a cracked instruction.
 863 def : InstRW<[P9_LoadAndALU2Op_8C, IP_AGEN_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
 864       (instrs
 865     LXSSP,
 866     LXSSPX,
 867     XFLOADf32,
 868     DFLOADf32
 869 )>;
 870
 871 // Cracked 3-Way Load Instruction
 872 // Load with two ALU operations that depend on each other
 873 def : InstRW<[P9_LoadAndALUOp_6C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
 874               DISP_PAIR_1C, DISP_PAIR_1C, DISP_1C],
 875       (instrs
 876     (instregex "LHAU(X)?(8)?$"),
 877     LWAUX
 878 )>;
 879
 880 // Cracked Load that requires the PM resource.
 881 // Since the Load and the PM cannot be done at the same time the latencies are
 882 // added. Requires 8 cycles. Since the PM requires the full superslice we need
 883 // both EXECE, EXECO pipelines as well as 1 dispatch for the PM. The Load
 884 // requires the remaining 1 dispatch.
 885 def : InstRW<[P9_LoadAndPMOp_8C, IP_AGEN_1C, IP_EXECE_1C, IP_EXECO_1C,
 886               DISP_1C, DISP_1C],
 887       (instrs
 888     LXVH8X,
 889     LXVDSX,
 890     LXVW4X
 891 )>;
 892
 893 // Single slice Restricted store operation. The restricted operation requires
 894 // all three dispatches for the superslice.
 895 def : InstRW<[P9_LS_1C, IP_EXEC_1C, IP_AGEN_1C, DISP_3SLOTS_1C],
 896       (instrs
 897     (instregex "STF(S|D|IWX|SX|DX)$"),
 898     (instregex "STXS(D|DX|SPX|IWX|IBX|IHX|SP)(v)?$"),
 899     (instregex "STW(8)?$"),
 900     (instregex "(D|X)FSTORE(f32|f64)$"),
 901     (instregex "ST(W|H|D)BRX$"),
 902     (instregex "ST(B|H|D)(8)?$"),
 903     (instregex "ST(B|W|H|D)(CI)?X(TLS|TLS_32)?(8)?(_)?$"),
 904     STIWX,
 905     SLBIEG,
 906     STMW,
 907     STSWI,
 908     TLBIE
 909 )>;
 910
 911 // Vector Store Instruction
 912 // Requires the whole superslice and therefore requires one dispatch
 913 // as well as both the Even and Odd exec pipelines.
 914 def : InstRW<[P9_LS_1C, IP_EXECE_1C, IP_EXECO_1C, IP_AGEN_1C, DISP_1C],
 915       (instrs
 916     (instregex "STVE(B|H|W)X$"),
 917     (instregex "STVX(L)?$"),
 918     (instregex "STXV(B16X|H8X|W4X|D2X|L|LL|X)?$")
 919 )>;
 920
 921 // 5 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 922 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 923 // dispatches.
 924 def : InstRW<[P9_DIV_5C, IP_EXECE_1C, IP_EXECO_1C, DISP_EVEN_1C],
 925       (instrs
 926     (instregex "MTCTR(8)?(loop)?$"),
 927     (instregex "MTLR(8)?$")
 928 )>;
 929
 930 // 12 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 931 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 932 // dispatches.
 933 def : InstRW<[P9_DIV_12C, IP_EXECE_1C, IP_EXECO_1C, DISP_EVEN_1C],
 934       (instrs
 935     (instregex "M(T|F)VRSAVE(v)?$"),
 936     (instregex "M(T|F)PMR$"),
 937     (instregex "M(T|F)TB(8)?$"),
 938     (instregex "MF(SPR|CTR|LR)(8)?$"),
 939     (instregex "M(T|F)MSR(D)?$"),
 940     (instregex "MTSPR(8)?$")
 941 )>;
 942
 943 // 16 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 944 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 945 // dispatches.
 946 def : InstRW<[P9_DIV_16C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 947       (instrs
 948     DIVW,
 949     DIVWU,
 950     MODSW
 951 )>;
 952
 953 // 24 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 954 // superslice. That includes both exec pipelines (EXECO, EXECE) and two
 955 // dispatches.
 956 def : InstRW<[P9_DIV_24C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 957       (instrs
 958     DIVWE,
 959     DIVD,
 960     DIVWEU,
 961     DIVDU,
 962     MODSD,
 963     MODUD,
 964     MODUW
 965 )>;
 966
 967 // 40 Cycle DIV operation. Only one DIV unit per superslice so we use the whole
 968 // superslice. That includes both exec pipelines (EXECO, EXECE) and all three
 969 // dispatches.
 970 def : InstRW<[P9_DIV_40C_8, IP_EXECO_1C, IP_EXECE_1C, DISP_EVEN_1C],
 971       (instrs
 972     DIVDE,
 973     DIVDEU
 974 )>;
 975
 976 // Cracked DIV and ALU operation. Requires one full slice for the ALU operation
 977 // and one full superslice for the DIV operation since there is only one DIV per
 978 // superslice. Latency of DIV plus ALU is 26.
 979 def : InstRW<[P9_IntDivAndALUOp_18C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
 980               DISP_EVEN_1C, DISP_1C],
 981       (instrs
 982     (instregex "DIVW(U)?(O)?o$")
 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_26C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
 989               DISP_EVEN_1C, DISP_1C],
 990       (instrs
 991     DIVDo,
 992     DIVDUo,
 993     DIVWEo,
 994     DIVWEUo
 995 )>;
 996
 997 // Cracked DIV and ALU operation. Requires one full slice for the ALU operation
 998 // and one full superslice for the DIV operation since there is only one DIV per
 999 // superslice. Latency of DIV plus ALU is 42.
1000 def : InstRW<[P9_IntDivAndALUOp_42C_8, IP_EXECE_1C, IP_EXECO_1C, IP_EXEC_1C,
1001               DISP_EVEN_1C, DISP_1C],
1002       (instrs
1003     DIVDEo,
1004     DIVDEUo
1005 )>;
1006
1007 // CR access instructions in _BrMCR, IIC_BrMCRX.
1008
1009 // Cracked, restricted, ALU operations.
1010 // Here the two ALU ops can actually be done in parallel and therefore the
1011 // latencies are not added together. Otherwise this is like having two
1012 // instructions running together on two pipelines and 6 dispatches. ALU ops are
1013 // 2 cycles each.
1014 def : InstRW<[P9_ALU_2C, P9_ALU_2C, IP_EXEC_1C, IP_EXEC_1C,
1015               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1016       (instrs
1017     MTCRF,
1018     MTCRF8
1019 )>;
1020
1021 // Cracked ALU operations.
1022 // Here the two ALU ops can actually be done in parallel and therefore the
1023 // latencies are not added together. Otherwise this is like having two
1024 // instructions running together on two pipelines and 2 dispatches. ALU ops are
1025 // 2 cycles each.
1026 def : InstRW<[P9_ALU_2C, P9_ALU_2C, IP_EXEC_1C, IP_EXEC_1C,
1027               DISP_1C, DISP_1C],
1028       (instrs
1029     (instregex "ADDC(8)?o$"),
1030     (instregex "SUBFC(8)?o$")
1031 )>;
1032
1033 // Cracked ALU operations.
1034 // Two ALU ops can be done in parallel.
1035 // One is three cycle ALU the ohter is a two cycle ALU.
1036 // One of the ALU ops is restricted the other is not so we have a total of
1037 // 5 dispatches.
1038 def : InstRW<[P9_ALU_2C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1039               DISP_3SLOTS_1C, DISP_1C],
1040       (instrs
1041     (instregex "F(N)?ABS(D|S)o$"),
1042     (instregex "FCPSGN(D|S)o$"),
1043     (instregex "FNEG(D|S)o$"),
1044     FMRo
1045 )>;
1046
1047 // Cracked ALU operations.
1048 // Here the two ALU ops can actually be done in parallel and therefore the
1049 // latencies are not added together. Otherwise this is like having two
1050 // instructions running together on two pipelines and 2 dispatches.
1051 // ALU ops are 3 cycles each.
1052 def : InstRW<[P9_ALU_3C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1053               DISP_1C, DISP_1C],
1054       (instrs
1055     MCRFS
1056 )>;
1057
1058 // Cracked Restricted ALU operations.
1059 // Here the two ALU ops can actually be done in parallel and therefore the
1060 // latencies are not added together. Otherwise this is like having two
1061 // instructions running together on two pipelines and 6 dispatches.
1062 // ALU ops are 3 cycles each.
1063 def : InstRW<[P9_ALU_3C, P9_ALU_3C, IP_EXEC_1C, IP_EXEC_1C,
1064               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1065       (instrs
1066     (instregex "MTFSF(b|o)?$"),
1067     (instregex "MTFSFI(o)?$")
1068 )>;
1069
1070 // Cracked instruction made of two ALU ops.
1071 // The two ops cannot be done in parallel.
1072 // One of the ALU ops is restricted and takes 3 dispatches.
1073 def : InstRW<[P9_ALUOpAndALUOp_4C, IP_EXEC_1C, IP_EXEC_1C,
1074               DISP_3SLOTS_1C, DISP_1C],
1075       (instrs
1076     (instregex "RLD(I)?C(R|L)o$"),
1077     (instregex "RLW(IMI|INM|NM)(8)?o$"),
1078     (instregex "SLW(8)?o$"),
1079     (instregex "SRAW(I)?o$"),
1080     (instregex "SRW(8)?o$"),
1081     RLDICL_32o,
1082     RLDIMIo
1083 )>;
1084
1085 // Cracked instruction made of two ALU ops.
1086 // The two ops cannot be done in parallel.
1087 // Both of the ALU ops are restricted and take 3 dispatches.
1088 def : InstRW<[P9_ALU2OpAndALU2Op_6C, IP_EXEC_1C, IP_EXEC_1C,
1089               DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1090       (instrs
1091     (instregex "MFFS(L|CE|o)?$")
1092 )>;
1093
1094 // Cracked ALU instruction composed of three consecutive 2 cycle loads for a
1095 // total of 6 cycles. All of the ALU operations are also restricted so each
1096 // takes 3 dispatches for a total of 9.
1097 def : InstRW<[P9_ALUOpAndALUOpAndALUOp_6C, IP_EXEC_1C, IP_EXEC_1C, IP_EXEC_1C,
1098               DISP_3SLOTS_1C, DISP_3SLOTS_1C, DISP_3SLOTS_1C],
1099       (instrs
1100     (instregex "MFCR(8)?$")
1101 )>;
1102
1103 // Cracked instruction made of two ALU ops.
1104 // The two ops cannot be done in parallel.
1105 def : InstRW<[P9_ALUOpAndALUOp_4C, IP_EXEC_1C, IP_EXEC_1C, DISP_1C, DISP_1C],
1106       (instrs
1107     (instregex "EXTSWSLI_32_64o$"),
1108     (instregex "SRAD(I)?o$"),
1109     EXTSWSLIo,
1110     SLDo,
1111     SRDo,
1112     RLDICo
1113 )>;
1114
1115 // 33 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1116 def : InstRW<[P9_DP_33C_8, IP_EXEC_1C, DISP_3SLOTS_1C],
1117       (instrs
1118     FDIV
1119 )>;
1120
1121 // 33 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1122 def : InstRW<[P9_DPOpAndALU2Op_36C_8, IP_EXEC_1C, IP_EXEC_1C,
1123               DISP_3SLOTS_1C, DISP_1C],
1124       (instrs
1125     FDIVo
1126 )>;
1127
1128 // 36 Cycle DP Instruction.
1129 // Instruction can be done on a single slice.
1130 def : InstRW<[P9_DP_36C_10, IP_EXEC_1C, DISP_1C],
1131       (instrs
1132     XSSQRTDP
1133 )>;
1134
1135 // 36 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1136 def : InstRW<[P9_DP_36C_10, IP_EXEC_1C, DISP_3SLOTS_1C],
1137       (instrs
1138     FSQRT
1139 )>;
1140
1141 // 36 Cycle DP Vector Instruction.
1142 def : InstRW<[P9_DPE_36C_10, P9_DPO_36C_10, IP_EXECE_1C, IP_EXECO_1C,
1143               DISP_1C],
1144       (instrs
1145     XVSQRTDP
1146 )>;
1147
1148 // 27 Cycle DP Vector Instruction.
1149 def : InstRW<[P9_DPE_27C_10, P9_DPO_27C_10, IP_EXECE_1C, IP_EXECO_1C,
1150               DISP_1C],
1151       (instrs
1152     XVSQRTSP
1153 )>;
1154
1155 // 36 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1156 def : InstRW<[P9_DPOpAndALU2Op_39C_10, IP_EXEC_1C, IP_EXEC_1C,
1157               DISP_3SLOTS_1C, DISP_1C],
1158       (instrs
1159     FSQRTo
1160 )>;
1161
1162 // 26 Cycle DP Instruction.
1163 def : InstRW<[P9_DP_26C_5, IP_EXEC_1C, DISP_1C],
1164       (instrs
1165     XSSQRTSP
1166 )>;
1167
1168 // 26 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1169 def : InstRW<[P9_DP_26C_5, IP_EXEC_1C, DISP_3SLOTS_1C],
1170       (instrs
1171     FSQRTS
1172 )>;
1173
1174 // 26 Cycle DP Instruction Restricted and Cracked with 3 Cycle ALU.
1175 def : InstRW<[P9_DPOpAndALU2Op_29C_5, IP_EXEC_1C, IP_EXEC_1C,
1176               DISP_3SLOTS_1C, DISP_1C],
1177       (instrs
1178     FSQRTSo
1179 )>;
1180
1181 // 33 Cycle DP Instruction. Takes one slice and 1 dispatch.
1182 def : InstRW<[P9_DP_33C_8, IP_EXEC_1C, DISP_1C],
1183       (instrs
1184     XSDIVDP
1185 )>;
1186
1187 // 22 Cycle DP Instruction Restricted. Takes one slice and 3 dispatches.
1188 def : InstRW<[P9_DP_22C_5, IP_EXEC_1C, DISP_3SLOTS_1C],
1189       (instrs
1190     FDIVS
1191 )>;
1192
1193 // 22 Cycle DP Instruction Restricted and Cracked with 2 Cycle ALU.
1194 def : InstRW<[P9_DPOpAndALU2Op_25C_5, IP_EXEC_1C, IP_EXEC_1C,
1195               DISP_3SLOTS_1C, DISP_1C],
1196       (instrs
1197     FDIVSo
1198 )>;
1199
1200 // 22 Cycle DP Instruction. Takes one slice and 1 dispatch.
1201 def : InstRW<[P9_DP_22C_5, IP_EXEC_1C, DISP_1C],
1202       (instrs
1203     XSDIVSP
1204 )>;
1205
1206 // 24 Cycle DP Vector Instruction. Takes one full superslice.
1207 // Includes both EXECE, EXECO pipelines and 1 dispatch for the given
1208 // superslice.
1209 def : InstRW<[P9_DPE_24C_8, P9_DPO_24C_8, IP_EXECE_1C, IP_EXECO_1C,
1210               DISP_1C],
1211       (instrs
1212     XVDIVSP
1213 )>;
1214
1215 // 33 Cycle DP Vector Instruction. Takes one full superslice.
1216 // Includes both EXECE, EXECO pipelines and 1 dispatch for the given
1217 // superslice.
1218 def : InstRW<[P9_DPE_33C_8, P9_DPO_33C_8, IP_EXECE_1C, IP_EXECO_1C,
1219               DISP_1C],
1220       (instrs
1221     XVDIVDP
1222 )>;
1223
1224 // Instruction cracked into three pieces. One Load and two ALU operations.
1225 // The Load and one of the ALU ops cannot be run at the same time and so the
1226 // latencies are added together for 6 cycles. The remainaing ALU is 2 cycles.
1227 // Both the load and the ALU that depends on it are restricted and so they take
1228 // a total of 7 dispatches. The final 2 dispatches come from the second ALU op.
1229 // The two EXEC pipelines are for the 2 ALUs while the AGEN is for the load.
1230 def : InstRW<[P9_LoadAndALU2Op_7C, P9_ALU_2C,
1231               IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
1232               DISP_3SLOTS_1C, DISP_3SLOTS_1C, DISP_1C],
1233       (instrs
1234     (instregex "LF(SU|SUX)$")
1235 )>;
1236
1237 // Cracked instruction made up of a Store and an ALU. The ALU does not depend on
1238 // the store and so it can be run at the same time as the store. The store is
1239 // also restricted.
1240 def : InstRW<[P9_LS_1C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C, IP_EXEC_1C,
1241               DISP_3SLOTS_1C, DISP_1C],
1242       (instrs
1243     (instregex "STF(S|D)U(X)?$"),
1244     (instregex "ST(B|H|W|D)U(X)?(8)?$")
1245 )>;
1246
1247 // Cracked instruction made up of a Load and an ALU. The ALU does not depend on
1248 // the load and so it can be run at the same time as the load.
1249 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C,
1250               DISP_PAIR_1C, DISP_PAIR_1C],
1251       (instrs
1252     (instregex "LBZU(X)?(8)?$"),
1253     (instregex "LDU(X)?$")
1254 )>;
1255
1256 // Cracked instruction made up of a Load and an ALU. The ALU does not depend on
1257 // the load and so it can be run at the same time as the load. The load is also
1258 // restricted. 3 dispatches are from the restricted load while the other two
1259 // are from the ALU. The AGEN pipeline is from the load and the EXEC pipeline
1260 // is required for the ALU.
1261 def : InstRW<[P9_LS_4C, P9_ALU_2C, IP_AGEN_1C, IP_EXEC_1C,
1262               DISP_3SLOTS_1C, DISP_1C],
1263       (instrs
1264     (instregex "LF(DU|DUX)$")
1265 )>;
1266
1267 // Crypto Instructions
1268
1269 // 6 Cycle CY operation. Only one CY unit per CPU so we use a whole
1270 // superslice. That includes both exec pipelines (EXECO, EXECE) and one
1271 // dispatch.
1272 def : InstRW<[P9_CY_6C, IP_EXECO_1C, IP_EXECE_1C, DISP_1C],
1273       (instrs
1274     (instregex "VPMSUM(B|H|W|D)$"),
1275     (instregex "V(N)?CIPHER(LAST)?$"),
1276     VSBOX
1277 )>;
1278
1279 // Branch Instructions
1280
1281 // Two Cycle Branch
1282 def : InstRW<[P9_BR_2C, DISP_BR_1C],
1283       (instrs
1284   (instregex "BCCCTR(L)?(8)?$"),
1285   (instregex "BCCL(A|R|RL)?$"),
1286   (instregex "BCCTR(L)?(8)?(n)?$"),
1287   (instregex "BD(N)?Z(8|A|Am|Ap|m|p)?$"),
1288   (instregex "BD(N)?ZL(A|Am|Ap|R|R8|RL|RLm|RLp|Rm|Rp|m|p)?$"),
1289   (instregex "BL(_TLS|_NOP)?$"),
1290   (instregex "BL8(_TLS|_NOP|_NOP_TLS|_TLS_)?$"),
1291   (instregex "BLA(8|8_NOP)?$"),
1292   (instregex "BLR(8|L)?$"),
1293   (instregex "TAILB(A)?(8)?$"),
1294   (instregex "TAILBCTR(8)?$"),
1295   (instregex "gBC(A|Aat|CTR|CTRL|L|LA|LAat|LR|LRL|Lat|at)?$"),
1296   (instregex "BCLR(L)?(n)?$"),
1297   (instregex "BCTR(L)?(8)?$"),
1298   B,
1299   BA,
1300   BC,
1301   BCC,
1302   BCCA,
1303   BCL,
1304   BCLalways,
1305   BCLn,
1306   BCTRL8_LDinto_toc,
1307   BCn,
1308   CTRL_DEP
1309 )>;
1310
1311 // Five Cycle Branch with a 2 Cycle ALU Op
1312 // Operations must be done consecutively and not in parallel.
1313 def : InstRW<[P9_BROpAndALUOp_7C, IP_EXEC_1C, DISP_BR_1C, DISP_1C],
1314       (instrs
1315     ADDPCIS
1316 )>;
1317
1318 // Special Extracted Instructions For Atomics
1319
1320 // Atomic Load
1321 def : InstRW<[P9_LS_1C, P9_LS_1C, P9_LS_4C, P9_LS_4C, P9_LS_4C,
1322               IP_EXEC_1C, IP_EXEC_1C, IP_AGEN_1C, IP_AGEN_1C, IP_AGEN_1C,
1323               IP_AGEN_1C, IP_AGEN_1C, DISP_1C, DISP_3SLOTS_1C,
1324               DISP_3SLOTS_1C, DISP_1C, DISP_1C, DISP_1C],
1325       (instrs
1326     (instregex "L(D|W)AT$")
1327 )>;
1328
1329 // Atomic Store
1330 def : InstRW<[P9_LS_1C, P9_LS_4C, P9_LS_4C, IP_EXEC_1C, IP_AGEN_1C, IP_AGEN_1C,
1331               IP_AGEN_1C, DISP_1C, DISP_3SLOTS_1C, DISP_1C],
1332       (instrs
1333     (instregex "ST(D|W)AT$")
1334 )>;
1335
1336 // Signal Processing Engine (SPE) Instructions
1337 // These instructions are not supported on Power 9
1338 def : InstRW<[],
1339     (instrs
1340   BRINC,
1341   EVABS,
1342   EVEQV,
1343   EVMRA,
1344   EVNAND,
1345   EVNEG,
1346   (instregex "EVADD(I)?W$"),
1347   (instregex "EVADD(SM|SS|UM|US)IAAW$"),
1348   (instregex "EVAND(C)?$"),
1349   (instregex "EVCMP(EQ|GTS|GTU|LTS|LTU)$"),
1350   (instregex "EVCNTL(S|Z)W$"),
1351   (instregex "EVDIVW(S|U)$"),
1352   (instregex "EVEXTS(B|H)$"),
1353   (instregex "EVLD(H|W|D)(X)?$"),
1354   (instregex "EVLHH(E|OS|OU)SPLAT(X)?$"),
1355   (instregex "EVLWHE(X)?$"),
1356   (instregex "EVLWHO(S|U)(X)?$"),
1357   (instregex "EVLW(H|W)SPLAT(X)?$"),
1358   (instregex "EVMERGE(HI|LO|HILO|LOHI)$"),
1359   (instregex "EVMHEG(S|U)M(F|I)A(A|N)$"),
1360   (instregex "EVMHES(M|S)(F|I)(A|AA|AAW|ANW)?$"),
1361   (instregex "EVMHEU(M|S)I(A|AA|AAW|ANW)?$"),
1362   (instregex "EVMHOG(U|S)M(F|I)A(A|N)$"),
1363   (instregex "EVMHOS(M|S)(F|I)(A|AA|AAW|ANW)?$"),
1364   (instregex "EVMHOU(M|S)I(A|AA|ANW|AAW)?$"),
1365   (instregex "EVMWHS(M|S)(F|FA|I|IA)$"),
1366   (instregex "EVMWHUMI(A)?$"),
1367   (instregex "EVMWLS(M|S)IA(A|N)W$"),
1368   (instregex "EVMWLU(M|S)I(A|AA|AAW|ANW)?$"),
1369   (instregex "EVMWSM(F|I)(A|AA|AN)?$"),
1370   (instregex "EVMWSSF(A|AA|AN)?$"),
1371   (instregex "EVMWUMI(A|AA|AN)?$"),
1372   (instregex "EV(N|X)?OR(C)?$"),
1373   (instregex "EVR(LW|LWI|NDW)$"),
1374   (instregex "EVSLW(I)?$"),
1375   (instregex "EVSPLAT(F)?I$"),
1376   (instregex "EVSRW(I)?(S|U)$"),
1377   (instregex "EVST(DD|DH|DW|WHE|WHO|WWE|WWO)(X)?$"),
1378   (instregex "EVSUBF(S|U)(M|S)IAAW$"),
1379   (instregex "EVSUB(I)?FW$")
1380 )> { let Unsupported = 1; }
1381
1382 // General Instructions without scheduling support.
1383 def : InstRW<[],
1384     (instrs
1385   (instregex "(H)?RFI(D)?$"),
1386   (instregex "DSS(ALL)?$"),
1387   (instregex "DST(ST)?(T)?(64)?$"),
1388   (instregex "ICBL(C|Q)$"),
1389   (instregex "L(W|H|B)EPX$"),
1390   (instregex "ST(W|H|B)EPX$"),
1391   (instregex "(L|ST)FDEPX$"),
1392   (instregex "M(T|F)SR(IN)?$"),
1393   (instregex "M(T|F)DCR$"),
1394   (instregex "NOP_GT_PWR(6|7)$"),
1395   (instregex "TLB(IA|IVAX|SX|SX2|SX2D|LD|LI|RE|RE2|WE|WE2)$"),
1396   (instregex "WRTEE(I)?$"),
1397   ATTN,
1398   CLRBHRB,
1399   MFBHRBE,
1400   MBAR,
1401   MSYNC,
1402   SLBSYNC,
1403   SLBFEEo,
1404   NAP,
1405   STOP,
1406   TRAP,
1407   RFCI,
1408   RFDI,
1409   RFMCI,
1410   SC,
1411   DCBA,
1412   DCBI,
1413   DCCCI,
1414   ICCCI
1415 )> { let Unsupported = 1; }