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