lib/Target/PowerPC/PPCInstrFormats.td

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