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
  18   bit PPC64 = 0;  // Default value, override with isPPC64
  19
  20   let Namespace = "PPC";
  21   let Inst{0-5} = opcode;
  22   let OutOperandList = OOL;
  23   let InOperandList = IOL;
  24   let AsmString = asmstr;
  25   let Itinerary = itin;
  26
  27   bits<1> PPC970_First = 0;
  28   bits<1> PPC970_Single = 0;
  29   bits<1> PPC970_Cracked = 0;
  30   bits<3> PPC970_Unit = 0;
  31
  32   /// These fields correspond to the fields in PPCInstrInfo.h.  Any changes to
  33   /// these must be reflected there!  See comments there for what these are.
  34   let TSFlags{0}   = PPC970_First;
  35   let TSFlags{1}   = PPC970_Single;
  36   let TSFlags{2}   = PPC970_Cracked;
  37   let TSFlags{5-3} = PPC970_Unit;
  38 }
  39
  40 class PPC970_DGroup_First   { bits<1> PPC970_First = 1;  }
  41 class PPC970_DGroup_Single  { bits<1> PPC970_Single = 1; }
  42 class PPC970_DGroup_Cracked { bits<1> PPC970_Cracked = 1; }
  43 class PPC970_MicroCode;
  44
  45 class PPC970_Unit_Pseudo   { bits<3> PPC970_Unit = 0;   }
  46 class PPC970_Unit_FXU      { bits<3> PPC970_Unit = 1;   }
  47 class PPC970_Unit_LSU      { bits<3> PPC970_Unit = 2;   }
  48 class PPC970_Unit_FPU      { bits<3> PPC970_Unit = 3;   }
  49 class PPC970_Unit_CRU      { bits<3> PPC970_Unit = 4;   }
  50 class PPC970_Unit_VALU     { bits<3> PPC970_Unit = 5;   }
  51 class PPC970_Unit_VPERM    { bits<3> PPC970_Unit = 6;   }
  52 class PPC970_Unit_BRU      { bits<3> PPC970_Unit = 7;   }
  53
  54 // Two joined instructions; used to emit two adjacent instructions as one.
  55 // The itinerary from the first instruction is used for scheduling and
  56 // classification.
  57 class I2<bits<6> opcode1, bits<6> opcode2, dag OOL, dag IOL, string asmstr,
  58          InstrItinClass itin>
  59         : Instruction {
  60   field bits<64> Inst;
  61
  62   bit PPC64 = 0;  // Default value, override with isPPC64
  63
  64   let Namespace = "PPC";
  65   let Inst{0-5} = opcode1;
  66   let Inst{32-37} = opcode2;
  67   let OutOperandList = OOL;
  68   let InOperandList = IOL;
  69   let AsmString = asmstr;
  70   let Itinerary = itin;
  71
  72   bits<1> PPC970_First = 0;
  73   bits<1> PPC970_Single = 0;
  74   bits<1> PPC970_Cracked = 0;
  75   bits<3> PPC970_Unit = 0;
  76
  77   /// These fields correspond to the fields in PPCInstrInfo.h.  Any changes to
  78   /// these must be reflected there!  See comments there for what these are.
  79   let TSFlags{0}   = PPC970_First;
  80   let TSFlags{1}   = PPC970_Single;
  81   let TSFlags{2}   = PPC970_Cracked;
  82   let TSFlags{5-3} = PPC970_Unit;
  83 }
  84
  85 // 1.7.1 I-Form
  86 class IForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr,
  87             InstrItinClass itin, list<dag> pattern>
  88          : I<opcode, OOL, IOL, asmstr, itin> {
  89   let Pattern = pattern;
  90   bits<24> LI;
  91
  92   let Inst{6-29}  = LI;
  93   let Inst{30}    = aa;
  94   let Inst{31}    = lk;
  95 }
  96
  97 // 1.7.2 B-Form
  98 class BForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr>
  99   : I<opcode, OOL, IOL, asmstr, BrB> {
 100   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 101   bits<3>  CR;
 102   bits<14> BD;
 103
 104   bits<5> BI;
 105   let BI{0-1} = BIBO{5-6};
 106   let BI{2-4} = CR{0-2};
 107
 108   let Inst{6-10}  = BIBO{4-0};
 109   let Inst{11-15} = BI;
 110   let Inst{16-29} = BD;
 111   let Inst{30}    = aa;
 112   let Inst{31}    = lk;
 113 }
 114
 115 class BForm_1<bits<6> opcode, bits<5> bo, bit aa, bit lk, dag OOL, dag IOL,
 116              string asmstr>
 117   : BForm<opcode, aa, lk, OOL, IOL, asmstr> {
 118   let BIBO{4-0} = bo;
 119   let BIBO{6-5} = 0;
 120   let CR = 0;
 121 }
 122
 123 class BForm_2<bits<6> opcode, bits<5> bo, bits<5> bi, bit aa, bit lk,
 124               dag OOL, dag IOL, string asmstr>
 125   : I<opcode, OOL, IOL, asmstr, BrB> {
 126   bits<14> BD;
 127
 128   let Inst{6-10}  = bo;
 129   let Inst{11-15} = bi;
 130   let Inst{16-29} = BD;
 131   let Inst{30}    = aa;
 132   let Inst{31}    = lk;
 133 }
 134
 135 // 1.7.4 D-Form
 136 class DForm_base<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 137                  InstrItinClass itin, list<dag> pattern>
 138   : I<opcode, OOL, IOL, asmstr, itin> {
 139   bits<5>  A;
 140   bits<5>  B;
 141   bits<16> C;
 142
 143   let Pattern = pattern;
 144
 145   let Inst{6-10}  = A;
 146   let Inst{11-15} = B;
 147   let Inst{16-31} = C;
 148 }
 149
 150 class DForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 151               InstrItinClass itin, list<dag> pattern>
 152   : I<opcode, OOL, IOL, asmstr, itin> {
 153   bits<5>  A;
 154   bits<21> Addr;
 155
 156   let Pattern = pattern;
 157
 158   let Inst{6-10}  = A;
 159   let Inst{11-15} = Addr{20-16}; // Base Reg
 160   let Inst{16-31} = Addr{15-0};  // Displacement
 161 }
 162
 163 class DForm_1a<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 164                InstrItinClass itin, list<dag> pattern>
 165   : I<opcode, OOL, IOL, asmstr, itin> {
 166   bits<5>  A;
 167   bits<16> C;
 168   bits<5>  B;
 169
 170   let Pattern = pattern;
 171
 172   let Inst{6-10}  = A;
 173   let Inst{11-15} = B;
 174   let Inst{16-31} = C;
 175 }
 176
 177
 178 class DForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 179               InstrItinClass itin, list<dag> pattern>
 180   : DForm_base<opcode, OOL, IOL, asmstr, itin, pattern>;
 181
 182 class DForm_2_r0<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 183                  InstrItinClass itin, list<dag> pattern>
 184   : I<opcode, OOL, IOL, asmstr, itin> {
 185   bits<5>  A;
 186   bits<16> B;
 187
 188   let Pattern = pattern;
 189
 190   let Inst{6-10}  = A;
 191   let Inst{11-15} = 0;
 192   let Inst{16-31} = B;
 193 }
 194
 195 class DForm_4<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 196               InstrItinClass itin, list<dag> pattern>
 197   : I<opcode, OOL, IOL, asmstr, itin> {
 198   bits<5>  B;
 199   bits<5>  A;
 200   bits<16> C;
 201
 202   let Pattern = pattern;
 203
 204   let Inst{6-10}  = A;
 205   let Inst{11-15} = B;
 206   let Inst{16-31} = C;
 207 }
 208
 209 class DForm_4_zero<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 210                    InstrItinClass itin, list<dag> pattern>
 211   : DForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
 212   let A = 0;
 213   let Addr = 0;
 214 }
 215
 216 class IForm_and_DForm_1<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 217             dag OOL, dag IOL, string asmstr,
 218             InstrItinClass itin, list<dag> pattern>
 219          : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> {
 220   bits<5>  A;
 221   bits<21> Addr;
 222
 223   let Pattern = pattern;
 224   bits<24> LI;
 225
 226   let Inst{6-29}  = LI;
 227   let Inst{30}    = aa;
 228   let Inst{31}    = lk;
 229
 230   let Inst{38-42}  = A;
 231   let Inst{43-47} = Addr{20-16}; // Base Reg
 232   let Inst{48-63} = Addr{15-0};  // Displacement
 233 }
 234
 235 // This is used to emit BL8+NOP.
 236 class IForm_and_DForm_4_zero<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2,
 237             dag OOL, dag IOL, string asmstr,
 238             InstrItinClass itin, list<dag> pattern>
 239          :  IForm_and_DForm_1<opcode1, aa, lk, opcode2,
 240                               OOL, IOL, asmstr, itin, pattern> {
 241   let A = 0;
 242   let Addr = 0;
 243 }
 244
 245 class DForm_5<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 246               InstrItinClass itin>
 247   : I<opcode, OOL, IOL, asmstr, itin> {
 248   bits<3>  BF;
 249   bits<1>  L;
 250   bits<5>  RA;
 251   bits<16> I;
 252
 253   let Inst{6-8}   = BF;
 254   let Inst{9}     = 0;
 255   let Inst{10}    = L;
 256   let Inst{11-15} = RA;
 257   let Inst{16-31} = I;
 258 }
 259
 260 class DForm_5_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 261                   InstrItinClass itin>
 262   : DForm_5<opcode, OOL, IOL, asmstr, itin> {
 263   let L = PPC64;
 264 }
 265
 266 class DForm_6<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 267               InstrItinClass itin>
 268   : DForm_5<opcode, OOL, IOL, asmstr, itin>;
 269
 270 class DForm_6_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 271                   InstrItinClass itin>
 272   : DForm_6<opcode, OOL, IOL, asmstr, itin> {
 273   let L = PPC64;
 274 }
 275
 276
 277 // 1.7.5 DS-Form
 278 class DSForm_1<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 279                InstrItinClass itin, list<dag> pattern>
 280          : I<opcode, OOL, IOL, asmstr, itin> {
 281   bits<5>  RST;
 282   bits<19> DS_RA;
 283
 284   let Pattern = pattern;
 285
 286   let Inst{6-10}  = RST;
 287   let Inst{11-15} = DS_RA{18-14};  // Register #
 288   let Inst{16-29} = DS_RA{13-0};   // Displacement.
 289   let Inst{30-31} = xo;
 290 }
 291
 292 class DSForm_1a<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 293                 InstrItinClass itin, list<dag> pattern>
 294          : I<opcode, OOL, IOL, asmstr, itin> {
 295    bits<5>  RST;
 296    bits<14> DS;
 297    bits<5>  RA;
 298
 299    let Pattern = pattern;
 300
 301    let Inst{6-10}  = RST;
 302    let Inst{11-15} = RA;
 303    let Inst{16-29} = DS;
 304    let Inst{30-31} = xo;
 305 }
 306
 307 // 1.7.6 X-Form
 308 class XForm_base_r3xo<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 309                       InstrItinClass itin, list<dag> pattern>
 310   : I<opcode, OOL, IOL, asmstr, itin> {
 311   bits<5> RST;
 312   bits<5> A;
 313   bits<5> B;
 314
 315   let Pattern = pattern;
 316
 317   bit RC = 0;    // set by isDOT
 318
 319   let Inst{6-10}  = RST;
 320   let Inst{11-15} = A;
 321   let Inst{16-20} = B;
 322   let Inst{21-30} = xo;
 323   let Inst{31}    = RC;
 324 }
 325
 326 // This is the same as XForm_base_r3xo, but the first two operands are swapped
 327 // when code is emitted.
 328 class XForm_base_r3xo_swapped
 329         <bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 330         InstrItinClass itin>
 331   : I<opcode, OOL, IOL, asmstr, itin> {
 332   bits<5> A;
 333   bits<5> RST;
 334   bits<5> B;
 335
 336   bit RC = 0;    // set by isDOT
 337
 338   let Inst{6-10}  = RST;
 339   let Inst{11-15} = A;
 340   let Inst{16-20} = B;
 341   let Inst{21-30} = xo;
 342   let Inst{31}    = RC;
 343 }
 344
 345
 346 class XForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 347               InstrItinClass itin, list<dag> pattern>
 348   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 349
 350 class XForm_6<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 351               InstrItinClass itin, list<dag> pattern>
 352   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 353   let Pattern = pattern;
 354 }
 355
 356 class XForm_8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 357               InstrItinClass itin, list<dag> pattern>
 358   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 359
 360 class XForm_10<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 361                InstrItinClass itin, list<dag> pattern>
 362   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 363     let Pattern = pattern;
 364 }
 365
 366 class XForm_11<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 367                InstrItinClass itin, list<dag> pattern>
 368   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 369   let B = 0;
 370   let Pattern = pattern;
 371 }
 372
 373 class XForm_16<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 374                InstrItinClass itin>
 375          : I<opcode, OOL, IOL, asmstr, itin> {
 376   bits<3> BF;
 377   bits<1> L;
 378   bits<5> RA;
 379   bits<5> RB;
 380
 381   let Inst{6-8}   = BF;
 382   let Inst{9}     = 0;
 383   let Inst{10}    = L;
 384   let Inst{11-15} = RA;
 385   let Inst{16-20} = RB;
 386   let Inst{21-30} = xo;
 387   let Inst{31}    = 0;
 388 }
 389
 390 class XForm_16_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 391                    InstrItinClass itin>
 392   : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> {
 393   let L = PPC64;
 394 }
 395
 396 class XForm_17<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 397                InstrItinClass itin>
 398          : I<opcode, OOL, IOL, asmstr, itin> {
 399   bits<3> BF;
 400   bits<5> FRA;
 401   bits<5> FRB;
 402
 403   let Inst{6-8}   = BF;
 404   let Inst{9-10}  = 0;
 405   let Inst{11-15} = FRA;
 406   let Inst{16-20} = FRB;
 407   let Inst{21-30} = xo;
 408   let Inst{31}    = 0;
 409 }
 410
 411 class XForm_24<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 412                InstrItinClass itin, list<dag> pattern>
 413   : I<opcode, OOL, IOL, asmstr, itin> {
 414   let Pattern = pattern;
 415   let Inst{6-10}  = 31;
 416   let Inst{11-15} = 0;
 417   let Inst{16-20} = 0;
 418   let Inst{21-30} = xo;
 419   let Inst{31}    = 0;
 420 }
 421
 422 class XForm_24_sync<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 423                string asmstr, InstrItinClass itin, list<dag> pattern>
 424   : I<opcode, OOL, IOL, asmstr, itin> {
 425   let Pattern = pattern;
 426   let Inst{6-10}  = 0;
 427   let Inst{11-15} = 0;
 428   let Inst{16-20} = 0;
 429   let Inst{21-30} = xo;
 430   let Inst{31}    = 0;
 431 }
 432
 433 class XForm_25<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 434                InstrItinClass itin, list<dag> pattern>
 435   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 436 }
 437
 438 class XForm_26<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 439                InstrItinClass itin, list<dag> pattern>
 440   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 441   let A = 0;
 442 }
 443
 444 class XForm_28<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 445                InstrItinClass itin, list<dag> pattern>
 446   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 447 }
 448
 449 // This is used for MFFS, MTFSB0, MTFSB1.  42 is arbitrary; this series of
 450 // numbers presumably relates to some document, but I haven't found it.
 451 class XForm_42<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 452               InstrItinClass itin, list<dag> pattern>
 453   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 454   let Pattern = pattern;
 455
 456   bit RC = 0;    // set by isDOT
 457
 458   let Inst{6-10}  = RST;
 459   let Inst{11-20} = 0;
 460   let Inst{21-30} = xo;
 461   let Inst{31}    = RC;
 462 }
 463 class XForm_43<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 464               InstrItinClass itin, list<dag> pattern>
 465   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 466   let Pattern = pattern;
 467   bits<5> FM;
 468
 469   bit RC = 0;    // set by isDOT
 470
 471   let Inst{6-10}  = FM;
 472   let Inst{11-20} = 0;
 473   let Inst{21-30} = xo;
 474   let Inst{31}    = RC;
 475 }
 476
 477 // DCB_Form - Form X instruction, used for dcb* instructions.
 478 class DCB_Form<bits<10> xo, bits<5> immfield, dag OOL, dag IOL, string asmstr,
 479                       InstrItinClass itin, list<dag> pattern>
 480   : I<31, OOL, IOL, asmstr, itin> {
 481   bits<5> A;
 482   bits<5> B;
 483
 484   let Pattern = pattern;
 485
 486   let Inst{6-10}  = immfield;
 487   let Inst{11-15} = A;
 488   let Inst{16-20} = B;
 489   let Inst{21-30} = xo;
 490   let Inst{31}    = 0;
 491 }
 492
 493
 494 // DSS_Form - Form X instruction, used for altivec dss* instructions.
 495 class DSS_Form<bits<10> xo, dag OOL, dag IOL, string asmstr,
 496                       InstrItinClass itin, list<dag> pattern>
 497   : I<31, OOL, IOL, asmstr, itin> {
 498   bits<1> T;
 499   bits<2> STRM;
 500   bits<5> A;
 501   bits<5> B;
 502
 503   let Pattern = pattern;
 504
 505   let Inst{6}     = T;
 506   let Inst{7-8}   = 0;
 507   let Inst{9-10}  = STRM;
 508   let Inst{11-15} = A;
 509   let Inst{16-20} = B;
 510   let Inst{21-30} = xo;
 511   let Inst{31}    = 0;
 512 }
 513
 514 // 1.7.7 XL-Form
 515 class XLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 516                InstrItinClass itin, list<dag> pattern>
 517     : I<opcode, OOL, IOL, asmstr, itin> {
 518   bits<5> CRD;
 519   bits<5> CRA;
 520   bits<5> CRB;
 521
 522   let Pattern = pattern;
 523
 524   let Inst{6-10}  = CRD;
 525   let Inst{11-15} = CRA;
 526   let Inst{16-20} = CRB;
 527   let Inst{21-30} = xo;
 528   let Inst{31}    = 0;
 529 }
 530
 531 class XLForm_1_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 532                InstrItinClass itin, list<dag> pattern>
 533     : I<opcode, OOL, IOL, asmstr, itin> {
 534   bits<5> CRD;
 535
 536   let Pattern = pattern;
 537
 538   let Inst{6-10}  = CRD;
 539   let Inst{11-15} = CRD;
 540   let Inst{16-20} = CRD;
 541   let Inst{21-30} = xo;
 542   let Inst{31}    = 0;
 543 }
 544
 545 class XLForm_2<bits<6> opcode, bits<10> xo, bit lk, dag OOL, dag IOL, string asmstr,
 546                InstrItinClass itin, list<dag> pattern>
 547     : I<opcode, OOL, IOL, asmstr, itin> {
 548   bits<5> BO;
 549   bits<5> BI;
 550   bits<2> BH;
 551
 552   let Pattern = pattern;
 553
 554   let Inst{6-10}  = BO;
 555   let Inst{11-15} = BI;
 556   let Inst{16-18} = 0;
 557   let Inst{19-20} = BH;
 558   let Inst{21-30} = xo;
 559   let Inst{31}    = lk;
 560 }
 561
 562 class XLForm_2_br<bits<6> opcode, bits<10> xo, bit lk,
 563                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 564   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 565   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 566   bits<3>  CR;
 567
 568   let BO = BIBO{2-6};
 569   let BI{0-1} = BIBO{0-1};
 570   let BI{2-4} = CR;
 571   let BH = 0;
 572 }
 573
 574
 575 class XLForm_2_ext<bits<6> opcode, bits<10> xo, bits<5> bo,  bits<5> bi, bit lk,
 576                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 577   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 578   let BO = bo;
 579   let BI = bi;
 580   let BH = 0;
 581 }
 582
 583 class XLForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 584                InstrItinClass itin>
 585          : I<opcode, OOL, IOL, asmstr, itin> {
 586   bits<3> BF;
 587   bits<3> BFA;
 588
 589   let Inst{6-8}   = BF;
 590   let Inst{9-10}  = 0;
 591   let Inst{11-13} = BFA;
 592   let Inst{14-15} = 0;
 593   let Inst{16-20} = 0;
 594   let Inst{21-30} = xo;
 595   let Inst{31}    = 0;
 596 }
 597
 598 // 1.7.8 XFX-Form
 599 class XFXForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 600                 InstrItinClass itin>
 601          : I<opcode, OOL, IOL, asmstr, itin> {
 602   bits<5>  RT;
 603   bits<10> SPR;
 604
 605   let Inst{6-10}  = RT;
 606   let Inst{11}    = SPR{4};
 607   let Inst{12}    = SPR{3};
 608   let Inst{13}    = SPR{2};
 609   let Inst{14}    = SPR{1};
 610   let Inst{15}    = SPR{0};
 611   let Inst{16}    = SPR{9};
 612   let Inst{17}    = SPR{8};
 613   let Inst{18}    = SPR{7};
 614   let Inst{19}    = SPR{6};
 615   let Inst{20}    = SPR{5};
 616   let Inst{21-30} = xo;
 617   let Inst{31}    = 0;
 618 }
 619
 620 class XFXForm_1_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 621                    dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 622   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin> {
 623   let SPR = spr;
 624 }
 625
 626 class XFXForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 627                 InstrItinClass itin>
 628          : I<opcode, OOL, IOL, asmstr, itin> {
 629   bits<5>  RT;
 630
 631   let Inst{6-10}  = RT;
 632   let Inst{11-20} = 0;
 633   let Inst{21-30} = xo;
 634   let Inst{31}    = 0;
 635 }
 636
 637 class XFXForm_5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 638                 InstrItinClass itin>
 639   : I<opcode, OOL, IOL, asmstr, itin> {
 640   bits<8>  FXM;
 641   bits<5>  rS;
 642
 643   let Inst{6-10}  = rS;
 644   let Inst{11}    = 0;
 645   let Inst{12-19} = FXM;
 646   let Inst{20}    = 0;
 647   let Inst{21-30} = xo;
 648   let Inst{31}    = 0;
 649 }
 650
 651 class XFXForm_5a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 652                  InstrItinClass itin>
 653   : I<opcode, OOL, IOL, asmstr, itin> {
 654   bits<5>  ST;
 655   bits<8>  FXM;
 656
 657   let Inst{6-10}  = ST;
 658   let Inst{11}    = 1;
 659   let Inst{12-19} = FXM;
 660   let Inst{20}    = 0;
 661   let Inst{21-30} = xo;
 662   let Inst{31}    = 0;
 663 }
 664
 665 class XFXForm_7<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 666                 InstrItinClass itin>
 667   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin>;
 668
 669 class XFXForm_7_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 670                     dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 671   : XFXForm_7<opcode, xo, OOL, IOL, asmstr, itin> {
 672   let SPR = spr;
 673 }
 674
 675 // XFL-Form - MTFSF
 676 // This is probably 1.7.9, but I don't have the reference that uses this
 677 // numbering scheme...
 678 class XFLForm<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 679               InstrItinClass itin, list<dag>pattern>
 680   : I<opcode, OOL, IOL, asmstr, itin> {
 681   bits<8> FM;
 682   bits<5> rT;
 683
 684   bit RC = 0;    // set by isDOT
 685   let Pattern = pattern;
 686
 687   let Inst{6} = 0;
 688   let Inst{7-14}  = FM;
 689   let Inst{15} = 0;
 690   let Inst{16-20} = rT;
 691   let Inst{21-30} = xo;
 692   let Inst{31}    = RC;
 693 }
 694
 695 // 1.7.10 XS-Form - SRADI.
 696 class XSForm_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 697                InstrItinClass itin, list<dag> pattern>
 698          : I<opcode, OOL, IOL, asmstr, itin> {
 699   bits<5> A;
 700   bits<5> RS;
 701   bits<6> SH;
 702
 703   bit RC = 0;    // set by isDOT
 704   let Pattern = pattern;
 705
 706   let Inst{6-10}  = RS;
 707   let Inst{11-15} = A;
 708   let Inst{16-20} = SH{4,3,2,1,0};
 709   let Inst{21-29} = xo;
 710   let Inst{30}    = SH{5};
 711   let Inst{31}    = RC;
 712 }
 713
 714 // 1.7.11 XO-Form
 715 class XOForm_1<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL, string asmstr,
 716                InstrItinClass itin, list<dag> pattern>
 717          : I<opcode, OOL, IOL, asmstr, itin> {
 718   bits<5> RT;
 719   bits<5> RA;
 720   bits<5> RB;
 721
 722   let Pattern = pattern;
 723
 724   bit RC = 0;    // set by isDOT
 725
 726   let Inst{6-10}  = RT;
 727   let Inst{11-15} = RA;
 728   let Inst{16-20} = RB;
 729   let Inst{21}    = oe;
 730   let Inst{22-30} = xo;
 731   let Inst{31}    = RC;
 732 }
 733
 734 class XOForm_3<bits<6> opcode, bits<9> xo, bit oe,
 735                dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 736   : XOForm_1<opcode, xo, oe, OOL, IOL, asmstr, itin, pattern> {
 737   let RB = 0;
 738 }
 739
 740 // 1.7.12 A-Form
 741 class AForm_1<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 742               InstrItinClass itin, list<dag> pattern>
 743          : I<opcode, OOL, IOL, asmstr, itin> {
 744   bits<5> FRT;
 745   bits<5> FRA;
 746   bits<5> FRC;
 747   bits<5> FRB;
 748
 749   let Pattern = pattern;
 750
 751   bit RC = 0;    // set by isDOT
 752
 753   let Inst{6-10}  = FRT;
 754   let Inst{11-15} = FRA;
 755   let Inst{16-20} = FRB;
 756   let Inst{21-25} = FRC;
 757   let Inst{26-30} = xo;
 758   let Inst{31}    = RC;
 759 }
 760
 761 class AForm_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 762               InstrItinClass itin, list<dag> pattern>
 763   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 764   let FRC = 0;
 765 }
 766
 767 class AForm_3<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 768               InstrItinClass itin, list<dag> pattern>
 769   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 770   let FRB = 0;
 771 }
 772
 773 class AForm_4<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 774               InstrItinClass itin, list<dag> pattern>
 775          : I<opcode, OOL, IOL, asmstr, itin> {
 776   bits<5> RT;
 777   bits<5> RA;
 778   bits<5> RB;
 779   bits<5> COND;
 780
 781   let Pattern = pattern;
 782
 783   let Inst{6-10}  = RT;
 784   let Inst{11-15} = RA;
 785   let Inst{16-20} = RB;
 786   let Inst{21-25} = COND;
 787   let Inst{26-30} = xo;
 788   let Inst{31}    = 0;
 789 }
 790
 791 // 1.7.13 M-Form
 792 class MForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 793               InstrItinClass itin, list<dag> pattern>
 794     : I<opcode, OOL, IOL, asmstr, itin> {
 795   bits<5> RA;
 796   bits<5> RS;
 797   bits<5> RB;
 798   bits<5> MB;
 799   bits<5> ME;
 800
 801   let Pattern = pattern;
 802
 803   bit RC = 0;    // set by isDOT
 804
 805   let Inst{6-10}  = RS;
 806   let Inst{11-15} = RA;
 807   let Inst{16-20} = RB;
 808   let Inst{21-25} = MB;
 809   let Inst{26-30} = ME;
 810   let Inst{31}    = RC;
 811 }
 812
 813 class MForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 814               InstrItinClass itin, list<dag> pattern>
 815   : MForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
 816 }
 817
 818 // 1.7.14 MD-Form
 819 class MDForm_1<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, string asmstr,
 820                InstrItinClass itin, list<dag> pattern>
 821     : I<opcode, OOL, IOL, asmstr, itin> {
 822   bits<5> RA;
 823   bits<5> RS;
 824   bits<6> SH;
 825   bits<6> MBE;
 826
 827   let Pattern = pattern;
 828
 829   bit RC = 0;    // set by isDOT
 830
 831   let Inst{6-10}  = RS;
 832   let Inst{11-15} = RA;
 833   let Inst{16-20} = SH{4,3,2,1,0};
 834   let Inst{21-26} = MBE{4,3,2,1,0,5};
 835   let Inst{27-29} = xo;
 836   let Inst{30}    = SH{5};
 837   let Inst{31}    = RC;
 838 }
 839
 840
 841
 842 // E-1 VA-Form
 843
 844 // VAForm_1 - DACB ordering.
 845 class VAForm_1<bits<6> xo, dag OOL, dag IOL, string asmstr,
 846                InstrItinClass itin, list<dag> pattern>
 847     : I<4, OOL, IOL, asmstr, itin> {
 848   bits<5> VD;
 849   bits<5> VA;
 850   bits<5> VC;
 851   bits<5> VB;
 852
 853   let Pattern = pattern;
 854
 855   let Inst{6-10}  = VD;
 856   let Inst{11-15} = VA;
 857   let Inst{16-20} = VB;
 858   let Inst{21-25} = VC;
 859   let Inst{26-31} = xo;
 860 }
 861
 862 // VAForm_1a - DABC ordering.
 863 class VAForm_1a<bits<6> xo, dag OOL, dag IOL, string asmstr,
 864                 InstrItinClass itin, list<dag> pattern>
 865     : I<4, OOL, IOL, asmstr, itin> {
 866   bits<5> VD;
 867   bits<5> VA;
 868   bits<5> VB;
 869   bits<5> VC;
 870
 871   let Pattern = pattern;
 872
 873   let Inst{6-10}  = VD;
 874   let Inst{11-15} = VA;
 875   let Inst{16-20} = VB;
 876   let Inst{21-25} = VC;
 877   let Inst{26-31} = xo;
 878 }
 879
 880 class VAForm_2<bits<6> xo, dag OOL, dag IOL, string asmstr,
 881                InstrItinClass itin, list<dag> pattern>
 882     : I<4, OOL, IOL, asmstr, itin> {
 883   bits<5> VD;
 884   bits<5> VA;
 885   bits<5> VB;
 886   bits<4> SH;
 887
 888   let Pattern = pattern;
 889
 890   let Inst{6-10}  = VD;
 891   let Inst{11-15} = VA;
 892   let Inst{16-20} = VB;
 893   let Inst{21}    = 0;
 894   let Inst{22-25} = SH;
 895   let Inst{26-31} = xo;
 896 }
 897
 898 // E-2 VX-Form
 899 class VXForm_1<bits<11> xo, dag OOL, dag IOL, string asmstr,
 900                InstrItinClass itin, list<dag> pattern>
 901     : I<4, OOL, IOL, asmstr, itin> {
 902   bits<5> VD;
 903   bits<5> VA;
 904   bits<5> VB;
 905
 906   let Pattern = pattern;
 907
 908   let Inst{6-10}  = VD;
 909   let Inst{11-15} = VA;
 910   let Inst{16-20} = VB;
 911   let Inst{21-31} = xo;
 912 }
 913
 914 class VXForm_setzero<bits<11> xo, dag OOL, dag IOL, string asmstr,
 915                InstrItinClass itin, list<dag> pattern>
 916     : VXForm_1<xo, OOL, IOL, asmstr, itin, pattern> {
 917   let VA = VD;
 918   let VB = VD;
 919 }
 920
 921
 922 class VXForm_2<bits<11> xo, dag OOL, dag IOL, string asmstr,
 923                InstrItinClass itin, list<dag> pattern>
 924     : I<4, OOL, IOL, asmstr, itin> {
 925   bits<5> VD;
 926   bits<5> VB;
 927
 928   let Pattern = pattern;
 929
 930   let Inst{6-10}  = VD;
 931   let Inst{11-15} = 0;
 932   let Inst{16-20} = VB;
 933   let Inst{21-31} = xo;
 934 }
 935
 936 class VXForm_3<bits<11> xo, dag OOL, dag IOL, string asmstr,
 937                InstrItinClass itin, list<dag> pattern>
 938     : I<4, OOL, IOL, asmstr, itin> {
 939   bits<5> VD;
 940   bits<5> IMM;
 941
 942   let Pattern = pattern;
 943
 944   let Inst{6-10}  = VD;
 945   let Inst{11-15} = IMM;
 946   let Inst{16-20} = 0;
 947   let Inst{21-31} = xo;
 948 }
 949
 950 /// VXForm_4 - VX instructions with "VD,0,0" register fields, like mfvscr.
 951 class VXForm_4<bits<11> xo, dag OOL, dag IOL, string asmstr,
 952                InstrItinClass itin, list<dag> pattern>
 953     : I<4, OOL, IOL, asmstr, itin> {
 954   bits<5> VD;
 955
 956   let Pattern = pattern;
 957
 958   let Inst{6-10}  = VD;
 959   let Inst{11-15} = 0;
 960   let Inst{16-20} = 0;
 961   let Inst{21-31} = xo;
 962 }
 963
 964 /// VXForm_5 - VX instructions with "0,0,VB" register fields, like mtvscr.
 965 class VXForm_5<bits<11> xo, dag OOL, dag IOL, string asmstr,
 966                InstrItinClass itin, list<dag> pattern>
 967     : I<4, OOL, IOL, asmstr, itin> {
 968   bits<5> VB;
 969
 970   let Pattern = pattern;
 971
 972   let Inst{6-10}  = 0;
 973   let Inst{11-15} = 0;
 974   let Inst{16-20} = VB;
 975   let Inst{21-31} = xo;
 976 }
 977
 978 // E-4 VXR-Form
 979 class VXRForm_1<bits<10> xo, dag OOL, dag IOL, string asmstr,
 980                InstrItinClass itin, list<dag> pattern>
 981     : I<4, OOL, IOL, asmstr, itin> {
 982   bits<5> VD;
 983   bits<5> VA;
 984   bits<5> VB;
 985   bit RC = 0;
 986
 987   let Pattern = pattern;
 988
 989   let Inst{6-10}  = VD;
 990   let Inst{11-15} = VA;
 991   let Inst{16-20} = VB;
 992   let Inst{21}    = RC;
 993   let Inst{22-31} = xo;
 994 }
 995
 996 //===----------------------------------------------------------------------===//
 997 class Pseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern>
 998     : I<0, OOL, IOL, asmstr, NoItinerary> {
 999   let PPC64 = 0;
1000   let Pattern = pattern;
1001   let Inst{31-0} = 0;
1002 }