lib/Target/PowerPC/PPCInstrFormats.td

   1 //===- PowerPCInstrFormats.td - PowerPC Instruction Formats --*- tablegen -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 //===----------------------------------------------------------------------===//
  11 //
  12 // PowerPC instruction formats
  13
  14 class I<bits<6> opcode, dag OOL, dag IOL, string asmstr, InstrItinClass itin>
  15         : Instruction {
  16   field bits<32> Inst;
  17   field bits<32> SoftFail = 0;
  18   let Size = 4;
  19
  20   bit PPC64 = 0;  // Default value, override with isPPC64
  21
  22   let Namespace = "PPC";
  23   let Inst{0-5} = opcode;
  24   let OutOperandList = OOL;
  25   let InOperandList = IOL;
  26   let AsmString = asmstr;
  27   let Itinerary = itin;
  28
  29   bits<1> PPC970_First = 0;
  30   bits<1> PPC970_Single = 0;
  31   bits<1> PPC970_Cracked = 0;
  32   bits<3> PPC970_Unit = 0;
  33
  34   /// These fields correspond to the fields in PPCInstrInfo.h.  Any changes to
  35   /// these must be reflected there!  See comments there for what these are.
  36   let TSFlags{0}   = PPC970_First;
  37   let TSFlags{1}   = PPC970_Single;
  38   let TSFlags{2}   = PPC970_Cracked;
  39   let TSFlags{5-3} = PPC970_Unit;
  40
  41   /// Indicate that the VSX instruction is to use VSX numbering/encoding.
  42   /// Since ISA 3.0, there are scalar instructions that use the upper
  43   /// half of the VSX register set only. Rather than adding further complexity
  44   /// to the register class set, the VSX registers just include the Altivec
  45   /// registers and this flag decides the numbering to be used for them.
  46   bits<1> UseVSXReg = 0;
  47   let TSFlags{6}   = UseVSXReg;
  48
  49   // Fields used for relation models.
  50   string BaseName = "";
  51
  52   // For cases where multiple instruction definitions really represent the
  53   // same underlying instruction but with one definition for 64-bit arguments
  54   // and one for 32-bit arguments, this bit breaks the degeneracy between
  55   // the two forms and allows TableGen to generate mapping tables.
  56   bit Interpretation64Bit = 0;
  57 }
  58
  59 class PPC970_DGroup_First   { bits<1> PPC970_First = 1;  }
  60 class PPC970_DGroup_Single  { bits<1> PPC970_Single = 1; }
  61 class PPC970_DGroup_Cracked { bits<1> PPC970_Cracked = 1; }
  62 class PPC970_MicroCode;
  63
  64 class PPC970_Unit_Pseudo   { bits<3> PPC970_Unit = 0;   }
  65 class PPC970_Unit_FXU      { bits<3> PPC970_Unit = 1;   }
  66 class PPC970_Unit_LSU      { bits<3> PPC970_Unit = 2;   }
  67 class PPC970_Unit_FPU      { bits<3> PPC970_Unit = 3;   }
  68 class PPC970_Unit_CRU      { bits<3> PPC970_Unit = 4;   }
  69 class PPC970_Unit_VALU     { bits<3> PPC970_Unit = 5;   }
  70 class PPC970_Unit_VPERM    { bits<3> PPC970_Unit = 6;   }
  71 class PPC970_Unit_BRU      { bits<3> PPC970_Unit = 7;   }
  72
  73 class UseVSXReg { bits<1> UseVSXReg = 1; }
  74
  75 // Two joined instructions; used to emit two adjacent instructions as one.
  76 // The itinerary from the first instruction is used for scheduling and
  77 // classification.
  78 class I2<bits<6> opcode1, bits<6> opcode2, dag OOL, dag IOL, string asmstr,
  79          InstrItinClass itin>
  80         : Instruction {
  81   field bits<64> Inst;
  82   field bits<64> SoftFail = 0;
  83   let Size = 8;
  84
  85   bit PPC64 = 0;  // Default value, override with isPPC64
  86
  87   let Namespace = "PPC";
  88   let Inst{0-5} = opcode1;
  89   let Inst{32-37} = opcode2;
  90   let OutOperandList = OOL;
  91   let InOperandList = IOL;
  92   let AsmString = asmstr;
  93   let Itinerary = itin;
  94
  95   bits<1> PPC970_First = 0;
  96   bits<1> PPC970_Single = 0;
  97   bits<1> PPC970_Cracked = 0;
  98   bits<3> PPC970_Unit = 0;
  99
 100   /// These fields correspond to the fields in PPCInstrInfo.h.  Any changes to
 101   /// these must be reflected there!  See comments there for what these are.
 102   let TSFlags{0}   = PPC970_First;
 103   let TSFlags{1}   = PPC970_Single;
 104   let TSFlags{2}   = PPC970_Cracked;
 105   let TSFlags{5-3} = PPC970_Unit;
 106
 107   // Fields used for relation models.
 108   string BaseName = "";
 109   bit Interpretation64Bit = 0;
 110 }
 111
 112 // 1.7.1 I-Form
 113 class IForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr,
 114             InstrItinClass itin, list<dag> pattern>
 115          : I<opcode, OOL, IOL, asmstr, itin> {
 116   let Pattern = pattern;
 117   bits<24> LI;
 118
 119   let Inst{6-29}  = LI;
 120   let Inst{30}    = aa;
 121   let Inst{31}    = lk;
 122 }
 123
 124 // 1.7.2 B-Form
 125 class BForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr>
 126   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 127   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 128   bits<3>  CR;
 129   bits<14> BD;
 130
 131   bits<5> BI;
 132   let BI{0-1} = BIBO{5-6};
 133   let BI{2-4} = CR{0-2};
 134
 135   let Inst{6-10}  = BIBO{4-0};
 136   let Inst{11-15} = BI;
 137   let Inst{16-29} = BD;
 138   let Inst{30}    = aa;
 139   let Inst{31}    = lk;
 140 }
 141
 142 class BForm_1<bits<6> opcode, bits<5> bo, bit aa, bit lk, dag OOL, dag IOL,
 143              string asmstr>
 144   : BForm<opcode, aa, lk, OOL, IOL, asmstr> {
 145   let BIBO{4-0} = bo;
 146   let BIBO{6-5} = 0;
 147   let CR = 0;
 148 }
 149
 150 class BForm_2<bits<6> opcode, bits<5> bo, bits<5> bi, bit aa, bit lk,
 151               dag OOL, dag IOL, string asmstr>
 152   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 153   bits<14> BD;
 154
 155   let Inst{6-10}  = bo;
 156   let Inst{11-15} = bi;
 157   let Inst{16-29} = BD;
 158   let Inst{30}    = aa;
 159   let Inst{31}    = lk;
 160 }
 161
 162 class BForm_3<bits<6> opcode, bit aa, bit lk,
 163               dag OOL, dag IOL, string asmstr>
 164   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 165   bits<5> BO;
 166   bits<5> BI;
 167   bits<14> BD;
 168
 169   let Inst{6-10}  = BO;
 170   let Inst{11-15} = BI;
 171   let Inst{16-29} = BD;
 172   let Inst{30}    = aa;
 173   let Inst{31}    = lk;
 174 }
 175
 176 class BForm_3_at<bits<6> opcode, bit aa, bit lk,
 177                  dag OOL, dag IOL, string asmstr>
 178   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 179   bits<5> BO;
 180   bits<2> at;
 181   bits<5> BI;
 182   bits<14> BD;
 183
 184   let Inst{6-8}   = BO{4-2};
 185   let Inst{9-10}  = at;
 186   let Inst{11-15} = BI;
 187   let Inst{16-29} = BD;
 188   let Inst{30}    = aa;
 189   let Inst{31}    = lk;
 190 }
 191
 192 class BForm_4<bits<6> opcode, bits<5> bo, bit aa, bit lk,
 193               dag OOL, dag IOL, string asmstr>
 194   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 195   bits<5> BI;
 196   bits<14> BD;
 197
 198   let Inst{6-10}  = bo;
 199   let Inst{11-15} = BI;
 200   let Inst{16-29} = BD;
 201   let Inst{30}    = aa;
 202   let Inst{31}    = lk;
 203 }
 204
 205 // 1.7.3 SC-Form
 206 class SCForm<bits<6> opcode, bits<1> xo,
 207                      dag OOL, dag IOL, string asmstr, InstrItinClass itin,
 208                      list<dag> pattern>
 209   : I<opcode, OOL, IOL, asmstr, itin> {
 210   bits<7>  LEV;
 211
 212   let Pattern = pattern;
 213
 214   let Inst{20-26} = LEV;
 215   let Inst{30}    = xo;
 216 }
 217
 218 // 1.7.4 D-Form
 219 class DForm_base<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 220                  InstrItinClass itin, list<dag> pattern>
 221   : I<opcode, OOL, IOL, asmstr, itin> {
 222   bits<5>  A;
 223   bits<5>  B;
 224   bits<16> C;
 225
 226   let Pattern = pattern;
 227
 228   let Inst{6-10}  = A;
 229   let Inst{11-15} = B;
 230   let Inst{16-31} = C;
 231 }
 232
 233 class DForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 234               InstrItinClass itin, list<dag> pattern>
 235   : I<opcode, OOL, IOL, asmstr, itin> {
 236   bits<5>  A;
 237   bits<21> Addr;
 238
 239   let Pattern = pattern;
 240
 241   let Inst{6-10}  = A;
 242   let Inst{11-15} = Addr{20-16}; // Base Reg
 243   let Inst{16-31} = Addr{15-0};  // Displacement
 244 }
 245
 246 class DForm_1a<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 247                InstrItinClass itin, list<dag> pattern>
 248   : I<opcode, OOL, IOL, asmstr, itin> {
 249   bits<5>  A;
 250   bits<16> C;
 251   bits<5>  B;
 252
 253   let Pattern = pattern;
 254
 255   let Inst{6-10}  = A;
 256   let Inst{11-15} = B;
 257   let Inst{16-31} = C;
 258 }
 259
 260
 261 class DForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 262               InstrItinClass itin, list<dag> pattern>
 263   : DForm_base<opcode, OOL, IOL, asmstr, itin, pattern> {
 264
 265   // Even though ADDICo does not really have an RC bit, provide
 266   // the declaration of one here so that isDOT has something to set.
 267   bit RC = 0;
 268 }
 269
 270 class DForm_2_r0<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 271                  InstrItinClass itin, list<dag> pattern>
 272   : I<opcode, OOL, IOL, asmstr, itin> {
 273   bits<5>  A;
 274   bits<16> B;
 275
 276   let Pattern = pattern;
 277
 278   let Inst{6-10}  = A;
 279   let Inst{11-15} = 0;
 280   let Inst{16-31} = B;
 281 }
 282
 283 class DForm_4<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 284               InstrItinClass itin, list<dag> pattern>
 285   : I<opcode, OOL, IOL, asmstr, itin> {
 286   bits<5>  B;
 287   bits<5>  A;
 288   bits<16> C;
 289
 290   let Pattern = pattern;
 291
 292   let Inst{6-10}  = A;
 293   let Inst{11-15} = B;
 294   let Inst{16-31} = C;
 295 }
 296
 297 class DForm_4_zero<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 298                    InstrItinClass itin, list<dag> pattern>
 299   : DForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
 300   let A = 0;
 301   let Addr = 0;
 302 }
 303
 304 class DForm_4_fixedreg_zero<bits<6> opcode, bits<5> R, dag OOL, dag IOL,
 305                             string asmstr, InstrItinClass itin,
 306                             list<dag> pattern>
 307   : DForm_4<opcode, OOL, IOL, asmstr, itin, pattern> {
 308   let A = R;
 309   let B = R;
 310   let C = 0;
 311 }
 312
 313 class IForm_and_DForm_1<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 314             dag OOL, dag IOL, string asmstr,
 315             InstrItinClass itin, list<dag> pattern>
 316          : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> {
 317   bits<5>  A;
 318   bits<21> Addr;
 319
 320   let Pattern = pattern;
 321   bits<24> LI;
 322
 323   let Inst{6-29}  = LI;
 324   let Inst{30}    = aa;
 325   let Inst{31}    = lk;
 326
 327   let Inst{38-42}  = A;
 328   let Inst{43-47} = Addr{20-16}; // Base Reg
 329   let Inst{48-63} = Addr{15-0};  // Displacement
 330 }
 331
 332 // This is used to emit BL8+NOP.
 333 class IForm_and_DForm_4_zero<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 334             dag OOL, dag IOL, string asmstr,
 335             InstrItinClass itin, list<dag> pattern>
 336          :  IForm_and_DForm_1<opcode1, aa, lk, opcode2,
 337                               OOL, IOL, asmstr, itin, pattern> {
 338   let A = 0;
 339   let Addr = 0;
 340 }
 341
 342 class DForm_5<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 343               InstrItinClass itin>
 344   : I<opcode, OOL, IOL, asmstr, itin> {
 345   bits<3>  BF;
 346   bits<1>  L;
 347   bits<5>  RA;
 348   bits<16> I;
 349
 350   let Inst{6-8}   = BF;
 351   let Inst{9}     = 0;
 352   let Inst{10}    = L;
 353   let Inst{11-15} = RA;
 354   let Inst{16-31} = I;
 355 }
 356
 357 class DForm_5_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 358                   InstrItinClass itin>
 359   : DForm_5<opcode, OOL, IOL, asmstr, itin> {
 360   let L = PPC64;
 361 }
 362
 363 class DForm_6<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 364               InstrItinClass itin>
 365   : DForm_5<opcode, OOL, IOL, asmstr, itin>;
 366
 367 class DForm_6_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 368                   InstrItinClass itin>
 369   : DForm_6<opcode, OOL, IOL, asmstr, itin> {
 370   let L = PPC64;
 371 }
 372
 373
 374 // 1.7.5 DS-Form
 375 class DSForm_1<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 376                InstrItinClass itin, list<dag> pattern>
 377          : I<opcode, OOL, IOL, asmstr, itin> {
 378   bits<5>  RST;
 379   bits<19> DS_RA;
 380
 381   let Pattern = pattern;
 382
 383   let Inst{6-10}  = RST;
 384   let Inst{11-15} = DS_RA{18-14};  // Register #
 385   let Inst{16-29} = DS_RA{13-0};   // Displacement.
 386   let Inst{30-31} = xo;
 387 }
 388
 389 // DQ-Form: [PO T RA DQ TX XO] or [PO S RA DQ SX XO]
 390 class DQ_RD6_RS5_DQ12<bits<6> opcode, bits<3> xo, dag OOL, dag IOL,
 391                       string asmstr, InstrItinClass itin, list<dag> pattern>
 392   : I<opcode, OOL, IOL, asmstr, itin> {
 393   bits<6>  XT;
 394   bits<17> DS_RA;
 395
 396   let Pattern = pattern;
 397
 398   let Inst{6-10}  = XT{4-0};
 399   let Inst{11-15} = DS_RA{16-12};  // Register #
 400   let Inst{16-27} = DS_RA{11-0};   // Displacement.
 401   let Inst{28}    = XT{5};
 402   let Inst{29-31} = xo;
 403 }
 404
 405 // 1.7.6 X-Form
 406 class XForm_base_r3xo<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 407                       InstrItinClass itin, list<dag> pattern>
 408   : I<opcode, OOL, IOL, asmstr, itin> {
 409   bits<5> RST;
 410   bits<5> A;
 411   bits<5> B;
 412
 413   let Pattern = pattern;
 414
 415   bit RC = 0;    // set by isDOT
 416
 417   let Inst{6-10}  = RST;
 418   let Inst{11-15} = A;
 419   let Inst{16-20} = B;
 420   let Inst{21-30} = xo;
 421   let Inst{31}    = RC;
 422 }
 423
 424 class XForm_tlb<bits<10> xo, dag OOL, dag IOL, string asmstr,
 425                 InstrItinClass itin> : XForm_base_r3xo<31, xo, OOL, IOL, asmstr, itin, []> {
 426   let RST = 0;
 427 }
 428
 429 class XForm_attn<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 430                  InstrItinClass itin>
 431   : I<opcode, OOL, IOL, asmstr, itin> {
 432   let Inst{21-30} = xo;
 433 }
 434
 435 // This is the same as XForm_base_r3xo, but the first two operands are swapped
 436 // when code is emitted.
 437 class XForm_base_r3xo_swapped
 438         <bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 439         InstrItinClass itin>
 440   : I<opcode, OOL, IOL, asmstr, itin> {
 441   bits<5> A;
 442   bits<5> RST;
 443   bits<5> B;
 444
 445   bit RC = 0;    // set by isDOT
 446
 447   let Inst{6-10}  = RST;
 448   let Inst{11-15} = A;
 449   let Inst{16-20} = B;
 450   let Inst{21-30} = xo;
 451   let Inst{31}    = RC;
 452 }
 453
 454
 455 class XForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 456               InstrItinClass itin, list<dag> pattern>
 457   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 458
 459 class XForm_1a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 460               InstrItinClass itin, list<dag> pattern>
 461   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 462   let RST = 0;
 463 }
 464
 465 class XForm_rs<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 466               InstrItinClass itin, list<dag> pattern>
 467   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 468   let A = 0;
 469   let B = 0;
 470 }
 471
 472 class XForm_tlbws<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 473               InstrItinClass itin, list<dag> pattern>
 474   : I<opcode, OOL, IOL, asmstr, itin> {
 475   bits<5> RST;
 476   bits<5> A;
 477   bits<1> WS;
 478
 479   let Pattern = pattern;
 480
 481   let Inst{6-10}  = RST;
 482   let Inst{11-15} = A;
 483   let Inst{20}    = WS;
 484   let Inst{21-30} = xo;
 485   let Inst{31}    = 0;
 486 }
 487
 488 class XForm_6<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 489               InstrItinClass itin, list<dag> pattern>
 490   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 491   let Pattern = pattern;
 492 }
 493
 494 class XForm_8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 495               InstrItinClass itin, list<dag> pattern>
 496   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 497
 498 class XForm_10<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 499                InstrItinClass itin, list<dag> pattern>
 500   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 501     let Pattern = pattern;
 502 }
 503
 504 class XForm_11<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 505                InstrItinClass itin, list<dag> pattern>
 506   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 507   let B = 0;
 508   let Pattern = pattern;
 509 }
 510
 511 class XForm_16<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 512                InstrItinClass itin>
 513          : I<opcode, OOL, IOL, asmstr, itin> {
 514   bits<3> BF;
 515   bits<1> L;
 516   bits<5> RA;
 517   bits<5> RB;
 518
 519   let Inst{6-8}   = BF;
 520   let Inst{9}     = 0;
 521   let Inst{10}    = L;
 522   let Inst{11-15} = RA;
 523   let Inst{16-20} = RB;
 524   let Inst{21-30} = xo;
 525   let Inst{31}    = 0;
 526 }
 527
 528 class XForm_icbt<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 529                  InstrItinClass itin>
 530          : I<opcode, OOL, IOL, asmstr, itin> {
 531   bits<4> CT;
 532   bits<5> RA;
 533   bits<5> RB;
 534
 535   let Inst{6} = 0;
 536   let Inst{7-10} = CT;
 537   let Inst{11-15} = RA;
 538   let Inst{16-20} = RB;
 539   let Inst{21-30} = xo;
 540   let Inst{31} = 0;
 541 }
 542
 543 class XForm_sr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 544                 InstrItinClass itin>
 545          : I<opcode, OOL, IOL, asmstr, itin> {
 546   bits<5> RS;
 547   bits<4> SR;
 548
 549   let Inst{6-10} = RS;
 550   let Inst{12-15} = SR;
 551   let Inst{21-30} = xo;
 552 }
 553
 554 class XForm_mbar<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 555                 InstrItinClass itin>
 556          : I<opcode, OOL, IOL, asmstr, itin> {
 557   bits<5> MO;
 558
 559   let Inst{6-10} = MO;
 560   let Inst{21-30} = xo;
 561 }
 562
 563 class XForm_srin<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 564                 InstrItinClass itin>
 565          : I<opcode, OOL, IOL, asmstr, itin> {
 566   bits<5> RS;
 567   bits<5> RB;
 568
 569   let Inst{6-10} = RS;
 570   let Inst{16-20} = RB;
 571   let Inst{21-30} = xo;
 572 }
 573
 574 class XForm_mtmsr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 575                 InstrItinClass itin>
 576          : I<opcode, OOL, IOL, asmstr, itin> {
 577   bits<5> RS;
 578   bits<1> L;
 579
 580   let Inst{6-10} = RS;
 581   let Inst{15} = L;
 582   let Inst{21-30} = xo;
 583 }
 584
 585 class XForm_16_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 586                    InstrItinClass itin>
 587   : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> {
 588   let L = PPC64;
 589 }
 590
 591 class XForm_17<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 592                InstrItinClass itin>
 593          : I<opcode, OOL, IOL, asmstr, itin> {
 594   bits<3> BF;
 595   bits<5> FRA;
 596   bits<5> FRB;
 597
 598   let Inst{6-8}   = BF;
 599   let Inst{9-10}  = 0;
 600   let Inst{11-15} = FRA;
 601   let Inst{16-20} = FRB;
 602   let Inst{21-30} = xo;
 603   let Inst{31}    = 0;
 604 }
 605
 606 // Used for QPX
 607 class XForm_18<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 608                InstrItinClass itin, list<dag> pattern>
 609          : I<opcode, OOL, IOL, asmstr, itin> {
 610   bits<5> FRT;
 611   bits<5> FRA;
 612   bits<5> FRB;
 613
 614   let Pattern = pattern;
 615
 616   let Inst{6-10}  = FRT;
 617   let Inst{11-15} = FRA;
 618   let Inst{16-20} = FRB;
 619   let Inst{21-30} = xo;
 620   let Inst{31}    = 0;
 621 }
 622
 623 class XForm_19<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 624               InstrItinClass itin, list<dag> pattern>
 625   : XForm_18<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 626   let FRA = 0;
 627 }
 628
 629 class XForm_20<bits<6> opcode, bits<6> xo, dag OOL, dag IOL, string asmstr,
 630                InstrItinClass itin, list<dag> pattern>
 631          : I<opcode, OOL, IOL, asmstr, itin> {
 632   bits<5> FRT;
 633   bits<5> FRA;
 634   bits<5> FRB;
 635   bits<4> tttt;
 636
 637   let Pattern = pattern;
 638
 639   let Inst{6-10}  = FRT;
 640   let Inst{11-15} = FRA;
 641   let Inst{16-20} = FRB;
 642   let Inst{21-24} = tttt;
 643   let Inst{25-30} = xo;
 644   let Inst{31}    = 0;
 645 }
 646
 647 class XForm_24<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 648                InstrItinClass itin, list<dag> pattern>
 649   : I<opcode, OOL, IOL, asmstr, itin> {
 650   let Pattern = pattern;
 651   let Inst{6-10}  = 31;
 652   let Inst{11-15} = 0;
 653   let Inst{16-20} = 0;
 654   let Inst{21-30} = xo;
 655   let Inst{31}    = 0;
 656 }
 657
 658 class XForm_24_sync<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 659                string asmstr, InstrItinClass itin, list<dag> pattern>
 660   : I<opcode, OOL, IOL, asmstr, itin> {
 661   bits<2> L;
 662
 663   let Pattern = pattern;
 664   let Inst{6-8}   = 0;
 665   let Inst{9-10}  = L;
 666   let Inst{11-15} = 0;
 667   let Inst{16-20} = 0;
 668   let Inst{21-30} = xo;
 669   let Inst{31}    = 0;
 670 }
 671
 672 class XForm_24_eieio<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 673                string asmstr, InstrItinClass itin, list<dag> pattern>
 674   : XForm_24_sync<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 675   let L = 0;
 676 }
 677
 678 class XForm_25<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 679                InstrItinClass itin, list<dag> pattern>
 680   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 681 }
 682
 683 class XForm_26<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 684                InstrItinClass itin, list<dag> pattern>
 685   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 686   let A = 0;
 687 }
 688
 689 class XForm_28<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 690                InstrItinClass itin, list<dag> pattern>
 691   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 692 }
 693
 694 // This is used for MFFS, MTFSB0, MTFSB1.  42 is arbitrary; this series of
 695 // numbers presumably relates to some document, but I haven't found it.
 696 class XForm_42<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 697               InstrItinClass itin, list<dag> pattern>
 698   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 699   let Pattern = pattern;
 700
 701   bit RC = 0;    // set by isDOT
 702
 703   let Inst{6-10}  = RST;
 704   let Inst{11-20} = 0;
 705   let Inst{21-30} = xo;
 706   let Inst{31}    = RC;
 707 }
 708 class XForm_43<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 709               InstrItinClass itin, list<dag> pattern>
 710   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 711   let Pattern = pattern;
 712   bits<5> FM;
 713
 714   bit RC = 0;    // set by isDOT
 715
 716   let Inst{6-10}  = FM;
 717   let Inst{11-20} = 0;
 718   let Inst{21-30} = xo;
 719   let Inst{31}    = RC;
 720 }
 721
 722 class XForm_0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 723               InstrItinClass itin, list<dag> pattern>
 724   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 725   let RST = 0;
 726   let A = 0;
 727   let B = 0;
 728 }
 729
 730 class XForm_16b<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 731               InstrItinClass itin, list<dag> pattern>
 732   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 733   let RST = 0;
 734   let A = 0;
 735 }
 736
 737 class XForm_htm0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 738                  string asmstr, InstrItinClass itin, list<dag> pattern>
 739   : I<opcode, OOL, IOL, asmstr, itin> {
 740   bit R;
 741
 742   bit RC = 1;
 743
 744   let Inst{6-9}   = 0;
 745   let Inst{10}    = R;
 746   let Inst{11-20} = 0;
 747   let Inst{21-30} = xo;
 748   let Inst{31}    = RC;
 749 }
 750
 751 class XForm_htm1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 752                  string asmstr, InstrItinClass itin, list<dag> pattern>
 753   : I<opcode, OOL, IOL, asmstr, itin> {
 754   bit A;
 755
 756   bit RC = 1;
 757
 758   let Inst{6}     = A;
 759   let Inst{7-20}  = 0;
 760   let Inst{21-30} = xo;
 761   let Inst{31}    = RC;
 762 }
 763
 764 class XForm_htm2<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 765               InstrItinClass itin, list<dag> pattern>
 766   : I<opcode, OOL, IOL, asmstr, itin> {
 767   bit L;
 768
 769   bit RC = 0;    // set by isDOT
 770
 771   let Inst{7-9}   = 0;
 772   let Inst{10}    = L;
 773   let Inst{11-20} = 0;
 774   let Inst{21-30} = xo;
 775   let Inst{31}    = RC;
 776 }
 777
 778 class XForm_htm3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 779               InstrItinClass itin, list<dag> pattern>
 780   : I<opcode, OOL, IOL, asmstr, itin> {
 781   bits<3> BF;
 782
 783   bit RC = 0;
 784
 785   let Inst{6-8}   = BF;
 786   let Inst{9-20}  = 0;
 787   let Inst{21-30} = xo;
 788   let Inst{31}    = RC;
 789 }
 790
 791 // [PO RT RA RB XO /]
 792 class X_BF3_L1_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 793                        string asmstr, InstrItinClass itin, list<dag> pattern>
 794   : I<opcode, OOL, IOL, asmstr, itin> {
 795   bits<3> BF;
 796   bits<1> L;
 797   bits<5> RA;
 798   bits<5> RB;
 799
 800   let Pattern = pattern;
 801
 802   let Inst{6-8}   = BF;
 803   let Inst{9}     = 0;
 804   let Inst{10}    = L;
 805   let Inst{11-15} = RA;
 806   let Inst{16-20} = RB;
 807   let Inst{21-30} = xo;
 808   let Inst{31}    = 0;
 809 }
 810
 811 // Same as XForm_17 but with GPR's and new naming convention
 812 class X_BF3_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 813                     string asmstr, InstrItinClass itin, list<dag> pattern>
 814          : I<opcode, OOL, IOL, asmstr, itin> {
 815   bits<3> BF;
 816   bits<5> RA;
 817   bits<5> RB;
 818
 819   let Pattern = pattern;
 820
 821   let Inst{6-8}   = BF;
 822   let Inst{9-10}  = 0;
 823   let Inst{11-15} = RA;
 824   let Inst{16-20} = RB;
 825   let Inst{21-30} = xo;
 826   let Inst{31}    = 0;
 827 }
 828
 829 // e.g. [PO VRT XO VRB XO /] or [PO VRT XO VRB XO RO]
 830 class X_RD5_XO5_RS5<bits<6> opcode, bits<5> xo2, bits<10> xo, dag OOL, dag IOL,
 831                     string asmstr, InstrItinClass itin, list<dag> pattern>
 832   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 833   let A = xo2;
 834 }
 835
 836 class X_BF3_DCMX7_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 837                       string asmstr, InstrItinClass itin, list<dag> pattern>
 838   : I<opcode, OOL, IOL, asmstr, itin> {
 839   bits<3> BF;
 840   bits<7> DCMX;
 841   bits<5> VB;
 842
 843   let Pattern = pattern;
 844
 845   let Inst{6-8}  = BF;
 846   let Inst{9-15} = DCMX;
 847   let Inst{16-20} = VB;
 848   let Inst{21-30} = xo;
 849   let Inst{31}    = 0;
 850 }
 851
 852 class X_RD6_IMM8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 853                  string asmstr, InstrItinClass itin, list<dag> pattern>
 854   : I<opcode, OOL, IOL, asmstr, itin> {
 855   bits<6> XT;
 856   bits<8> IMM8;
 857
 858   let Pattern = pattern;
 859
 860   let Inst{6-10}  = XT{4-0};
 861   let Inst{11-12} = 0;
 862   let Inst{13-20} = IMM8;
 863   let Inst{21-30} = xo;
 864   let Inst{31}    = XT{5};
 865 }
 866
 867 // XForm_base_r3xo for instructions such as P9 atomics where we don't want
 868 // to specify an SDAG pattern for matching.
 869 class X_RD5_RS5_IM5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 870                     string asmstr, InstrItinClass itin>
 871   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, []> {
 872 }
 873
 874 class X_BF3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 875             InstrItinClass itin>
 876   : XForm_17<opcode, xo, OOL, IOL, asmstr, itin> {
 877   let FRA = 0;
 878   let FRB = 0;
 879 }
 880
 881 // [PO /// L RA RB XO /]
 882 class X_L1_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 883                    string asmstr, InstrItinClass itin, list<dag> pattern>
 884   : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> {
 885   let BF = 0;
 886   let Pattern = pattern;
 887
 888   bit RC = 0;
 889   let Inst{31} = RC;
 890 }
 891
 892 // XX*-Form (VSX)
 893 class XX1Form<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 894               InstrItinClass itin, list<dag> pattern>
 895   : I<opcode, OOL, IOL, asmstr, itin> {
 896   bits<6> XT;
 897   bits<5> A;
 898   bits<5> B;
 899
 900   let Pattern = pattern;
 901
 902   let Inst{6-10}  = XT{4-0};
 903   let Inst{11-15} = A;
 904   let Inst{16-20} = B;
 905   let Inst{21-30} = xo;
 906   let Inst{31}    = XT{5};
 907 }
 908
 909 class XX1_RS6_RD5_XO<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 910                      string asmstr, InstrItinClass itin, list<dag> pattern>
 911   : XX1Form<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 912   let B = 0;
 913 }
 914
 915 class XX2Form<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 916               InstrItinClass itin, list<dag> pattern>
 917   : I<opcode, OOL, IOL, asmstr, itin> {
 918   bits<6> XT;
 919   bits<6> XB;
 920
 921   let Pattern = pattern;
 922
 923   let Inst{6-10}  = XT{4-0};
 924   let Inst{11-15} = 0;
 925   let Inst{16-20} = XB{4-0};
 926   let Inst{21-29} = xo;
 927   let Inst{30}    = XB{5};
 928   let Inst{31}    = XT{5};
 929 }
 930
 931 class XX2Form_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 932                 InstrItinClass itin, list<dag> pattern>
 933   : I<opcode, OOL, IOL, asmstr, itin> {
 934   bits<3> CR;
 935   bits<6> XB;
 936
 937   let Pattern = pattern;
 938
 939   let Inst{6-8}   = CR;
 940   let Inst{9-15}  = 0;
 941   let Inst{16-20} = XB{4-0};
 942   let Inst{21-29} = xo;
 943   let Inst{30}    = XB{5};
 944   let Inst{31}    = 0;
 945 }
 946
 947 class XX2Form_2<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 948                 InstrItinClass itin, list<dag> pattern>
 949   : I<opcode, OOL, IOL, asmstr, itin> {
 950   bits<6> XT;
 951   bits<6> XB;
 952   bits<2> D;
 953
 954   let Pattern = pattern;
 955
 956   let Inst{6-10}  = XT{4-0};
 957   let Inst{11-13} = 0;
 958   let Inst{14-15} = D;
 959   let Inst{16-20} = XB{4-0};
 960   let Inst{21-29} = xo;
 961   let Inst{30}    = XB{5};
 962   let Inst{31}    = XT{5};
 963 }
 964
 965 class XX2_RD6_UIM5_RS6<bits<6> opcode, bits<9> xo, dag OOL, dag IOL,
 966                        string asmstr, InstrItinClass itin, list<dag> pattern>
 967   : I<opcode, OOL, IOL, asmstr, itin> {
 968   bits<6> XT;
 969   bits<6> XB;
 970   bits<5> UIM5;
 971
 972   let Pattern = pattern;
 973
 974   let Inst{6-10}  = XT{4-0};
 975   let Inst{11-15} = UIM5;
 976   let Inst{16-20} = XB{4-0};
 977   let Inst{21-29} = xo;
 978   let Inst{30}    = XB{5};
 979   let Inst{31}    = XT{5};
 980 }
 981
 982 // [PO T XO B XO BX /]
 983 class XX2_RD5_XO5_RS6<bits<6> opcode, bits<5> xo2, bits<9> xo, dag OOL, dag IOL,
 984                        string asmstr, InstrItinClass itin, list<dag> pattern>
 985   : I<opcode, OOL, IOL, asmstr, itin> {
 986   bits<5> RT;
 987   bits<6> XB;
 988
 989   let Pattern = pattern;
 990
 991   let Inst{6-10}  = RT;
 992   let Inst{11-15} = xo2;
 993   let Inst{16-20} = XB{4-0};
 994   let Inst{21-29} = xo;
 995   let Inst{30}    = XB{5};
 996   let Inst{31}    = 0;
 997 }
 998
 999 // [PO T XO B XO BX TX]
1000 class XX2_RD6_XO5_RS6<bits<6> opcode, bits<5> xo2, bits<9> xo, dag OOL, dag IOL,
1001                       string asmstr, InstrItinClass itin, list<dag> pattern>
1002   : I<opcode, OOL, IOL, asmstr, itin> {
1003   bits<6> XT;
1004   bits<6> XB;
1005
1006   let Pattern = pattern;
1007
1008   let Inst{6-10}  = XT{4-0};
1009   let Inst{11-15} = xo2;
1010   let Inst{16-20} = XB{4-0};
1011   let Inst{21-29} = xo;
1012   let Inst{30}    = XB{5};
1013   let Inst{31}    = XT{5};
1014 }
1015
1016 class XX2_BF3_DCMX7_RS6<bits<6> opcode, bits<9> xo, dag OOL, dag IOL,
1017                       string asmstr, InstrItinClass itin, list<dag> pattern>
1018   : I<opcode, OOL, IOL, asmstr, itin> {
1019   bits<3> BF;
1020   bits<7> DCMX;
1021   bits<6> XB;
1022
1023   let Pattern = pattern;
1024
1025   let Inst{6-8}  = BF;
1026   let Inst{9-15} = DCMX;
1027   let Inst{16-20} = XB{4-0};
1028   let Inst{21-29} = xo;
1029   let Inst{30}    = XB{5};
1030   let Inst{31}    = 0;
1031 }
1032
1033 class XX2_RD6_DCMX7_RS6<bits<6> opcode, bits<4> xo1, bits<3> xo2,
1034                         dag OOL, dag IOL, string asmstr, InstrItinClass itin,
1035                         list<dag> pattern>
1036   : I<opcode, OOL, IOL, asmstr, itin> {
1037   bits<6> XT;
1038   bits<7> DCMX;
1039   bits<6> XB;
1040
1041   let Pattern = pattern;
1042
1043   let Inst{6-10}  = XT{4-0};
1044   let Inst{11-15} = DCMX{4-0};
1045   let Inst{16-20} = XB{4-0};
1046   let Inst{21-24} = xo1;
1047   let Inst{25}    = DCMX{5};
1048   let Inst{26-28} = xo2;
1049   let Inst{29}    = DCMX{6};
1050   let Inst{30}    = XB{5};
1051   let Inst{31}    = XT{5};
1052 }
1053
1054 class XX3Form<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1055               InstrItinClass itin, list<dag> pattern>
1056   : I<opcode, OOL, IOL, asmstr, itin> {
1057   bits<6> XT;
1058   bits<6> XA;
1059   bits<6> XB;
1060
1061   let Pattern = pattern;
1062
1063   let Inst{6-10}  = XT{4-0};
1064   let Inst{11-15} = XA{4-0};
1065   let Inst{16-20} = XB{4-0};
1066   let Inst{21-28} = xo;
1067   let Inst{29}    = XA{5};
1068   let Inst{30}    = XB{5};
1069   let Inst{31}    = XT{5};
1070 }
1071
1072 class XX3Form_Zero<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1073               InstrItinClass itin, list<dag> pattern>
1074   : XX3Form<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1075   let XA = XT;
1076   let XB = XT;
1077 }
1078
1079 class XX3Form_SetZero<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1080                InstrItinClass itin, list<dag> pattern>
1081     : XX3Form<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1082   let XB = XT;
1083   let XA = XT;
1084 }
1085
1086 class XX3Form_1<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1087                 InstrItinClass itin, list<dag> pattern>
1088   : I<opcode, OOL, IOL, asmstr, itin> {
1089   bits<3> CR;
1090   bits<6> XA;
1091   bits<6> XB;
1092
1093   let Pattern = pattern;
1094
1095   let Inst{6-8}   = CR;
1096   let Inst{9-10}  = 0;
1097   let Inst{11-15} = XA{4-0};
1098   let Inst{16-20} = XB{4-0};
1099   let Inst{21-28} = xo;
1100   let Inst{29}    = XA{5};
1101   let Inst{30}    = XB{5};
1102   let Inst{31}    = 0;
1103 }
1104
1105 class XX3Form_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1106                 InstrItinClass itin, list<dag> pattern>
1107   : I<opcode, OOL, IOL, asmstr, itin> {
1108   bits<6> XT;
1109   bits<6> XA;
1110   bits<6> XB;
1111   bits<2> D;
1112
1113   let Pattern = pattern;
1114
1115   let Inst{6-10}  = XT{4-0};
1116   let Inst{11-15} = XA{4-0};
1117   let Inst{16-20} = XB{4-0};
1118   let Inst{21}    = 0;
1119   let Inst{22-23} = D;
1120   let Inst{24-28} = xo;
1121   let Inst{29}    = XA{5};
1122   let Inst{30}    = XB{5};
1123   let Inst{31}    = XT{5};
1124 }
1125
1126 class XX3Form_Rc<bits<6> opcode, bits<7> xo, dag OOL, dag IOL, string asmstr,
1127               InstrItinClass itin, list<dag> pattern>
1128   : I<opcode, OOL, IOL, asmstr, itin> {
1129   bits<6> XT;
1130   bits<6> XA;
1131   bits<6> XB;
1132
1133   let Pattern = pattern;
1134
1135   bit RC = 0;    // set by isDOT
1136
1137   let Inst{6-10}  = XT{4-0};
1138   let Inst{11-15} = XA{4-0};
1139   let Inst{16-20} = XB{4-0};
1140   let Inst{21}    = RC;
1141   let Inst{22-28} = xo;
1142   let Inst{29}    = XA{5};
1143   let Inst{30}    = XB{5};
1144   let Inst{31}    = XT{5};
1145 }
1146
1147 class XX4Form<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
1148               InstrItinClass itin, list<dag> pattern>
1149   : I<opcode, OOL, IOL, asmstr, itin> {
1150   bits<6> XT;
1151   bits<6> XA;
1152   bits<6> XB;
1153   bits<6> XC;
1154
1155   let Pattern = pattern;
1156
1157   let Inst{6-10}  = XT{4-0};
1158   let Inst{11-15} = XA{4-0};
1159   let Inst{16-20} = XB{4-0};
1160   let Inst{21-25} = XC{4-0};
1161   let Inst{26-27} = xo;
1162   let Inst{28}    = XC{5};
1163   let Inst{29}    = XA{5};
1164   let Inst{30}    = XB{5};
1165   let Inst{31}    = XT{5};
1166 }
1167
1168 // DCB_Form - Form X instruction, used for dcb* instructions.
1169 class DCB_Form<bits<10> xo, bits<5> immfield, dag OOL, dag IOL, string asmstr,
1170                       InstrItinClass itin, list<dag> pattern>
1171   : I<31, OOL, IOL, asmstr, itin> {
1172   bits<5> A;
1173   bits<5> B;
1174
1175   let Pattern = pattern;
1176
1177   let Inst{6-10}  = immfield;
1178   let Inst{11-15} = A;
1179   let Inst{16-20} = B;
1180   let Inst{21-30} = xo;
1181   let Inst{31}    = 0;
1182 }
1183
1184 class DCB_Form_hint<bits<10> xo, dag OOL, dag IOL, string asmstr,
1185                     InstrItinClass itin, list<dag> pattern>
1186   : I<31, OOL, IOL, asmstr, itin> {
1187   bits<5> TH;
1188   bits<5> A;
1189   bits<5> B;
1190
1191   let Pattern = pattern;
1192
1193   let Inst{6-10}  = TH;
1194   let Inst{11-15} = A;
1195   let Inst{16-20} = B;
1196   let Inst{21-30} = xo;
1197   let Inst{31}    = 0;
1198 }
1199
1200 // DSS_Form - Form X instruction, used for altivec dss* instructions.
1201 class DSS_Form<bits<1> T, bits<10> xo, dag OOL, dag IOL, string asmstr,
1202                       InstrItinClass itin, list<dag> pattern>
1203   : I<31, OOL, IOL, asmstr, itin> {
1204   bits<2> STRM;
1205   bits<5> A;
1206   bits<5> B;
1207
1208   let Pattern = pattern;
1209
1210   let Inst{6}     = T;
1211   let Inst{7-8}   = 0;
1212   let Inst{9-10}  = STRM;
1213   let Inst{11-15} = A;
1214   let Inst{16-20} = B;
1215   let Inst{21-30} = xo;
1216   let Inst{31}    = 0;
1217 }
1218
1219 // 1.7.7 XL-Form
1220 class XLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1221                InstrItinClass itin, list<dag> pattern>
1222     : I<opcode, OOL, IOL, asmstr, itin> {
1223   bits<5> CRD;
1224   bits<5> CRA;
1225   bits<5> CRB;
1226
1227   let Pattern = pattern;
1228
1229   let Inst{6-10}  = CRD;
1230   let Inst{11-15} = CRA;
1231   let Inst{16-20} = CRB;
1232   let Inst{21-30} = xo;
1233   let Inst{31}    = 0;
1234 }
1235
1236 class XLForm_1_np<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1237                   InstrItinClass itin, list<dag> pattern>
1238   : XLForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1239   let CRD = 0;
1240   let CRA = 0;
1241   let CRB = 0;
1242 }
1243
1244 class XLForm_1_gen<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1245                    InstrItinClass itin, list<dag> pattern>
1246   : XLForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1247   bits<5> RT;
1248   bits<5> RB;
1249
1250   let CRD = RT;
1251   let CRA = 0;
1252   let CRB = RB;
1253 }
1254
1255 class XLForm_1_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1256                InstrItinClass itin, list<dag> pattern>
1257     : I<opcode, OOL, IOL, asmstr, itin> {
1258   bits<5> CRD;
1259
1260   let Pattern = pattern;
1261
1262   let Inst{6-10}  = CRD;
1263   let Inst{11-15} = CRD;
1264   let Inst{16-20} = CRD;
1265   let Inst{21-30} = xo;
1266   let Inst{31}    = 0;
1267 }
1268
1269 class XLForm_2<bits<6> opcode, bits<10> xo, bit lk, dag OOL, dag IOL, string asmstr,
1270                InstrItinClass itin, list<dag> pattern>
1271     : I<opcode, OOL, IOL, asmstr, itin> {
1272   bits<5> BO;
1273   bits<5> BI;
1274   bits<2> BH;
1275
1276   let Pattern = pattern;
1277
1278   let Inst{6-10}  = BO;
1279   let Inst{11-15} = BI;
1280   let Inst{16-18} = 0;
1281   let Inst{19-20} = BH;
1282   let Inst{21-30} = xo;
1283   let Inst{31}    = lk;
1284 }
1285
1286 class XLForm_2_br<bits<6> opcode, bits<10> xo, bit lk,
1287                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
1288   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
1289   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
1290   bits<3>  CR;
1291
1292   let BO = BIBO{4-0};
1293   let BI{0-1} = BIBO{5-6};
1294   let BI{2-4} = CR{0-2};
1295   let BH = 0;
1296 }
1297
1298 class XLForm_2_br2<bits<6> opcode, bits<10> xo, bits<5> bo, bit lk,
1299                    dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
1300   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
1301   let BO = bo;
1302   let BH = 0;
1303 }
1304
1305 class XLForm_2_ext<bits<6> opcode, bits<10> xo, bits<5> bo,  bits<5> bi, bit lk,
1306                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
1307   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
1308   let BO = bo;
1309   let BI = bi;
1310   let BH = 0;
1311 }
1312
1313 class XLForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1314                InstrItinClass itin>
1315          : I<opcode, OOL, IOL, asmstr, itin> {
1316   bits<3> BF;
1317   bits<3> BFA;
1318
1319   let Inst{6-8}   = BF;
1320   let Inst{9-10}  = 0;
1321   let Inst{11-13} = BFA;
1322   let Inst{14-15} = 0;
1323   let Inst{16-20} = 0;
1324   let Inst{21-30} = xo;
1325   let Inst{31}    = 0;
1326 }
1327
1328 class XLForm_4<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1329                InstrItinClass itin>
1330          : I<opcode, OOL, IOL, asmstr, itin> {
1331   bits<3> BF;
1332   bit W;
1333   bits<4> U;
1334
1335   bit RC = 0;
1336
1337   let Inst{6-8}   = BF;
1338   let Inst{9-10}  = 0;
1339   let Inst{11-14} = 0;
1340   let Inst{15}    = W;
1341   let Inst{16-19} = U;
1342   let Inst{20}    = 0;
1343   let Inst{21-30} = xo;
1344   let Inst{31}    = RC;
1345 }
1346
1347 class XLForm_S<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1348                InstrItinClass itin, list<dag> pattern>
1349     : I<opcode, OOL, IOL, asmstr, itin> {
1350   bits<1> S;
1351
1352   let Pattern = pattern;
1353
1354   let Inst{6-19}  = 0;
1355   let Inst{20}    = S;
1356   let Inst{21-30} = xo;
1357   let Inst{31}    = 0;
1358 }
1359
1360 class XLForm_2_and_DSForm_1<bits<6> opcode1, bits<10> xo1, bit lk,
1361                             bits<6> opcode2, bits<2> xo2,
1362                             dag OOL, dag IOL, string asmstr,
1363                             InstrItinClass itin, list<dag> pattern>
1364         : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> {
1365   bits<5> BO;
1366   bits<5> BI;
1367   bits<2> BH;
1368
1369   bits<5>  RST;
1370   bits<19> DS_RA;
1371
1372   let Pattern = pattern;
1373
1374   let Inst{6-10}  = BO;
1375   let Inst{11-15} = BI;
1376   let Inst{16-18} = 0;
1377   let Inst{19-20} = BH;
1378   let Inst{21-30} = xo1;
1379   let Inst{31}    = lk;
1380
1381   let Inst{38-42} = RST;
1382   let Inst{43-47} = DS_RA{18-14};  // Register #
1383   let Inst{48-61} = DS_RA{13-0};   // Displacement.
1384   let Inst{62-63} = xo2;
1385 }
1386
1387 class XLForm_2_ext_and_DSForm_1<bits<6> opcode1, bits<10> xo1,
1388                                 bits<5> bo, bits<5> bi, bit lk,
1389                                 bits<6> opcode2, bits<2> xo2,
1390                                 dag OOL, dag IOL, string asmstr,
1391                                 InstrItinClass itin, list<dag> pattern>
1392   : XLForm_2_and_DSForm_1<opcode1, xo1, lk, opcode2, xo2,
1393                           OOL, IOL, asmstr, itin, pattern> {
1394   let BO = bo;
1395   let BI = bi;
1396   let BH = 0;
1397 }
1398
1399 // 1.7.8 XFX-Form
1400 class XFXForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1401                 InstrItinClass itin>
1402          : I<opcode, OOL, IOL, asmstr, itin> {
1403   bits<5>  RT;
1404   bits<10> SPR;
1405
1406   let Inst{6-10}  = RT;
1407   let Inst{11}    = SPR{4};
1408   let Inst{12}    = SPR{3};
1409   let Inst{13}    = SPR{2};
1410   let Inst{14}    = SPR{1};
1411   let Inst{15}    = SPR{0};
1412   let Inst{16}    = SPR{9};
1413   let Inst{17}    = SPR{8};
1414   let Inst{18}    = SPR{7};
1415   let Inst{19}    = SPR{6};
1416   let Inst{20}    = SPR{5};
1417   let Inst{21-30} = xo;
1418   let Inst{31}    = 0;
1419 }
1420
1421 class XFXForm_1_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
1422                    dag OOL, dag IOL, string asmstr, InstrItinClass itin>
1423   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin> {
1424   let SPR = spr;
1425 }
1426
1427 class XFXForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1428                 InstrItinClass itin>
1429          : I<opcode, OOL, IOL, asmstr, itin> {
1430   bits<5>  RT;
1431
1432   let Inst{6-10}  = RT;
1433   let Inst{11-20} = 0;
1434   let Inst{21-30} = xo;
1435   let Inst{31}    = 0;
1436 }
1437
1438 class XFXForm_3p<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1439                  InstrItinClass itin, list<dag> pattern>
1440          : I<opcode, OOL, IOL, asmstr, itin> {
1441   bits<5>  RT;
1442   bits<10> Entry;
1443   let Pattern = pattern;
1444
1445   let Inst{6-10}  = RT;
1446   let Inst{11-20} = Entry;
1447   let Inst{21-30} = xo;
1448   let Inst{31}    = 0;
1449 }
1450
1451 class XFXForm_5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1452                 InstrItinClass itin>
1453   : I<opcode, OOL, IOL, asmstr, itin> {
1454   bits<8>  FXM;
1455   bits<5>  rS;
1456
1457   let Inst{6-10}  = rS;
1458   let Inst{11}    = 0;
1459   let Inst{12-19} = FXM;
1460   let Inst{20}    = 0;
1461   let Inst{21-30} = xo;
1462   let Inst{31}    = 0;
1463 }
1464
1465 class XFXForm_5a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1466                  InstrItinClass itin>
1467   : I<opcode, OOL, IOL, asmstr, itin> {
1468   bits<5>  ST;
1469   bits<8>  FXM;
1470
1471   let Inst{6-10}  = ST;
1472   let Inst{11}    = 1;
1473   let Inst{12-19} = FXM;
1474   let Inst{20}    = 0;
1475   let Inst{21-30} = xo;
1476   let Inst{31}    = 0;
1477 }
1478
1479 class XFXForm_7<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1480                 InstrItinClass itin>
1481   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin>;
1482
1483 class XFXForm_7_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
1484                     dag OOL, dag IOL, string asmstr, InstrItinClass itin>
1485   : XFXForm_7<opcode, xo, OOL, IOL, asmstr, itin> {
1486   let SPR = spr;
1487 }
1488
1489 // XFL-Form - MTFSF
1490 // This is probably 1.7.9, but I don't have the reference that uses this
1491 // numbering scheme...
1492 class XFLForm<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1493               InstrItinClass itin, list<dag>pattern>
1494   : I<opcode, OOL, IOL, asmstr, itin> {
1495   bits<8> FM;
1496   bits<5> rT;
1497
1498   bit RC = 0;    // set by isDOT
1499   let Pattern = pattern;
1500
1501   let Inst{6} = 0;
1502   let Inst{7-14}  = FM;
1503   let Inst{15} = 0;
1504   let Inst{16-20} = rT;
1505   let Inst{21-30} = xo;
1506   let Inst{31}    = RC;
1507 }
1508
1509 class XFLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
1510                 InstrItinClass itin, list<dag>pattern>
1511   : I<opcode, OOL, IOL, asmstr, itin> {
1512   bit L;
1513   bits<8> FLM;
1514   bit W;
1515   bits<5> FRB;
1516
1517   bit RC = 0;    // set by isDOT
1518   let Pattern = pattern;
1519
1520   let Inst{6}     = L;
1521   let Inst{7-14}  = FLM;
1522   let Inst{15}    = W;
1523   let Inst{16-20} = FRB;
1524   let Inst{21-30} = xo;
1525   let Inst{31}    = RC;
1526 }
1527
1528 // 1.7.10 XS-Form - SRADI.
1529 class XSForm_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
1530                InstrItinClass itin, list<dag> pattern>
1531          : I<opcode, OOL, IOL, asmstr, itin> {
1532   bits<5> A;
1533   bits<5> RS;
1534   bits<6> SH;
1535
1536   bit RC = 0;    // set by isDOT
1537   let Pattern = pattern;
1538
1539   let Inst{6-10}  = RS;
1540   let Inst{11-15} = A;
1541   let Inst{16-20} = SH{4,3,2,1,0};
1542   let Inst{21-29} = xo;
1543   let Inst{30}    = SH{5};
1544   let Inst{31}    = RC;
1545 }
1546
1547 // 1.7.11 XO-Form
1548 class XOForm_1<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL, string asmstr,
1549                InstrItinClass itin, list<dag> pattern>
1550          : I<opcode, OOL, IOL, asmstr, itin> {
1551   bits<5> RT;
1552   bits<5> RA;
1553   bits<5> RB;
1554
1555   let Pattern = pattern;
1556
1557   bit RC = 0;    // set by isDOT
1558
1559   let Inst{6-10}  = RT;
1560   let Inst{11-15} = RA;
1561   let Inst{16-20} = RB;
1562   let Inst{21}    = oe;
1563   let Inst{22-30} = xo;
1564   let Inst{31}    = RC;
1565 }
1566
1567 class XOForm_3<bits<6> opcode, bits<9> xo, bit oe,
1568                dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
1569   : XOForm_1<opcode, xo, oe, OOL, IOL, asmstr, itin, pattern> {
1570   let RB = 0;
1571 }
1572
1573 // 1.7.12 A-Form
1574 class AForm_1<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1575               InstrItinClass itin, list<dag> pattern>
1576          : I<opcode, OOL, IOL, asmstr, itin> {
1577   bits<5> FRT;
1578   bits<5> FRA;
1579   bits<5> FRC;
1580   bits<5> FRB;
1581
1582   let Pattern = pattern;
1583
1584   bit RC = 0;    // set by isDOT
1585
1586   let Inst{6-10}  = FRT;
1587   let Inst{11-15} = FRA;
1588   let Inst{16-20} = FRB;
1589   let Inst{21-25} = FRC;
1590   let Inst{26-30} = xo;
1591   let Inst{31}    = RC;
1592 }
1593
1594 class AForm_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1595               InstrItinClass itin, list<dag> pattern>
1596   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1597   let FRC = 0;
1598 }
1599
1600 class AForm_3<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1601               InstrItinClass itin, list<dag> pattern>
1602   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1603   let FRB = 0;
1604 }
1605
1606 class AForm_4<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1607               InstrItinClass itin, list<dag> pattern>
1608          : I<opcode, OOL, IOL, asmstr, itin> {
1609   bits<5> RT;
1610   bits<5> RA;
1611   bits<5> RB;
1612   bits<5> COND;
1613
1614   let Pattern = pattern;
1615
1616   let Inst{6-10}  = RT;
1617   let Inst{11-15} = RA;
1618   let Inst{16-20} = RB;
1619   let Inst{21-25} = COND;
1620   let Inst{26-30} = xo;
1621   let Inst{31}    = 0;
1622 }
1623
1624 // Used for QPX
1625 class AForm_4a<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1626               InstrItinClass itin, list<dag> pattern>
1627   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1628   let FRA = 0;
1629   let FRC = 0;
1630 }
1631
1632 // 1.7.13 M-Form
1633 class MForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
1634               InstrItinClass itin, list<dag> pattern>
1635     : I<opcode, OOL, IOL, asmstr, itin> {
1636   bits<5> RA;
1637   bits<5> RS;
1638   bits<5> RB;
1639   bits<5> MB;
1640   bits<5> ME;
1641
1642   let Pattern = pattern;
1643
1644   bit RC = 0;    // set by isDOT
1645
1646   let Inst{6-10}  = RS;
1647   let Inst{11-15} = RA;
1648   let Inst{16-20} = RB;
1649   let Inst{21-25} = MB;
1650   let Inst{26-30} = ME;
1651   let Inst{31}    = RC;
1652 }
1653
1654 class MForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
1655               InstrItinClass itin, list<dag> pattern>
1656   : MForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
1657 }
1658
1659 // 1.7.14 MD-Form
1660 class MDForm_1<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, string asmstr,
1661                InstrItinClass itin, list<dag> pattern>
1662     : I<opcode, OOL, IOL, asmstr, itin> {
1663   bits<5> RA;
1664   bits<5> RS;
1665   bits<6> SH;
1666   bits<6> MBE;
1667
1668   let Pattern = pattern;
1669
1670   bit RC = 0;    // set by isDOT
1671
1672   let Inst{6-10}  = RS;
1673   let Inst{11-15} = RA;
1674   let Inst{16-20} = SH{4,3,2,1,0};
1675   let Inst{21-26} = MBE{4,3,2,1,0,5};
1676   let Inst{27-29} = xo;
1677   let Inst{30}    = SH{5};
1678   let Inst{31}    = RC;
1679 }
1680
1681 class MDSForm_1<bits<6> opcode, bits<4> xo, dag OOL, dag IOL, string asmstr,
1682                 InstrItinClass itin, list<dag> pattern>
1683     : I<opcode, OOL, IOL, asmstr, itin> {
1684   bits<5> RA;
1685   bits<5> RS;
1686   bits<5> RB;
1687   bits<6> MBE;
1688
1689   let Pattern = pattern;
1690
1691   bit RC = 0;    // set by isDOT
1692
1693   let Inst{6-10}  = RS;
1694   let Inst{11-15} = RA;
1695   let Inst{16-20} = RB;
1696   let Inst{21-26} = MBE{4,3,2,1,0,5};
1697   let Inst{27-30} = xo;
1698   let Inst{31}    = RC;
1699 }
1700
1701
1702 // E-1 VA-Form
1703
1704 // VAForm_1 - DACB ordering.
1705 class VAForm_1<bits<6> xo, dag OOL, dag IOL, string asmstr,
1706                InstrItinClass itin, list<dag> pattern>
1707     : I<4, OOL, IOL, asmstr, itin> {
1708   bits<5> VD;
1709   bits<5> VA;
1710   bits<5> VC;
1711   bits<5> VB;
1712
1713   let Pattern = pattern;
1714
1715   let Inst{6-10}  = VD;
1716   let Inst{11-15} = VA;
1717   let Inst{16-20} = VB;
1718   let Inst{21-25} = VC;
1719   let Inst{26-31} = xo;
1720 }
1721
1722 // VAForm_1a - DABC ordering.
1723 class VAForm_1a<bits<6> xo, dag OOL, dag IOL, string asmstr,
1724                 InstrItinClass itin, list<dag> pattern>
1725     : I<4, OOL, IOL, asmstr, itin> {
1726   bits<5> VD;
1727   bits<5> VA;
1728   bits<5> VB;
1729   bits<5> VC;
1730
1731   let Pattern = pattern;
1732
1733   let Inst{6-10}  = VD;
1734   let Inst{11-15} = VA;
1735   let Inst{16-20} = VB;
1736   let Inst{21-25} = VC;
1737   let Inst{26-31} = xo;
1738 }
1739
1740 class VAForm_2<bits<6> xo, dag OOL, dag IOL, string asmstr,
1741                InstrItinClass itin, list<dag> pattern>
1742     : I<4, OOL, IOL, asmstr, itin> {
1743   bits<5> VD;
1744   bits<5> VA;
1745   bits<5> VB;
1746   bits<4> SH;
1747
1748   let Pattern = pattern;
1749
1750   let Inst{6-10}  = VD;
1751   let Inst{11-15} = VA;
1752   let Inst{16-20} = VB;
1753   let Inst{21}    = 0;
1754   let Inst{22-25} = SH;
1755   let Inst{26-31} = xo;
1756 }
1757
1758 // E-2 VX-Form
1759 class VXForm_1<bits<11> xo, dag OOL, dag IOL, string asmstr,
1760                InstrItinClass itin, list<dag> pattern>
1761     : I<4, OOL, IOL, asmstr, itin> {
1762   bits<5> VD;
1763   bits<5> VA;
1764   bits<5> VB;
1765
1766   let Pattern = pattern;
1767
1768   let Inst{6-10}  = VD;
1769   let Inst{11-15} = VA;
1770   let Inst{16-20} = VB;
1771   let Inst{21-31} = xo;
1772 }
1773
1774 class VXForm_setzero<bits<11> xo, dag OOL, dag IOL, string asmstr,
1775                InstrItinClass itin, list<dag> pattern>
1776     : VXForm_1<xo, OOL, IOL, asmstr, itin, pattern> {
1777   let VA = VD;
1778   let VB = VD;
1779 }
1780
1781
1782 class VXForm_2<bits<11> xo, dag OOL, dag IOL, string asmstr,
1783                InstrItinClass itin, list<dag> pattern>
1784     : I<4, OOL, IOL, asmstr, itin> {
1785   bits<5> VD;
1786   bits<5> VB;
1787
1788   let Pattern = pattern;
1789
1790   let Inst{6-10}  = VD;
1791   let Inst{11-15} = 0;
1792   let Inst{16-20} = VB;
1793   let Inst{21-31} = xo;
1794 }
1795
1796 class VXForm_3<bits<11> xo, dag OOL, dag IOL, string asmstr,
1797                InstrItinClass itin, list<dag> pattern>
1798     : I<4, OOL, IOL, asmstr, itin> {
1799   bits<5> VD;
1800   bits<5> IMM;
1801
1802   let Pattern = pattern;
1803
1804   let Inst{6-10}  = VD;
1805   let Inst{11-15} = IMM;
1806   let Inst{16-20} = 0;
1807   let Inst{21-31} = xo;
1808 }
1809
1810 /// VXForm_4 - VX instructions with "VD,0,0" register fields, like mfvscr.
1811 class VXForm_4<bits<11> xo, dag OOL, dag IOL, string asmstr,
1812                InstrItinClass itin, list<dag> pattern>
1813     : I<4, OOL, IOL, asmstr, itin> {
1814   bits<5> VD;
1815
1816   let Pattern = pattern;
1817
1818   let Inst{6-10}  = VD;
1819   let Inst{11-15} = 0;
1820   let Inst{16-20} = 0;
1821   let Inst{21-31} = xo;
1822 }
1823
1824 /// VXForm_5 - VX instructions with "0,0,VB" register fields, like mtvscr.
1825 class VXForm_5<bits<11> xo, dag OOL, dag IOL, string asmstr,
1826                InstrItinClass itin, list<dag> pattern>
1827     : I<4, OOL, IOL, asmstr, itin> {
1828   bits<5> VB;
1829
1830   let Pattern = pattern;
1831
1832   let Inst{6-10}  = 0;
1833   let Inst{11-15} = 0;
1834   let Inst{16-20} = VB;
1835   let Inst{21-31} = xo;
1836 }
1837
1838 // e.g. [PO VRT EO VRB XO]
1839 class VXForm_RD5_XO5_RS5<bits<11> xo, bits<5> eo, dag OOL, dag IOL,
1840                          string asmstr, InstrItinClass itin, list<dag> pattern>
1841     : I<4, OOL, IOL, asmstr, itin> {
1842   bits<5> RD;
1843   bits<5> VB;
1844
1845   let Pattern = pattern;
1846
1847   let Inst{6-10}  = RD;
1848   let Inst{11-15} = eo;
1849   let Inst{16-20} = VB;
1850   let Inst{21-31} = xo;
1851 }
1852
1853 /// VXForm_CR - VX crypto instructions with "VRT, VRA, ST, SIX"
1854 class VXForm_CR<bits<11> xo, dag OOL, dag IOL, string asmstr,
1855                InstrItinClass itin, list<dag> pattern>
1856     : I<4, OOL, IOL, asmstr, itin> {
1857   bits<5> VD;
1858   bits<5> VA;
1859   bits<1> ST;
1860   bits<4> SIX;
1861
1862   let Pattern = pattern;
1863
1864   let Inst{6-10}  = VD;
1865   let Inst{11-15} = VA;
1866   let Inst{16} =  ST;
1867   let Inst{17-20} = SIX;
1868   let Inst{21-31} = xo;
1869 }
1870
1871 /// VXForm_BX - VX crypto instructions with "VRT, VRA, 0 - like vsbox"
1872 class VXForm_BX<bits<11> xo, dag OOL, dag IOL, string asmstr,
1873                InstrItinClass itin, list<dag> pattern>
1874     : I<4, OOL, IOL, asmstr, itin> {
1875   bits<5> VD;
1876   bits<5> VA;
1877
1878   let Pattern = pattern;
1879
1880   let Inst{6-10}  = VD;
1881   let Inst{11-15} = VA;
1882   let Inst{16-20} = 0;
1883   let Inst{21-31} = xo;
1884 }
1885
1886 // E-4 VXR-Form
1887 class VXRForm_1<bits<10> xo, dag OOL, dag IOL, string asmstr,
1888                InstrItinClass itin, list<dag> pattern>
1889     : I<4, OOL, IOL, asmstr, itin> {
1890   bits<5> VD;
1891   bits<5> VA;
1892   bits<5> VB;
1893   bit RC = 0;
1894
1895   let Pattern = pattern;
1896
1897   let Inst{6-10}  = VD;
1898   let Inst{11-15} = VA;
1899   let Inst{16-20} = VB;
1900   let Inst{21}    = RC;
1901   let Inst{22-31} = xo;
1902 }
1903
1904 // VX-Form: [PO VRT EO VRB 1 PS XO]
1905 class VX_RD5_EO5_RS5_PS1_XO9<bits<5> eo, bits<9> xo,
1906                              dag OOL, dag IOL, string asmstr,
1907                              InstrItinClass itin, list<dag> pattern>
1908   : I<4, OOL, IOL, asmstr, itin> {
1909   bits<5> VD;
1910   bits<5> VB;
1911   bit PS;
1912
1913   let Pattern = pattern;
1914
1915   let Inst{6-10}  = VD;
1916   let Inst{11-15} = eo;
1917   let Inst{16-20} = VB;
1918   let Inst{21}    = 1;
1919   let Inst{22}    = PS;
1920   let Inst{23-31} = xo;
1921 }
1922
1923 // VX-Form: [PO VRT VRA VRB 1 PS XO] or [PO VRT VRA VRB 1 / XO]
1924 class VX_RD5_RSp5_PS1_XO9<bits<9> xo, dag OOL, dag IOL, string asmstr,
1925                           InstrItinClass itin, list<dag> pattern>
1926   : I<4, OOL, IOL, asmstr, itin> {
1927   bits<5> VD;
1928   bits<5> VA;
1929   bits<5> VB;
1930   bit PS;
1931
1932   let Pattern = pattern;
1933
1934   let Inst{6-10}  = VD;
1935   let Inst{11-15} = VA;
1936   let Inst{16-20} = VB;
1937   let Inst{21}    = 1;
1938   let Inst{22}    = PS;
1939   let Inst{23-31} = xo;
1940 }
1941
1942 // Z23-Form (used by QPX)
1943 class Z23Form_1<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1944               InstrItinClass itin, list<dag> pattern>
1945          : I<opcode, OOL, IOL, asmstr, itin> {
1946   bits<5> FRT;
1947   bits<5> FRA;
1948   bits<5> FRB;
1949   bits<2> idx;
1950
1951   let Pattern = pattern;
1952
1953   bit RC = 0;    // set by isDOT
1954
1955   let Inst{6-10}  = FRT;
1956   let Inst{11-15} = FRA;
1957   let Inst{16-20} = FRB;
1958   let Inst{21-22} = idx;
1959   let Inst{23-30} = xo;
1960   let Inst{31}    = RC;
1961 }
1962
1963 class Z23Form_2<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1964               InstrItinClass itin, list<dag> pattern>
1965   : Z23Form_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1966   let FRB = 0;
1967 }
1968
1969 class Z23Form_3<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
1970               InstrItinClass itin, list<dag> pattern>
1971          : I<opcode, OOL, IOL, asmstr, itin> {
1972   bits<5> FRT;
1973   bits<12> idx;
1974
1975   let Pattern = pattern;
1976
1977   bit RC = 0;    // set by isDOT
1978
1979   let Inst{6-10}  = FRT;
1980   let Inst{11-22} = idx;
1981   let Inst{23-30} = xo;
1982   let Inst{31}    = RC;
1983 }
1984
1985 //===----------------------------------------------------------------------===//
1986 class Pseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern>
1987     : I<0, OOL, IOL, asmstr, NoItinerary> {
1988   let isCodeGenOnly = 1;
1989   let PPC64 = 0;
1990   let Pattern = pattern;
1991   let Inst{31-0} = 0;
1992 }