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   // Fields used for relation models.
  42   string BaseName = "";
  43
  44   // For cases where multiple instruction definitions really represent the
  45   // same underlying instruction but with one definition for 64-bit arguments
  46   // and one for 32-bit arguments, this bit breaks the degeneracy between
  47   // the two forms and allows TableGen to generate mapping tables.
  48   bit Interpretation64Bit = 0;
  49 }
  50
  51 class PPC970_DGroup_First   { bits<1> PPC970_First = 1;  }
  52 class PPC970_DGroup_Single  { bits<1> PPC970_Single = 1; }
  53 class PPC970_DGroup_Cracked { bits<1> PPC970_Cracked = 1; }
  54 class PPC970_MicroCode;
  55
  56 class PPC970_Unit_Pseudo   { bits<3> PPC970_Unit = 0;   }
  57 class PPC970_Unit_FXU      { bits<3> PPC970_Unit = 1;   }
  58 class PPC970_Unit_LSU      { bits<3> PPC970_Unit = 2;   }
  59 class PPC970_Unit_FPU      { bits<3> PPC970_Unit = 3;   }
  60 class PPC970_Unit_CRU      { bits<3> PPC970_Unit = 4;   }
  61 class PPC970_Unit_VALU     { bits<3> PPC970_Unit = 5;   }
  62 class PPC970_Unit_VPERM    { bits<3> PPC970_Unit = 6;   }
  63 class PPC970_Unit_BRU      { bits<3> PPC970_Unit = 7;   }
  64
  65 // Two joined instructions; used to emit two adjacent instructions as one.
  66 // The itinerary from the first instruction is used for scheduling and
  67 // classification.
  68 class I2<bits<6> opcode1, bits<6> opcode2, dag OOL, dag IOL, string asmstr,
  69          InstrItinClass itin>
  70         : Instruction {
  71   field bits<64> Inst;
  72   field bits<64> SoftFail = 0;
  73   let Size = 8;
  74
  75   bit PPC64 = 0;  // Default value, override with isPPC64
  76
  77   let Namespace = "PPC";
  78   let Inst{0-5} = opcode1;
  79   let Inst{32-37} = opcode2;
  80   let OutOperandList = OOL;
  81   let InOperandList = IOL;
  82   let AsmString = asmstr;
  83   let Itinerary = itin;
  84
  85   bits<1> PPC970_First = 0;
  86   bits<1> PPC970_Single = 0;
  87   bits<1> PPC970_Cracked = 0;
  88   bits<3> PPC970_Unit = 0;
  89
  90   /// These fields correspond to the fields in PPCInstrInfo.h.  Any changes to
  91   /// these must be reflected there!  See comments there for what these are.
  92   let TSFlags{0}   = PPC970_First;
  93   let TSFlags{1}   = PPC970_Single;
  94   let TSFlags{2}   = PPC970_Cracked;
  95   let TSFlags{5-3} = PPC970_Unit;
  96
  97   // Fields used for relation models.
  98   string BaseName = "";
  99   bit Interpretation64Bit = 0;
 100 }
 101
 102 // 1.7.1 I-Form
 103 class IForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr,
 104             InstrItinClass itin, list<dag> pattern>
 105          : I<opcode, OOL, IOL, asmstr, itin> {
 106   let Pattern = pattern;
 107   bits<24> LI;
 108
 109   let Inst{6-29}  = LI;
 110   let Inst{30}    = aa;
 111   let Inst{31}    = lk;
 112 }
 113
 114 // 1.7.2 B-Form
 115 class BForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr>
 116   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 117   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 118   bits<3>  CR;
 119   bits<14> BD;
 120
 121   bits<5> BI;
 122   let BI{0-1} = BIBO{5-6};
 123   let BI{2-4} = CR{0-2};
 124
 125   let Inst{6-10}  = BIBO{4-0};
 126   let Inst{11-15} = BI;
 127   let Inst{16-29} = BD;
 128   let Inst{30}    = aa;
 129   let Inst{31}    = lk;
 130 }
 131
 132 class BForm_1<bits<6> opcode, bits<5> bo, bit aa, bit lk, dag OOL, dag IOL,
 133              string asmstr>
 134   : BForm<opcode, aa, lk, OOL, IOL, asmstr> {
 135   let BIBO{4-0} = bo;
 136   let BIBO{6-5} = 0;
 137   let CR = 0;
 138 }
 139
 140 class BForm_2<bits<6> opcode, bits<5> bo, bits<5> bi, bit aa, bit lk,
 141               dag OOL, dag IOL, string asmstr>
 142   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 143   bits<14> BD;
 144
 145   let Inst{6-10}  = bo;
 146   let Inst{11-15} = bi;
 147   let Inst{16-29} = BD;
 148   let Inst{30}    = aa;
 149   let Inst{31}    = lk;
 150 }
 151
 152 class BForm_3<bits<6> opcode, bit aa, bit lk,
 153               dag OOL, dag IOL, string asmstr>
 154   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 155   bits<5> BO;
 156   bits<5> BI;
 157   bits<14> BD;
 158
 159   let Inst{6-10}  = BO;
 160   let Inst{11-15} = BI;
 161   let Inst{16-29} = BD;
 162   let Inst{30}    = aa;
 163   let Inst{31}    = lk;
 164 }
 165
 166 class BForm_4<bits<6> opcode, bits<5> bo, bit aa, bit lk,
 167               dag OOL, dag IOL, string asmstr>
 168   : I<opcode, OOL, IOL, asmstr, IIC_BrB> {
 169   bits<5> BI;
 170   bits<14> BD;
 171
 172   let Inst{6-10}  = bo;
 173   let Inst{11-15} = BI;
 174   let Inst{16-29} = BD;
 175   let Inst{30}    = aa;
 176   let Inst{31}    = lk;
 177 }
 178
 179 // 1.7.3 SC-Form
 180 class SCForm<bits<6> opcode, bits<1> xo,
 181                      dag OOL, dag IOL, string asmstr, InstrItinClass itin,
 182                      list<dag> pattern>
 183   : I<opcode, OOL, IOL, asmstr, itin> {
 184   bits<7>  LEV;
 185
 186   let Pattern = pattern;
 187
 188   let Inst{20-26} = LEV;
 189   let Inst{30}    = xo;
 190 }
 191
 192 // 1.7.4 D-Form
 193 class DForm_base<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 194                  InstrItinClass itin, list<dag> pattern>
 195   : I<opcode, OOL, IOL, asmstr, itin> {
 196   bits<5>  A;
 197   bits<5>  B;
 198   bits<16> C;
 199
 200   let Pattern = pattern;
 201
 202   let Inst{6-10}  = A;
 203   let Inst{11-15} = B;
 204   let Inst{16-31} = C;
 205 }
 206
 207 class DForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 208               InstrItinClass itin, list<dag> pattern>
 209   : I<opcode, OOL, IOL, asmstr, itin> {
 210   bits<5>  A;
 211   bits<21> Addr;
 212
 213   let Pattern = pattern;
 214
 215   let Inst{6-10}  = A;
 216   let Inst{11-15} = Addr{20-16}; // Base Reg
 217   let Inst{16-31} = Addr{15-0};  // Displacement
 218 }
 219
 220 class DForm_1a<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 221                InstrItinClass itin, list<dag> pattern>
 222   : I<opcode, OOL, IOL, asmstr, itin> {
 223   bits<5>  A;
 224   bits<16> C;
 225   bits<5>  B;
 226
 227   let Pattern = pattern;
 228
 229   let Inst{6-10}  = A;
 230   let Inst{11-15} = B;
 231   let Inst{16-31} = C;
 232 }
 233
 234
 235 class DForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 236               InstrItinClass itin, list<dag> pattern>
 237   : DForm_base<opcode, OOL, IOL, asmstr, itin, pattern> {
 238
 239   // Even though ADDICo does not really have an RC bit, provide
 240   // the declaration of one here so that isDOT has something to set.
 241   bit RC = 0;
 242 }
 243
 244 class DForm_2_r0<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 245                  InstrItinClass itin, list<dag> pattern>
 246   : I<opcode, OOL, IOL, asmstr, itin> {
 247   bits<5>  A;
 248   bits<16> B;
 249
 250   let Pattern = pattern;
 251
 252   let Inst{6-10}  = A;
 253   let Inst{11-15} = 0;
 254   let Inst{16-31} = B;
 255 }
 256
 257 class DForm_4<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 258               InstrItinClass itin, list<dag> pattern>
 259   : I<opcode, OOL, IOL, asmstr, itin> {
 260   bits<5>  B;
 261   bits<5>  A;
 262   bits<16> C;
 263
 264   let Pattern = pattern;
 265
 266   let Inst{6-10}  = A;
 267   let Inst{11-15} = B;
 268   let Inst{16-31} = C;
 269 }
 270
 271 class DForm_4_zero<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 272                    InstrItinClass itin, list<dag> pattern>
 273   : DForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
 274   let A = 0;
 275   let Addr = 0;
 276 }
 277
 278 class DForm_4_fixedreg_zero<bits<6> opcode, bits<5> R, dag OOL, dag IOL,
 279                             string asmstr, InstrItinClass itin,
 280                             list<dag> pattern>
 281   : DForm_4<opcode, OOL, IOL, asmstr, itin, pattern> {
 282   let A = R;
 283   let B = R;
 284   let C = 0;
 285 }
 286
 287 class IForm_and_DForm_1<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 288             dag OOL, dag IOL, string asmstr,
 289             InstrItinClass itin, list<dag> pattern>
 290          : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> {
 291   bits<5>  A;
 292   bits<21> Addr;
 293
 294   let Pattern = pattern;
 295   bits<24> LI;
 296
 297   let Inst{6-29}  = LI;
 298   let Inst{30}    = aa;
 299   let Inst{31}    = lk;
 300
 301   let Inst{38-42}  = A;
 302   let Inst{43-47} = Addr{20-16}; // Base Reg
 303   let Inst{48-63} = Addr{15-0};  // Displacement
 304 }
 305
 306 // This is used to emit BL8+NOP.
 307 class IForm_and_DForm_4_zero<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 308             dag OOL, dag IOL, string asmstr,
 309             InstrItinClass itin, list<dag> pattern>
 310          :  IForm_and_DForm_1<opcode1, aa, lk, opcode2,
 311                               OOL, IOL, asmstr, itin, pattern> {
 312   let A = 0;
 313   let Addr = 0;
 314 }
 315
 316 class DForm_5<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 317               InstrItinClass itin>
 318   : I<opcode, OOL, IOL, asmstr, itin> {
 319   bits<3>  BF;
 320   bits<1>  L;
 321   bits<5>  RA;
 322   bits<16> I;
 323
 324   let Inst{6-8}   = BF;
 325   let Inst{9}     = 0;
 326   let Inst{10}    = L;
 327   let Inst{11-15} = RA;
 328   let Inst{16-31} = I;
 329 }
 330
 331 class DForm_5_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 332                   InstrItinClass itin>
 333   : DForm_5<opcode, OOL, IOL, asmstr, itin> {
 334   let L = PPC64;
 335 }
 336
 337 class DForm_6<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 338               InstrItinClass itin>
 339   : DForm_5<opcode, OOL, IOL, asmstr, itin>;
 340
 341 class DForm_6_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 342                   InstrItinClass itin>
 343   : DForm_6<opcode, OOL, IOL, asmstr, itin> {
 344   let L = PPC64;
 345 }
 346
 347
 348 // 1.7.5 DS-Form
 349 class DSForm_1<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 350                InstrItinClass itin, list<dag> pattern>
 351          : I<opcode, OOL, IOL, asmstr, itin> {
 352   bits<5>  RST;
 353   bits<19> DS_RA;
 354
 355   let Pattern = pattern;
 356
 357   let Inst{6-10}  = RST;
 358   let Inst{11-15} = DS_RA{18-14};  // Register #
 359   let Inst{16-29} = DS_RA{13-0};   // Displacement.
 360   let Inst{30-31} = xo;
 361 }
 362
 363
 364 // 1.7.6 X-Form
 365 class XForm_base_r3xo<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 366                       InstrItinClass itin, list<dag> pattern>
 367   : I<opcode, OOL, IOL, asmstr, itin> {
 368   bits<5> RST;
 369   bits<5> A;
 370   bits<5> B;
 371
 372   let Pattern = pattern;
 373
 374   bit RC = 0;    // set by isDOT
 375
 376   let Inst{6-10}  = RST;
 377   let Inst{11-15} = A;
 378   let Inst{16-20} = B;
 379   let Inst{21-30} = xo;
 380   let Inst{31}    = RC;
 381 }
 382
 383 // This is the same as XForm_base_r3xo, but the first two operands are swapped
 384 // when code is emitted.
 385 class XForm_base_r3xo_swapped
 386         <bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 387         InstrItinClass itin>
 388   : I<opcode, OOL, IOL, asmstr, itin> {
 389   bits<5> A;
 390   bits<5> RST;
 391   bits<5> B;
 392
 393   bit RC = 0;    // set by isDOT
 394
 395   let Inst{6-10}  = RST;
 396   let Inst{11-15} = A;
 397   let Inst{16-20} = B;
 398   let Inst{21-30} = xo;
 399   let Inst{31}    = RC;
 400 }
 401
 402
 403 class XForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 404               InstrItinClass itin, list<dag> pattern>
 405   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 406
 407 class XForm_1a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 408               InstrItinClass itin, list<dag> pattern>
 409   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 410   let RST = 0;
 411 }
 412
 413 class XForm_rs<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 414               InstrItinClass itin, list<dag> pattern>
 415   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 416   let A = 0;
 417   let B = 0;
 418 }
 419
 420 class XForm_6<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 421               InstrItinClass itin, list<dag> pattern>
 422   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 423   let Pattern = pattern;
 424 }
 425
 426 class XForm_8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 427               InstrItinClass itin, list<dag> pattern>
 428   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 429
 430 class XForm_10<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 431                InstrItinClass itin, list<dag> pattern>
 432   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 433     let Pattern = pattern;
 434 }
 435
 436 class XForm_11<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 437                InstrItinClass itin, list<dag> pattern>
 438   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 439   let B = 0;
 440   let Pattern = pattern;
 441 }
 442
 443 class XForm_16<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 444                InstrItinClass itin>
 445          : I<opcode, OOL, IOL, asmstr, itin> {
 446   bits<3> BF;
 447   bits<1> L;
 448   bits<5> RA;
 449   bits<5> RB;
 450
 451   let Inst{6-8}   = BF;
 452   let Inst{9}     = 0;
 453   let Inst{10}    = L;
 454   let Inst{11-15} = RA;
 455   let Inst{16-20} = RB;
 456   let Inst{21-30} = xo;
 457   let Inst{31}    = 0;
 458 }
 459
 460 class XForm_sr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 461                 InstrItinClass itin>
 462          : I<opcode, OOL, IOL, asmstr, itin> {
 463   bits<5> RS;
 464   bits<4> SR;
 465
 466   let Inst{6-10} = RS;
 467   let Inst{12-15} = SR;
 468   let Inst{21-30} = xo;
 469 }
 470
 471 class XForm_srin<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 472                 InstrItinClass itin>
 473          : I<opcode, OOL, IOL, asmstr, itin> {
 474   bits<5> RS;
 475   bits<5> RB;
 476
 477   let Inst{6-10} = RS;
 478   let Inst{16-20} = RB;
 479   let Inst{21-30} = xo;
 480 }
 481
 482 class XForm_mtmsr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 483                 InstrItinClass itin>
 484          : I<opcode, OOL, IOL, asmstr, itin> {
 485   bits<5> RS;
 486   bits<1> L;
 487
 488   let Inst{6-10} = RS;
 489   let Inst{15} = L;
 490   let Inst{21-30} = xo;
 491 }
 492
 493 class XForm_16_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 494                    InstrItinClass itin>
 495   : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> {
 496   let L = PPC64;
 497 }
 498
 499 class XForm_17<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 500                InstrItinClass itin>
 501          : I<opcode, OOL, IOL, asmstr, itin> {
 502   bits<3> BF;
 503   bits<5> FRA;
 504   bits<5> FRB;
 505
 506   let Inst{6-8}   = BF;
 507   let Inst{9-10}  = 0;
 508   let Inst{11-15} = FRA;
 509   let Inst{16-20} = FRB;
 510   let Inst{21-30} = xo;
 511   let Inst{31}    = 0;
 512 }
 513
 514 class XForm_24<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 515                InstrItinClass itin, list<dag> pattern>
 516   : I<opcode, OOL, IOL, asmstr, itin> {
 517   let Pattern = pattern;
 518   let Inst{6-10}  = 31;
 519   let Inst{11-15} = 0;
 520   let Inst{16-20} = 0;
 521   let Inst{21-30} = xo;
 522   let Inst{31}    = 0;
 523 }
 524
 525 class XForm_24_sync<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 526                string asmstr, InstrItinClass itin, list<dag> pattern>
 527   : I<opcode, OOL, IOL, asmstr, itin> {
 528   bits<2> L;
 529
 530   let Pattern = pattern;
 531   let Inst{6-8}   = 0;
 532   let Inst{9-10}  = L;
 533   let Inst{11-15} = 0;
 534   let Inst{16-20} = 0;
 535   let Inst{21-30} = xo;
 536   let Inst{31}    = 0;
 537 }
 538
 539 class XForm_24_eieio<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 540                string asmstr, InstrItinClass itin, list<dag> pattern>
 541   : XForm_24_sync<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 542   let L = 0;
 543 }
 544
 545 class XForm_25<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 546                InstrItinClass itin, list<dag> pattern>
 547   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 548 }
 549
 550 class XForm_26<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 551                InstrItinClass itin, list<dag> pattern>
 552   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 553   let A = 0;
 554 }
 555
 556 class XForm_28<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 557                InstrItinClass itin, list<dag> pattern>
 558   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 559 }
 560
 561 // This is used for MFFS, MTFSB0, MTFSB1.  42 is arbitrary; this series of
 562 // numbers presumably relates to some document, but I haven't found it.
 563 class XForm_42<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 564               InstrItinClass itin, list<dag> pattern>
 565   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 566   let Pattern = pattern;
 567
 568   bit RC = 0;    // set by isDOT
 569
 570   let Inst{6-10}  = RST;
 571   let Inst{11-20} = 0;
 572   let Inst{21-30} = xo;
 573   let Inst{31}    = RC;
 574 }
 575 class XForm_43<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 576               InstrItinClass itin, list<dag> pattern>
 577   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 578   let Pattern = pattern;
 579   bits<5> FM;
 580
 581   bit RC = 0;    // set by isDOT
 582
 583   let Inst{6-10}  = FM;
 584   let Inst{11-20} = 0;
 585   let Inst{21-30} = xo;
 586   let Inst{31}    = RC;
 587 }
 588
 589 class XForm_0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 590               InstrItinClass itin, list<dag> pattern>
 591   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 592   let RST = 0;
 593   let A = 0;
 594   let B = 0;
 595 }
 596
 597 class XForm_16b<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 598               InstrItinClass itin, list<dag> pattern>
 599   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 600   let RST = 0;
 601   let A = 0;
 602 }
 603
 604 // XX*-Form (VSX)
 605 class XX1Form<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 606               InstrItinClass itin, list<dag> pattern>
 607   : I<opcode, OOL, IOL, asmstr, itin> {
 608   bits<6> XT;
 609   bits<5> A;
 610   bits<5> B;
 611
 612   let Pattern = pattern;
 613
 614   let Inst{6-10}  = XT{4-0};
 615   let Inst{11-15} = A;
 616   let Inst{16-20} = B;
 617   let Inst{21-30} = xo;
 618   let Inst{31}    = XT{5};
 619 }
 620
 621 class XX2Form<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 622               InstrItinClass itin, list<dag> pattern>
 623   : I<opcode, OOL, IOL, asmstr, itin> {
 624   bits<6> XT;
 625   bits<6> XB;
 626
 627   let Pattern = pattern;
 628
 629   let Inst{6-10}  = XT{4-0};
 630   let Inst{11-15} = 0;
 631   let Inst{16-20} = XB{4-0};
 632   let Inst{21-29} = xo;
 633   let Inst{30}    = XB{5};
 634   let Inst{31}    = XT{5};
 635 }
 636
 637 class XX2Form_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 638                 InstrItinClass itin, list<dag> pattern>
 639   : I<opcode, OOL, IOL, asmstr, itin> {
 640   bits<3> CR;
 641   bits<6> XB;
 642
 643   let Pattern = pattern;
 644
 645   let Inst{6-8}   = CR;
 646   let Inst{9-15}  = 0;
 647   let Inst{16-20} = XB{4-0};
 648   let Inst{21-29} = xo;
 649   let Inst{30}    = XB{5};
 650   let Inst{31}    = 0;
 651 }
 652
 653 class XX2Form_2<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 654                 InstrItinClass itin, list<dag> pattern>
 655   : I<opcode, OOL, IOL, asmstr, itin> {
 656   bits<6> XT;
 657   bits<6> XB;
 658   bits<2> D;
 659
 660   let Pattern = pattern;
 661
 662   let Inst{6-10}  = XT{4-0};
 663   let Inst{11-13} = 0;
 664   let Inst{14-15} = D;
 665   let Inst{16-20} = XB{4-0};
 666   let Inst{21-29} = xo;
 667   let Inst{30}    = XB{5};
 668   let Inst{31}    = XT{5};
 669 }
 670
 671 class XX3Form<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
 672               InstrItinClass itin, list<dag> pattern>
 673   : I<opcode, OOL, IOL, asmstr, itin> {
 674   bits<6> XT;
 675   bits<6> XA;
 676   bits<6> XB;
 677
 678   let Pattern = pattern;
 679
 680   let Inst{6-10}  = XT{4-0};
 681   let Inst{11-15} = XA{4-0};
 682   let Inst{16-20} = XB{4-0};
 683   let Inst{21-28} = xo;
 684   let Inst{29}    = XA{5};
 685   let Inst{30}    = XB{5};
 686   let Inst{31}    = XT{5};
 687 }
 688
 689 class XX3Form_1<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr,
 690                 InstrItinClass itin, list<dag> pattern>
 691   : I<opcode, OOL, IOL, asmstr, itin> {
 692   bits<3> CR;
 693   bits<6> XA;
 694   bits<6> XB;
 695
 696   let Pattern = pattern;
 697
 698   let Inst{6-8}   = CR;
 699   let Inst{9-10}  = 0;
 700   let Inst{11-15} = XA{4-0};
 701   let Inst{16-20} = XB{4-0};
 702   let Inst{21-28} = xo;
 703   let Inst{29}    = XA{5};
 704   let Inst{30}    = XB{5};
 705   let Inst{31}    = 0;
 706 }
 707
 708 class XX3Form_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 709                 InstrItinClass itin, list<dag> pattern>
 710   : I<opcode, OOL, IOL, asmstr, itin> {
 711   bits<6> XT;
 712   bits<6> XA;
 713   bits<6> XB;
 714   bits<2> D;
 715
 716   let Pattern = pattern;
 717
 718   let Inst{6-10}  = XT{4-0};
 719   let Inst{11-15} = XA{4-0};
 720   let Inst{16-20} = XB{4-0};
 721   let Inst{21}    = 0;
 722   let Inst{22-23} = D;
 723   let Inst{24-28} = xo;
 724   let Inst{29}    = XA{5};
 725   let Inst{30}    = XB{5};
 726   let Inst{31}    = XT{5};
 727 }
 728
 729 class XX3Form_Rc<bits<6> opcode, bits<7> xo, dag OOL, dag IOL, string asmstr,
 730               InstrItinClass itin, list<dag> pattern>
 731   : I<opcode, OOL, IOL, asmstr, itin> {
 732   bits<6> XT;
 733   bits<6> XA;
 734   bits<6> XB;
 735
 736   let Pattern = pattern;
 737
 738   bit RC = 0;    // set by isDOT
 739
 740   let Inst{6-10}  = XT{4-0};
 741   let Inst{11-15} = XA{4-0};
 742   let Inst{16-20} = XB{4-0};
 743   let Inst{21}    = RC;
 744   let Inst{22-28} = xo;
 745   let Inst{29}    = XA{5};
 746   let Inst{30}    = XB{5};
 747   let Inst{31}    = XT{5};
 748 }
 749
 750 class XX4Form<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 751               InstrItinClass itin, list<dag> pattern>
 752   : I<opcode, OOL, IOL, asmstr, itin> {
 753   bits<6> XT;
 754   bits<6> XA;
 755   bits<6> XB;
 756   bits<6> XC;
 757
 758   let Pattern = pattern;
 759
 760   let Inst{6-10}  = XT{4-0};
 761   let Inst{11-15} = XA{4-0};
 762   let Inst{16-20} = XB{4-0};
 763   let Inst{21-25} = XC{4-0};
 764   let Inst{26-27} = xo;
 765   let Inst{28}    = XC{5};
 766   let Inst{29}    = XA{5};
 767   let Inst{30}    = XB{5};
 768   let Inst{31}    = XT{5};
 769 }
 770
 771 // DCB_Form - Form X instruction, used for dcb* instructions.
 772 class DCB_Form<bits<10> xo, bits<5> immfield, dag OOL, dag IOL, string asmstr,
 773                       InstrItinClass itin, list<dag> pattern>
 774   : I<31, OOL, IOL, asmstr, itin> {
 775   bits<5> A;
 776   bits<5> B;
 777
 778   let Pattern = pattern;
 779
 780   let Inst{6-10}  = immfield;
 781   let Inst{11-15} = A;
 782   let Inst{16-20} = B;
 783   let Inst{21-30} = xo;
 784   let Inst{31}    = 0;
 785 }
 786
 787
 788 // DSS_Form - Form X instruction, used for altivec dss* instructions.
 789 class DSS_Form<bits<10> xo, dag OOL, dag IOL, string asmstr,
 790                       InstrItinClass itin, list<dag> pattern>
 791   : I<31, OOL, IOL, asmstr, itin> {
 792   bits<1> T;
 793   bits<2> STRM;
 794   bits<5> A;
 795   bits<5> B;
 796
 797   let Pattern = pattern;
 798
 799   let Inst{6}     = T;
 800   let Inst{7-8}   = 0;
 801   let Inst{9-10}  = STRM;
 802   let Inst{11-15} = A;
 803   let Inst{16-20} = B;
 804   let Inst{21-30} = xo;
 805   let Inst{31}    = 0;
 806 }
 807
 808 // 1.7.7 XL-Form
 809 class XLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 810                InstrItinClass itin, list<dag> pattern>
 811     : I<opcode, OOL, IOL, asmstr, itin> {
 812   bits<5> CRD;
 813   bits<5> CRA;
 814   bits<5> CRB;
 815
 816   let Pattern = pattern;
 817
 818   let Inst{6-10}  = CRD;
 819   let Inst{11-15} = CRA;
 820   let Inst{16-20} = CRB;
 821   let Inst{21-30} = xo;
 822   let Inst{31}    = 0;
 823 }
 824
 825 class XLForm_1_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 826                InstrItinClass itin, list<dag> pattern>
 827     : I<opcode, OOL, IOL, asmstr, itin> {
 828   bits<5> CRD;
 829
 830   let Pattern = pattern;
 831
 832   let Inst{6-10}  = CRD;
 833   let Inst{11-15} = CRD;
 834   let Inst{16-20} = CRD;
 835   let Inst{21-30} = xo;
 836   let Inst{31}    = 0;
 837 }
 838
 839 class XLForm_2<bits<6> opcode, bits<10> xo, bit lk, dag OOL, dag IOL, string asmstr,
 840                InstrItinClass itin, list<dag> pattern>
 841     : I<opcode, OOL, IOL, asmstr, itin> {
 842   bits<5> BO;
 843   bits<5> BI;
 844   bits<2> BH;
 845
 846   let Pattern = pattern;
 847
 848   let Inst{6-10}  = BO;
 849   let Inst{11-15} = BI;
 850   let Inst{16-18} = 0;
 851   let Inst{19-20} = BH;
 852   let Inst{21-30} = xo;
 853   let Inst{31}    = lk;
 854 }
 855
 856 class XLForm_2_br<bits<6> opcode, bits<10> xo, bit lk,
 857                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 858   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 859   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 860   bits<3>  CR;
 861
 862   let BO = BIBO{4-0};
 863   let BI{0-1} = BIBO{5-6};
 864   let BI{2-4} = CR{0-2};
 865   let BH = 0;
 866 }
 867
 868 class XLForm_2_br2<bits<6> opcode, bits<10> xo, bits<5> bo, bit lk,
 869                    dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 870   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 871   let BO = bo;
 872   let BH = 0;
 873 }
 874
 875 class XLForm_2_ext<bits<6> opcode, bits<10> xo, bits<5> bo,  bits<5> bi, bit lk,
 876                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 877   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 878   let BO = bo;
 879   let BI = bi;
 880   let BH = 0;
 881 }
 882
 883 class XLForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 884                InstrItinClass itin>
 885          : I<opcode, OOL, IOL, asmstr, itin> {
 886   bits<3> BF;
 887   bits<3> BFA;
 888
 889   let Inst{6-8}   = BF;
 890   let Inst{9-10}  = 0;
 891   let Inst{11-13} = BFA;
 892   let Inst{14-15} = 0;
 893   let Inst{16-20} = 0;
 894   let Inst{21-30} = xo;
 895   let Inst{31}    = 0;
 896 }
 897
 898 // 1.7.8 XFX-Form
 899 class XFXForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 900                 InstrItinClass itin>
 901          : I<opcode, OOL, IOL, asmstr, itin> {
 902   bits<5>  RT;
 903   bits<10> SPR;
 904
 905   let Inst{6-10}  = RT;
 906   let Inst{11}    = SPR{4};
 907   let Inst{12}    = SPR{3};
 908   let Inst{13}    = SPR{2};
 909   let Inst{14}    = SPR{1};
 910   let Inst{15}    = SPR{0};
 911   let Inst{16}    = SPR{9};
 912   let Inst{17}    = SPR{8};
 913   let Inst{18}    = SPR{7};
 914   let Inst{19}    = SPR{6};
 915   let Inst{20}    = SPR{5};
 916   let Inst{21-30} = xo;
 917   let Inst{31}    = 0;
 918 }
 919
 920 class XFXForm_1_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 921                    dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 922   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin> {
 923   let SPR = spr;
 924 }
 925
 926 class XFXForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 927                 InstrItinClass itin>
 928          : I<opcode, OOL, IOL, asmstr, itin> {
 929   bits<5>  RT;
 930
 931   let Inst{6-10}  = RT;
 932   let Inst{11-20} = 0;
 933   let Inst{21-30} = xo;
 934   let Inst{31}    = 0;
 935 }
 936
 937 class XFXForm_5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 938                 InstrItinClass itin>
 939   : I<opcode, OOL, IOL, asmstr, itin> {
 940   bits<8>  FXM;
 941   bits<5>  rS;
 942
 943   let Inst{6-10}  = rS;
 944   let Inst{11}    = 0;
 945   let Inst{12-19} = FXM;
 946   let Inst{20}    = 0;
 947   let Inst{21-30} = xo;
 948   let Inst{31}    = 0;
 949 }
 950
 951 class XFXForm_5a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 952                  InstrItinClass itin>
 953   : I<opcode, OOL, IOL, asmstr, itin> {
 954   bits<5>  ST;
 955   bits<8>  FXM;
 956
 957   let Inst{6-10}  = ST;
 958   let Inst{11}    = 1;
 959   let Inst{12-19} = FXM;
 960   let Inst{20}    = 0;
 961   let Inst{21-30} = xo;
 962   let Inst{31}    = 0;
 963 }
 964
 965 class XFXForm_7<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 966                 InstrItinClass itin>
 967   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin>;
 968
 969 class XFXForm_7_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 970                     dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 971   : XFXForm_7<opcode, xo, OOL, IOL, asmstr, itin> {
 972   let SPR = spr;
 973 }
 974
 975 // XFL-Form - MTFSF
 976 // This is probably 1.7.9, but I don't have the reference that uses this
 977 // numbering scheme...
 978 class XFLForm<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 979               InstrItinClass itin, list<dag>pattern>
 980   : I<opcode, OOL, IOL, asmstr, itin> {
 981   bits<8> FM;
 982   bits<5> rT;
 983
 984   bit RC = 0;    // set by isDOT
 985   let Pattern = pattern;
 986
 987   let Inst{6} = 0;
 988   let Inst{7-14}  = FM;
 989   let Inst{15} = 0;
 990   let Inst{16-20} = rT;
 991   let Inst{21-30} = xo;
 992   let Inst{31}    = RC;
 993 }
 994
 995 // 1.7.10 XS-Form - SRADI.
 996 class XSForm_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 997                InstrItinClass itin, list<dag> pattern>
 998          : I<opcode, OOL, IOL, asmstr, itin> {
 999   bits<5> A;
1000   bits<5> RS;
1001   bits<6> SH;
1002
1003   bit RC = 0;    // set by isDOT
1004   let Pattern = pattern;
1005
1006   let Inst{6-10}  = RS;
1007   let Inst{11-15} = A;
1008   let Inst{16-20} = SH{4,3,2,1,0};
1009   let Inst{21-29} = xo;
1010   let Inst{30}    = SH{5};
1011   let Inst{31}    = RC;
1012 }
1013
1014 // 1.7.11 XO-Form
1015 class XOForm_1<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL, string asmstr,
1016                InstrItinClass itin, list<dag> pattern>
1017          : I<opcode, OOL, IOL, asmstr, itin> {
1018   bits<5> RT;
1019   bits<5> RA;
1020   bits<5> RB;
1021
1022   let Pattern = pattern;
1023
1024   bit RC = 0;    // set by isDOT
1025
1026   let Inst{6-10}  = RT;
1027   let Inst{11-15} = RA;
1028   let Inst{16-20} = RB;
1029   let Inst{21}    = oe;
1030   let Inst{22-30} = xo;
1031   let Inst{31}    = RC;
1032 }
1033
1034 class XOForm_3<bits<6> opcode, bits<9> xo, bit oe,
1035                dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
1036   : XOForm_1<opcode, xo, oe, OOL, IOL, asmstr, itin, pattern> {
1037   let RB = 0;
1038 }
1039
1040 // 1.7.12 A-Form
1041 class AForm_1<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1042               InstrItinClass itin, list<dag> pattern>
1043          : I<opcode, OOL, IOL, asmstr, itin> {
1044   bits<5> FRT;
1045   bits<5> FRA;
1046   bits<5> FRC;
1047   bits<5> FRB;
1048
1049   let Pattern = pattern;
1050
1051   bit RC = 0;    // set by isDOT
1052
1053   let Inst{6-10}  = FRT;
1054   let Inst{11-15} = FRA;
1055   let Inst{16-20} = FRB;
1056   let Inst{21-25} = FRC;
1057   let Inst{26-30} = xo;
1058   let Inst{31}    = RC;
1059 }
1060
1061 class AForm_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1062               InstrItinClass itin, list<dag> pattern>
1063   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1064   let FRC = 0;
1065 }
1066
1067 class AForm_3<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1068               InstrItinClass itin, list<dag> pattern>
1069   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
1070   let FRB = 0;
1071 }
1072
1073 class AForm_4<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
1074               InstrItinClass itin, list<dag> pattern>
1075          : I<opcode, OOL, IOL, asmstr, itin> {
1076   bits<5> RT;
1077   bits<5> RA;
1078   bits<5> RB;
1079   bits<5> COND;
1080
1081   let Pattern = pattern;
1082
1083   let Inst{6-10}  = RT;
1084   let Inst{11-15} = RA;
1085   let Inst{16-20} = RB;
1086   let Inst{21-25} = COND;
1087   let Inst{26-30} = xo;
1088   let Inst{31}    = 0;
1089 }
1090
1091 // 1.7.13 M-Form
1092 class MForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
1093               InstrItinClass itin, list<dag> pattern>
1094     : I<opcode, OOL, IOL, asmstr, itin> {
1095   bits<5> RA;
1096   bits<5> RS;
1097   bits<5> RB;
1098   bits<5> MB;
1099   bits<5> ME;
1100
1101   let Pattern = pattern;
1102
1103   bit RC = 0;    // set by isDOT
1104
1105   let Inst{6-10}  = RS;
1106   let Inst{11-15} = RA;
1107   let Inst{16-20} = RB;
1108   let Inst{21-25} = MB;
1109   let Inst{26-30} = ME;
1110   let Inst{31}    = RC;
1111 }
1112
1113 class MForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
1114               InstrItinClass itin, list<dag> pattern>
1115   : MForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
1116 }
1117
1118 // 1.7.14 MD-Form
1119 class MDForm_1<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, string asmstr,
1120                InstrItinClass itin, list<dag> pattern>
1121     : I<opcode, OOL, IOL, asmstr, itin> {
1122   bits<5> RA;
1123   bits<5> RS;
1124   bits<6> SH;
1125   bits<6> MBE;
1126
1127   let Pattern = pattern;
1128
1129   bit RC = 0;    // set by isDOT
1130
1131   let Inst{6-10}  = RS;
1132   let Inst{11-15} = RA;
1133   let Inst{16-20} = SH{4,3,2,1,0};
1134   let Inst{21-26} = MBE{4,3,2,1,0,5};
1135   let Inst{27-29} = xo;
1136   let Inst{30}    = SH{5};
1137   let Inst{31}    = RC;
1138 }
1139
1140 class MDSForm_1<bits<6> opcode, bits<4> xo, dag OOL, dag IOL, string asmstr,
1141                 InstrItinClass itin, list<dag> pattern>
1142     : I<opcode, OOL, IOL, asmstr, itin> {
1143   bits<5> RA;
1144   bits<5> RS;
1145   bits<5> RB;
1146   bits<6> MBE;
1147
1148   let Pattern = pattern;
1149
1150   bit RC = 0;    // set by isDOT
1151
1152   let Inst{6-10}  = RS;
1153   let Inst{11-15} = RA;
1154   let Inst{16-20} = RB;
1155   let Inst{21-26} = MBE{4,3,2,1,0,5};
1156   let Inst{27-30} = xo;
1157   let Inst{31}    = RC;
1158 }
1159
1160
1161 // E-1 VA-Form
1162
1163 // VAForm_1 - DACB ordering.
1164 class VAForm_1<bits<6> xo, dag OOL, dag IOL, string asmstr,
1165                InstrItinClass itin, list<dag> pattern>
1166     : I<4, OOL, IOL, asmstr, itin> {
1167   bits<5> VD;
1168   bits<5> VA;
1169   bits<5> VC;
1170   bits<5> VB;
1171
1172   let Pattern = pattern;
1173
1174   let Inst{6-10}  = VD;
1175   let Inst{11-15} = VA;
1176   let Inst{16-20} = VB;
1177   let Inst{21-25} = VC;
1178   let Inst{26-31} = xo;
1179 }
1180
1181 // VAForm_1a - DABC ordering.
1182 class VAForm_1a<bits<6> xo, dag OOL, dag IOL, string asmstr,
1183                 InstrItinClass itin, list<dag> pattern>
1184     : I<4, OOL, IOL, asmstr, itin> {
1185   bits<5> VD;
1186   bits<5> VA;
1187   bits<5> VB;
1188   bits<5> VC;
1189
1190   let Pattern = pattern;
1191
1192   let Inst{6-10}  = VD;
1193   let Inst{11-15} = VA;
1194   let Inst{16-20} = VB;
1195   let Inst{21-25} = VC;
1196   let Inst{26-31} = xo;
1197 }
1198
1199 class VAForm_2<bits<6> xo, dag OOL, dag IOL, string asmstr,
1200                InstrItinClass itin, list<dag> pattern>
1201     : I<4, OOL, IOL, asmstr, itin> {
1202   bits<5> VD;
1203   bits<5> VA;
1204   bits<5> VB;
1205   bits<4> SH;
1206
1207   let Pattern = pattern;
1208
1209   let Inst{6-10}  = VD;
1210   let Inst{11-15} = VA;
1211   let Inst{16-20} = VB;
1212   let Inst{21}    = 0;
1213   let Inst{22-25} = SH;
1214   let Inst{26-31} = xo;
1215 }
1216
1217 // E-2 VX-Form
1218 class VXForm_1<bits<11> xo, dag OOL, dag IOL, string asmstr,
1219                InstrItinClass itin, list<dag> pattern>
1220     : I<4, OOL, IOL, asmstr, itin> {
1221   bits<5> VD;
1222   bits<5> VA;
1223   bits<5> VB;
1224
1225   let Pattern = pattern;
1226
1227   let Inst{6-10}  = VD;
1228   let Inst{11-15} = VA;
1229   let Inst{16-20} = VB;
1230   let Inst{21-31} = xo;
1231 }
1232
1233 class VXForm_setzero<bits<11> xo, dag OOL, dag IOL, string asmstr,
1234                InstrItinClass itin, list<dag> pattern>
1235     : VXForm_1<xo, OOL, IOL, asmstr, itin, pattern> {
1236   let VA = VD;
1237   let VB = VD;
1238 }
1239
1240
1241 class VXForm_2<bits<11> xo, dag OOL, dag IOL, string asmstr,
1242                InstrItinClass itin, list<dag> pattern>
1243     : I<4, OOL, IOL, asmstr, itin> {
1244   bits<5> VD;
1245   bits<5> VB;
1246
1247   let Pattern = pattern;
1248
1249   let Inst{6-10}  = VD;
1250   let Inst{11-15} = 0;
1251   let Inst{16-20} = VB;
1252   let Inst{21-31} = xo;
1253 }
1254
1255 class VXForm_3<bits<11> xo, dag OOL, dag IOL, string asmstr,
1256                InstrItinClass itin, list<dag> pattern>
1257     : I<4, OOL, IOL, asmstr, itin> {
1258   bits<5> VD;
1259   bits<5> IMM;
1260
1261   let Pattern = pattern;
1262
1263   let Inst{6-10}  = VD;
1264   let Inst{11-15} = IMM;
1265   let Inst{16-20} = 0;
1266   let Inst{21-31} = xo;
1267 }
1268
1269 /// VXForm_4 - VX instructions with "VD,0,0" register fields, like mfvscr.
1270 class VXForm_4<bits<11> xo, dag OOL, dag IOL, string asmstr,
1271                InstrItinClass itin, list<dag> pattern>
1272     : I<4, OOL, IOL, asmstr, itin> {
1273   bits<5> VD;
1274
1275   let Pattern = pattern;
1276
1277   let Inst{6-10}  = VD;
1278   let Inst{11-15} = 0;
1279   let Inst{16-20} = 0;
1280   let Inst{21-31} = xo;
1281 }
1282
1283 /// VXForm_5 - VX instructions with "0,0,VB" register fields, like mtvscr.
1284 class VXForm_5<bits<11> xo, dag OOL, dag IOL, string asmstr,
1285                InstrItinClass itin, list<dag> pattern>
1286     : I<4, OOL, IOL, asmstr, itin> {
1287   bits<5> VB;
1288
1289   let Pattern = pattern;
1290
1291   let Inst{6-10}  = 0;
1292   let Inst{11-15} = 0;
1293   let Inst{16-20} = VB;
1294   let Inst{21-31} = xo;
1295 }
1296
1297 // E-4 VXR-Form
1298 class VXRForm_1<bits<10> xo, dag OOL, dag IOL, string asmstr,
1299                InstrItinClass itin, list<dag> pattern>
1300     : I<4, OOL, IOL, asmstr, itin> {
1301   bits<5> VD;
1302   bits<5> VA;
1303   bits<5> VB;
1304   bit RC = 0;
1305
1306   let Pattern = pattern;
1307
1308   let Inst{6-10}  = VD;
1309   let Inst{11-15} = VA;
1310   let Inst{16-20} = VB;
1311   let Inst{21}    = RC;
1312   let Inst{22-31} = xo;
1313 }
1314
1315 //===----------------------------------------------------------------------===//
1316 class Pseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern>
1317     : I<0, OOL, IOL, asmstr, NoItinerary> {
1318   let isCodeGenOnly = 1;
1319   let PPC64 = 0;
1320   let Pattern = pattern;
1321   let Inst{31-0} = 0;
1322 }